Initial commit

services/chantierTemplateService.ts

@@ -0,0 +1,169 @@
+/**
+ * Service pour la gestion des templates de chantiers et l'auto-génération des phases
+ */
+
+import { TypeChantier, PhaseTemplate, ChantierTemplate } from '../types/chantier-templates';
+import { PhaseChantier } from '../types/btp-extended';
+import phaseTemplateService from './phaseTemplateService';
+
+class ChantierTemplateService {
+    
+    /**
+     * Récupérer la liste des types de chantiers disponibles
+     */
+    async getAvailableChantierTypes(): Promise<{ value: TypeChantier; label: string; categorie: string }[]> {
+        return phaseTemplateService.getAvailableChantierTypes();
+    }
+    
+    /**
+     * Récupérer le template d'un type de chantier
+     */
+    async getTemplate(typeChantier: TypeChantier): Promise<ChantierTemplate> {
+        const templates = await phaseTemplateService.getTemplatesByType(typeChantier);
+        const dureeTotal = await phaseTemplateService.calculateDureeTotale(typeChantier);
+        
+        // Construire un ChantierTemplate à partir des données API
+        return {
+            typeChantier,
+            nom: typeChantier,
+            description: `Template pour ${typeChantier}`,
+            dureeMoyenneJours: dureeTotal,
+            phases: templates
+        };
+    }
+    
+    /**
+     * Estimer la durée d'un projet selon son type
+     */
+    async estimateProjectDuration(typeChantier: TypeChantier): Promise<number> {
+        return phaseTemplateService.calculateDureeTotale(typeChantier);
+    }
+    
+    /**
+     * Générer automatiquement les phases d'un chantier
+     */
+    async generatePhases(
+        chantierId: string, 
+        typeChantier: TypeChantier, 
+        dateDebutProjet: Date,
+        options?: {
+            ajusterDelais?: boolean;
+            inclureSousPhases?: boolean;
+            personnaliser?: boolean;
+        }
+    ): Promise<PhaseChantier[]> {
+        
+        try {
+            // Utiliser l'API backend pour générer les phases
+            const phasesGenerees = await phaseTemplateService.generatePhases(
+                chantierId,
+                dateDebutProjet,
+                options?.inclureSousPhases !== false // Par défaut true
+            );
+            
+            return phasesGenerees;
+            
+        } catch (error) {
+            console.error('Erreur lors de la génération des phases:', error);
+            throw new Error('Impossible de générer les phases automatiquement');
+        }
+    }
+    
+    /**
+     * Prévisualiser les phases qui seraient générées (sans les créer)
+     */
+    async previewPhases(typeChantier: TypeChantier, dateDebutProjet: Date): Promise<PhaseTemplate[]> {
+        return phaseTemplateService.previewPhases(typeChantier);
+    }
+    
+    /**
+     * Obtenir les spécificités d'un type de chantier
+     */
+    async getSpecificites(typeChantier: TypeChantier): Promise<string[]> {
+        const template = await this.getTemplate(typeChantier);
+        return template.specificites || [];
+    }
+    
+    /**
+     * Obtenir les réglementations applicables
+     */
+    async getReglementations(typeChantier: TypeChantier): Promise<string[]> {
+        const template = await this.getTemplate(typeChantier);
+        return template.reglementations || [];
+    }
+    
+    /**
+     * Calculer le planning prévisionnel complet
+     */
+    async calculatePlanning(typeChantier: TypeChantier, dateDebutProjet: Date): Promise<{
+        dateDebut: Date;
+        dateFin: Date;
+        dureeJours: number;
+        phases: Array<{
+            nom: string;
+            dateDebut: Date;
+            dateFin: Date;
+            duree: number;
+            critique: boolean;
+        }>;
+    }> {
+        const template = await this.getTemplate(typeChantier);
+        let currentDate = new Date(dateDebutProjet);
+        
+        const phases = template.phases.map(phase => {
+            const phaseDebut = new Date(currentDate);
+            const phaseFin = new Date(currentDate);
+            phaseFin.setDate(phaseFin.getDate() + phase.dureePrevueJours);
+            
+            const phaseInfo = {
+                nom: phase.nom,
+                dateDebut: phaseDebut,
+                dateFin: phaseFin,
+                duree: phase.dureePrevueJours,
+                critique: phase.critique
+            };
+            
+            currentDate = new Date(phaseFin);
+            return phaseInfo;
+        });
+        
+        return {
+            dateDebut: dateDebutProjet,
+            dateFin: currentDate,
+            dureeJours: template.dureeMoyenneJours,
+            phases
+        };
+    }
+    
+    /**
+     * Analyser la complexité d'un projet
+     */
+    async analyzeComplexity(typeChantier: TypeChantier): Promise<{
+        niveau: 'SIMPLE' | 'MOYEN' | 'COMPLEXE' | 'TRES_COMPLEXE';
+        score: number;
+        facteurs: string[];
+    }> {
+        const complexiteAPI = await phaseTemplateService.analyzeComplexity(typeChantier);
+        
+        // Calculer des facteurs supplémentaires basés sur les données
+        const facteurs: string[] = [];
+        
+        if (complexiteAPI.nombrePhases > 8) facteurs.push('Nombreuses phases');
+        if (complexiteAPI.dureeTotal > 365) facteurs.push('Durée longue');
+        if (complexiteAPI.nombrePhasesCritiques > 3) facteurs.push('Phases critiques multiples');
+        
+        // Calculer un score basé sur les données API
+        let score = 0;
+        score += complexiteAPI.nombrePhases * 2;
+        score += Math.floor(complexiteAPI.dureeTotal / 30);
+        score += complexiteAPI.nombrePhasesCritiques * 3;
+        
+        return {
+            niveau: complexiteAPI.niveauComplexite as 'SIMPLE' | 'MOYEN' | 'COMPLEXE' | 'TRES_COMPLEXE',
+            score,
+            facteurs
+        };
+    }
+}
+
+export default new ChantierTemplateService();