@rsuci/shared-form-components 1.0.28 → 1.0.32

package/dist/lib/utils/groupeInstanceManager.js

@@ -0,0 +1,606 @@
+/**
+ * Gestionnaire des instances multiples pour les groupes d'enquête
+ * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ */
+export class GroupeInstanceManager {
+    /**
+     * Récupère le nombre maximum d'instances autorisées depuis la variable de contrôle
+     * RÈGLE DE PROTECTION : Ne jamais permettre de réduire sous le nombre d'instances existantes
+     */
+    static getMaxInstances(groupe, responses) {
+        if (!groupe.estMultiple || !groupe.codeVariable) {
+            console.log('GroupeInstanceManager.getMaxInstances - Groupe non multiple ou sans variable de contrôle:', {
+                estMultiple: groupe.estMultiple,
+                codeVariable: groupe.codeVariable,
+                groupeCode: groupe.code
+            });
+            return 1;
+        }
+        console.log('GroupeInstanceManager.getMaxInstances - Recherche variable de contrôle:', {
+            groupeCode: groupe.code,
+            codeVariable: groupe.codeVariable,
+            responsesKeys: Object.keys(responses),
+            responses: responses
+        });
+        // Chercher la réponse de la variable de contrôle
+        // D'abord essayer avec la clé directe
+        let controlResponse = responses[groupe.codeVariable];
+        // Si pas trouvé, chercher dans toutes les réponses par variableCode
+        if (!controlResponse) {
+            const foundResponse = Object.values(responses).find(response => response.variableCode === groupe.codeVariable);
+            if (foundResponse) {
+                controlResponse = foundResponse;
+            }
+            console.log('GroupeInstanceManager.getMaxInstances - Recherche par variableCode:', {
+                found: !!foundResponse,
+                controlResponse: foundResponse
+            });
+        }
+        const controlValue = controlResponse?.valeur;
+        console.log('GroupeInstanceManager.getMaxInstances - Valeur de contrôle trouvée:', {
+            controlResponse: controlResponse,
+            controlValue: controlValue,
+            valueType: typeof controlValue
+        });
+        // Convertir la valeur en nombre
+        let maxFromControl = 1; // Valeur par défaut
+        if (typeof controlValue === 'number') {
+            maxFromControl = controlValue;
+        }
+        else if (typeof controlValue === 'string') {
+            const parsed = parseInt(controlValue, 10);
+            if (!isNaN(parsed)) {
+                maxFromControl = parsed;
+            }
+        }
+        // PROTECTION DES DONNÉES : Obtenir le nombre d'instances existantes
+        const existingInstancesCount = groupe.instances?.length || 0;
+        // Le maximum effectif est au moins égal au nombre d'instances existantes
+        const protectedMax = Math.max(maxFromControl, existingInstancesCount);
+        console.log('GroupeInstanceManager.getMaxInstances - Résultat avec protection:', {
+            groupeCode: groupe.code,
+            codeVariable: groupe.codeVariable,
+            maxFromControl: maxFromControl,
+            existingInstancesCount: existingInstancesCount,
+            protectedMax: protectedMax,
+            isProtectionActive: protectedMax > maxFromControl
+        });
+        // S'assurer qu'on a au moins 1 instance
+        return Math.max(1, protectedMax);
+    }
+    /**
+     * Récupère le nombre minimum d'instances (basé sur les instances existantes)
+     */
+    static getMinInstances(groupe) {
+        if (!groupe.estMultiple) {
+            return 1;
+        }
+        const existingInstances = groupe.instances?.length || 0;
+        return Math.max(1, existingInstances);
+    }
+    /**
+     * Compte le nombre d'instances existantes pour un groupe
+     */
+    static getInstancesCount(groupe, responses) {
+        if (!groupe.estMultiple) {
+            return 1;
+        }
+        console.log('GroupeInstanceManager.getInstancesCount - Début:', {
+            groupeCode: groupe.code,
+            variableCodes: groupe.variables.map(v => v.code),
+            responsesKeys: Object.keys(responses)
+        });
+        // Compter les instances basées sur les réponses
+        const instanceNumbers = new Set();
+        // Méthode 1: Par numeroMembre
+        groupe.variables.forEach(variable => {
+            Object.values(responses).forEach(response => {
+                if (response.variableCode === variable.code && response.numeroMembre) {
+                    instanceNumbers.add(response.numeroMembre);
+                }
+            });
+        });
+        // Méthode 2: Par clé avec format "CODE_NUMERO"
+        groupe.variables.forEach(variable => {
+            Object.keys(responses).forEach(key => {
+                const response = responses[key];
+                if (response.variableCode === variable.code) {
+                    // Extraire le numéro d'instance de la clé si elle suit le format "CODE_NUMERO"
+                    const keyParts = key.split('_');
+                    if (keyParts.length >= 2) {
+                        const lastPart = keyParts[keyParts.length - 1];
+                        const instanceNum = parseInt(lastPart, 10);
+                        if (!isNaN(instanceNum) && instanceNum > 0) {
+                            instanceNumbers.add(instanceNum);
+                        }
+                    }
+                }
+            });
+        });
+        const count = Math.max(1, instanceNumbers.size);
+        console.log('GroupeInstanceManager.getInstancesCount - Résultat:', {
+            groupeCode: groupe.code,
+            instanceNumbers: Array.from(instanceNumbers).sort(),
+            finalCount: count
+        });
+        return count;
+    }
+    /**
+     * Crée une nouvelle instance pour un groupe multiple
+     */
+    static createInstance(groupe, numeroInstance) {
+        const libelle = `${groupe.designation} ${numeroInstance}`;
+        return {
+            numeroInstance,
+            libelle,
+            estComplete: false,
+            reponses: {}
+        };
+    }
+    /**
+     * Initialise les instances pour un groupe multiple
+     */
+    static initializeInstances(groupe, responses) {
+        if (!groupe.estMultiple) {
+            return [];
+        }
+        console.log('GroupeInstanceManager.initializeInstances - Début:', {
+            groupeCode: groupe.code,
+            codeVariable: groupe.codeVariable,
+            responsesKeys: Object.keys(responses),
+            allResponses: responses
+        });
+        // Identifier toutes les instances existantes pour ce groupe
+        const instanceNumbers = new Set();
+        // Collecter les réponses existantes pour ce groupe (avec et sans numeroMembre)
+        const groupResponses = [];
+        // Parcourir toutes les réponses pour trouver celles de ce groupe
+        Object.values(responses).forEach(response => {
+            const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
+            if (belongsToGroup) {
+                groupResponses.push(response);
+                if (response.numeroMembre) {
+                    instanceNumbers.add(response.numeroMembre);
+                }
+            }
+        });
+        // Aussi chercher par clé avec format "CODE_NUMERO"
+        Object.keys(responses).forEach(key => {
+            const response = responses[key];
+            const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
+            if (belongsToGroup) {
+                // Extraire le numéro d'instance de la clé si elle suit le format "CODE_NUMERO"
+                const keyParts = key.split('_');
+                if (keyParts.length >= 2) {
+                    const lastPart = keyParts[keyParts.length - 1];
+                    const instanceNum = parseInt(lastPart, 10);
+                    if (!isNaN(instanceNum) && instanceNum > 0) {
+                        instanceNumbers.add(instanceNum);
+                    }
+                }
+            }
+        });
+        console.log('GroupeInstanceManager.initializeInstances - Données trouvées:', {
+            groupeCode: groupe.code,
+            instanceNumbers: Array.from(instanceNumbers).sort(),
+            groupResponsesCount: groupResponses.length,
+            responsesWithNumeroMembre: groupResponses.filter(r => r.numeroMembre).length,
+            responsesWithoutNumeroMembre: groupResponses.filter(r => !r.numeroMembre).length
+        });
+        const maxInstances = this.getMaxInstances(groupe, responses);
+        // Déterminer le nombre d'instances à créer
+        let instanceCount = Math.max(1, instanceNumbers.size);
+        // CORRECTION: Ne pas forcer la création de maxInstances instances
+        // Respecter la limite de la variable de contrôle
+        instanceCount = Math.min(instanceCount, maxInstances);
+        // Si aucune instance existante, créer au moins 1 instance
+        if (instanceCount === 0) {
+            instanceCount = 1;
+        }
+        console.log('GroupeInstanceManager.initializeInstances - Calcul instances:', {
+            groupeCode: groupe.code,
+            maxInstances,
+            existingInstancesCount: instanceNumbers.size,
+            finalInstanceCount: instanceCount
+        });
+        const instances = [];
+        // Séparer les réponses avec et sans numeroMembre
+        const responsesWithMember = groupResponses.filter(r => r.numeroMembre);
+        const responsesWithoutMember = groupResponses.filter(r => !r.numeroMembre);
+        for (let i = 1; i <= instanceCount; i++) {
+            const instance = this.createInstance(groupe, i);
+            // Remplir les réponses existantes pour cette instance
+            groupe.variables.forEach(variable => {
+                let existingResponse;
+                // 1. Chercher d'abord par numeroMembre
+                existingResponse = responsesWithMember.find(r => r.variableCode === variable.code && r.numeroMembre === i);
+                // 2. Si pas trouvé, chercher par clé avec format "CODE_NUMERO"
+                if (!existingResponse) {
+                    const keyWithInstance = `${variable.code}_${i}`;
+                    existingResponse = responses[keyWithInstance];
+                }
+                // 3. Si toujours pas trouvé et qu'on a des réponses sans numeroMembre,
+                // les distribuer aux instances (première instance = première réponse, etc.)
+                if (!existingResponse && responsesWithoutMember.length > 0) {
+                    // Pour la première instance, prendre les réponses sans numeroMembre
+                    if (i === 1) {
+                        existingResponse = responsesWithoutMember.find(r => r.variableCode === variable.code);
+                        if (existingResponse) {
+                            console.log('GroupeInstanceManager.initializeInstances - Attribution réponse sans numeroMembre:', {
+                                groupeCode: groupe.code,
+                                instanceNumber: i,
+                                variableCode: variable.code,
+                                originalResponse: existingResponse
+                            });
+                            // Créer une copie avec numeroMembre pour cette instance
+                            existingResponse = {
+                                ...existingResponse,
+                                numeroMembre: i
+                            };
+                        }
+                    }
+                }
+                if (existingResponse) {
+                    console.log('GroupeInstanceManager.initializeInstances - Réponse trouvée:', {
+                        groupeCode: groupe.code,
+                        instanceNumber: i,
+                        variableCode: variable.code,
+                        hasNumeroMembre: !!existingResponse.numeroMembre,
+                        response: existingResponse
+                    });
+                    instance.reponses[variable.code] = existingResponse;
+                }
+            });
+            // Vérifier si l'instance est complète
+            instance.estComplete = this.isInstanceComplete(instance, groupe);
+            instances.push(instance);
+            console.log('GroupeInstanceManager.initializeInstances - Instance créée:', {
+                groupeCode: groupe.code,
+                instanceNumber: i,
+                responsesCount: Object.keys(instance.reponses).length,
+                isComplete: instance.estComplete
+            });
+        }
+        console.log('GroupeInstanceManager.initializeInstances - Résultat final:', {
+            groupeCode: groupe.code,
+            instancesCreated: instances.length,
+            instances: instances.map(inst => ({
+                numero: inst.numeroInstance,
+                responsesCount: Object.keys(inst.reponses).length,
+                isComplete: inst.estComplete
+            }))
+        });
+        return instances;
+    }
+    /**
+     * Vérifie si une instance est complètement renseignée
+     */
+    static isInstanceComplete(instance, groupe) {
+        const requiredVariables = groupe.variables.filter(v => v.estObligatoire);
+        return requiredVariables.every(variable => {
+            const response = instance.reponses[variable.code];
+            return response && response.valeur !== null && response.valeur !== '';
+        });
+    }
+    /**
+     * Valide si on peut ajouter une nouvelle instance
+     */
+    static canAddInstance(groupe, responses) {
+        const constraints = [];
+        if (!groupe.estMultiple) {
+            constraints.push({
+                type: 'instance_limit',
+                groupeCode: groupe.code,
+                message: 'Ce groupe ne supporte pas les instances multiples'
+            });
+            return {
+                isValid: false,
+                errors: [],
+                constraints,
+                canProceed: false
+            };
+        }
+        const currentCount = this.getInstancesCount(groupe, responses);
+        const maxInstances = this.getMaxInstances(groupe, responses);
+        if (currentCount >= maxInstances) {
+            constraints.push({
+                type: 'instance_limit',
+                groupeCode: groupe.code,
+                variableCode: groupe.codeVariable,
+                currentValue: currentCount,
+                requiredValue: maxInstances,
+                message: `Maximum ${maxInstances} instances autorisées (variable ${groupe.codeVariable})`
+            });
+            return {
+                isValid: false,
+                errors: [],
+                constraints,
+                canProceed: false
+            };
+        }
+        return {
+            isValid: true,
+            errors: [],
+            constraints: [],
+            canProceed: true
+        };
+    }
+    /**
+     * Valide si on peut supprimer une instance
+     */
+    static canRemoveInstance(groupe, responses) {
+        const constraints = [];
+        // CORRECTION: Utiliser le nombre d'instances du groupe directement
+        const currentCount = groupe.instances?.length || 0;
+        console.log('GroupeInstanceManager.canRemoveInstance - Debug:', {
+            groupeCode: groupe.code,
+            instancesLength: groupe.instances?.length,
+            currentCount,
+            canRemove: currentCount > 1
+        });
+        if (currentCount <= 1) {
+            constraints.push({
+                type: 'instance_limit',
+                groupeCode: groupe.code,
+                currentValue: currentCount,
+                requiredValue: 1,
+                message: 'Au moins une instance doit être conservée'
+            });
+            return {
+                isValid: false,
+                errors: [],
+                constraints,
+                canProceed: false
+            };
+        }
+        return {
+            isValid: true,
+            errors: [],
+            constraints: [],
+            canProceed: true
+        };
+    }
+    /**
+     * Valide si on peut modifier la variable de contrôle
+     */
+    static canModifyControlVariable(variableCode, newValue, groupesMultiples, responses) {
+        const constraints = [];
+        // Trouver tous les groupes qui utilisent cette variable de contrôle
+        const affectedGroups = groupesMultiples.filter(g => g.codeVariable === variableCode);
+        for (const groupe of affectedGroups) {
+            const existingInstances = this.getInstancesCount(groupe, responses);
+            if (newValue < existingInstances) {
+                constraints.push({
+                    type: 'bidirectional_control',
+                    variableCode,
+                    groupeCode: groupe.code,
+                    currentValue: newValue,
+                    requiredValue: existingInstances,
+                    message: `Impossible de réduire à ${newValue}. Le groupe "${groupe.designation}" a déjà ${existingInstances} instances créées.`
+                });
+            }
+        }
+        if (constraints.length > 0) {
+            return {
+                isValid: false,
+                errors: [],
+                constraints,
+                canProceed: false
+            };
+        }
+        return {
+            isValid: true,
+            errors: [],
+            constraints: [],
+            canProceed: true
+        };
+    }
+    /**
+     * Ajoute une nouvelle instance à un groupe
+     */
+    static addInstance(groupe, responses) {
+        const validation = this.canAddInstance(groupe, responses);
+        if (!validation.canProceed) {
+            return {
+                success: false,
+                error: validation.constraints[0]?.message || 'Impossible d\'ajouter une instance'
+            };
+        }
+        // CORRECTION: Calculer le bon numéro d'instance
+        if (!groupe.instances) {
+            groupe.instances = [];
+        }
+        const newInstanceNumber = groupe.instances.length + 1;
+        const newInstance = this.createInstance(groupe, newInstanceNumber);
+        // Ajouter l'instance au groupe
+        groupe.instances.push(newInstance);
+        // Mettre à jour les propriétés calculées
+        groupe.instancesCount = groupe.instances.length;
+        console.log('GroupeInstanceManager.addInstance - Instance ajoutée:', {
+            groupeCode: groupe.code,
+            newInstanceNumber,
+            totalInstances: groupe.instances.length,
+            maxInstances: this.getMaxInstances(groupe, responses)
+        });
+        return {
+            success: true,
+            instance: newInstance
+        };
+    }
+    /**
+     * Supprime une instance d'un groupe
+     */
+    static removeInstance(groupe, instanceNumber, responses) {
+        const validation = this.canRemoveInstance(groupe, responses);
+        if (!validation.canProceed) {
+            return {
+                success: false,
+                error: validation.constraints[0]?.message || 'Impossible de supprimer cette instance'
+            };
+        }
+        // Supprimer l'instance du tableau
+        if (groupe.instances) {
+            groupe.instances = groupe.instances.filter(i => i.numeroInstance !== instanceNumber);
+            groupe.instancesCount = groupe.instances.length;
+        }
+        // Supprimer les réponses associées à cette instance
+        Object.keys(responses).forEach(key => {
+            const response = responses[key];
+            if (response.numeroMembre === instanceNumber) {
+                // Trouver si cette réponse appartient à ce groupe
+                const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
+                if (belongsToGroup) {
+                    delete responses[key];
+                }
+            }
+        });
+        // Réorganiser les instances pour maintenir une numérotation séquentielle
+        this.reorderInstances(groupe, responses);
+        return {
+            success: true
+        };
+    }
+    /**
+     * Met à jour les propriétés calculées d'un groupe multiple
+     */
+    static updateGroupeProperties(groupe, responses) {
+        if (!groupe.estMultiple) {
+            return;
+        }
+        groupe.maxInstances = this.getMaxInstances(groupe, responses);
+        groupe.minInstances = this.getMinInstances(groupe);
+        // Initialiser les instances si elles n'existent pas
+        if (!groupe.instances) {
+            groupe.instances = this.initializeInstances(groupe, responses);
+        }
+        // PROTECTION DES DONNÉES : Ne plus supprimer automatiquement les instances
+        // La logique de protection est maintenant dans getMaxInstances()
+        console.log('GroupeInstanceManager.updateGroupeProperties - Protection des données active:', {
+            groupeCode: groupe.code,
+            currentInstances: groupe.instances.length,
+            maxInstances: groupe.maxInstances,
+            protectionActive: groupe.instances.length > 0
+        });
+        groupe.instancesCount = groupe.instances.length;
+        // Mettre à jour le statut de completion des instances
+        groupe.instances.forEach(instance => {
+            instance.estComplete = this.isInstanceComplete(instance, groupe);
+        });
+    }
+    /**
+     * Synchronise les réponses d'une instance avec le store global
+     */
+    static syncInstanceResponses(instance, groupe, globalResponses) {
+        // Copier les réponses de l'instance vers le store global
+        Object.entries(instance.reponses).forEach(([variableCode, response]) => {
+            const globalKey = `${variableCode}_${instance.numeroInstance}`;
+            globalResponses[globalKey] = {
+                ...response,
+                numeroMembre: instance.numeroInstance
+            };
+        });
+        // Copier les réponses du store global vers l'instance
+        groupe.variables.forEach(variable => {
+            const existingResponse = Object.values(globalResponses).find(r => r.variableCode === variable.code && r.numeroMembre === instance.numeroInstance);
+            if (existingResponse) {
+                instance.reponses[variable.code] = existingResponse;
+            }
+        });
+    }
+    /**
+     * Valide la navigation vers l'instance suivante
+     */
+    static canNavigateToNextInstance(currentInstance, groupe) {
+        const constraints = [];
+        if (!this.isInstanceComplete(currentInstance, groupe)) {
+            const requiredVariables = groupe.variables.filter(v => v.estObligatoire);
+            const missingVariables = requiredVariables.filter(v => {
+                const response = currentInstance.reponses[v.code];
+                return !response || response.valeur === null || response.valeur === '';
+            });
+            constraints.push({
+                type: 'navigation_block',
+                groupeCode: groupe.code,
+                message: `Veuillez renseigner tous les champs obligatoires de cette instance avant de continuer. Champs manquants: ${missingVariables.map(v => v.designation).join(', ')}`
+            });
+            return {
+                isValid: false,
+                errors: [],
+                constraints,
+                canProceed: false
+            };
+        }
+        return {
+            isValid: true,
+            errors: [],
+            constraints: [],
+            canProceed: true
+        };
+    }
+    /**
+     * Trouve la prochaine instance incomplète dans un groupe
+     */
+    static findNextIncompleteInstance(groupe) {
+        if (!groupe.instances) {
+            return null;
+        }
+        return groupe.instances.find(instance => !instance.estComplete) || null;
+    }
+    /**
+     * Calcule la progression d'un groupe multiple
+     */
+    static calculateGroupProgress(groupe) {
+        if (!groupe.estMultiple || !groupe.instances) {
+            return {
+                completedInstances: 0,
+                totalInstances: 1,
+                progressPercentage: 0
+            };
+        }
+        const completedInstances = groupe.instances.filter(i => i.estComplete).length;
+        const totalInstances = groupe.instances.length;
+        const progressPercentage = totalInstances > 0 ? (completedInstances / totalInstances) * 100 : 0;
+        return {
+            completedInstances,
+            totalInstances,
+            progressPercentage
+        };
+    }
+    /**
+     * Réorganise les numéros d'instances après suppression
+     */
+    static reorderInstances(groupe, responses) {
+        if (!groupe.instances) {
+            return;
+        }
+        // Trier les instances par numéro
+        groupe.instances.sort((a, b) => a.numeroInstance - b.numeroInstance);
+        // Réassigner les numéros séquentiellement
+        groupe.instances.forEach((instance, index) => {
+            const newNumber = index + 1;
+            const oldNumber = instance.numeroInstance;
+            if (newNumber !== oldNumber) {
+                // Mettre à jour le numéro de l'instance
+                instance.numeroInstance = newNumber;
+                instance.libelle = `${groupe.designation} ${newNumber}`;
+                // Mettre à jour les réponses dans le store global
+                Object.keys(responses).forEach(key => {
+                    const response = responses[key];
+                    if (response.numeroMembre === oldNumber) {
+                        const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
+                        if (belongsToGroup) {
+                            response.numeroMembre = newNumber;
+                            // Mettre à jour la clé si nécessaire
+                            delete responses[key];
+                            responses[`${response.variableCode}_${newNumber}`] = response;
+                        }
+                    }
+                });
+                // Mettre à jour les réponses dans l'instance
+                Object.keys(instance.reponses).forEach(variableCode => {
+                    instance.reponses[variableCode].numeroMembre = newNumber;
+                });
+            }
+        });
+    }
+}