feat: Sauvegarde des formulaires d'école dans les bons dossiers /

utilisation des bons composants dans les modales [N3WTS-17]

Back-End/Subscriptions/models.py

@@ -318,20 +318,27 @@ class RegistrationForm(models.Model):
 ####### Formulaires masters (documents école, à signer ou pas) #######
 def registration_school_file_master_upload_to(instance, filename):
     # Stocke les fichiers masters dans un dossier dédié
-    return f"registration_files/school_file_masters/{instance.pk}/{filename}"
+    # Utilise l'ID si le nom n'est pas encore disponible
+    est_name = None
+    if instance.establishment and instance.establishment.name:
+        est_name = instance.establishment.name
+    else:
+        # fallback si pas d'établissement (devrait être rare)
+        est_name = "unknown_establishment"
+    return f"{est_name}/Formulaires/{filename}"
 
 class RegistrationSchoolFileMaster(models.Model):
     groups = models.ManyToManyField(RegistrationFileGroup, related_name='school_file_masters', blank=True)
     name = models.CharField(max_length=255, default="")
     is_required = models.BooleanField(default=False)
     formMasterData = models.JSONField(default=list, blank=True, null=True)
-    # Nouveau champ pour formulaire existant (PDF, DOC, etc.)
     file = models.FileField(
         upload_to=registration_school_file_master_upload_to,
         null=True,
         blank=True,
         help_text="Fichier du formulaire existant (PDF, DOC, etc.)"
     )
+    establishment = models.ForeignKey('Establishment.Establishment', on_delete=models.CASCADE, related_name='school_file_masters', null=True, blank=True)
 
     def __str__(self):
         return f'{self.name} - {self.id}'
@@ -342,6 +349,131 @@ class RegistrationSchoolFileMaster(models.Model):
             return self.file.url
         return None
 
+    def save(self, *args, **kwargs):
+        import os
+        affected_rf_ids = set()
+        is_new = self.pk is None
+
+        super().save(*args, **kwargs)
+
+        # 2. Gestion des groupes pour la synchro des templates
+        if is_new:
+            from Subscriptions.models import RegistrationForm
+            new_groups = set(self.groups.values_list('id', flat=True))
+            affected_rf_ids.update(
+                RegistrationForm.objects.filter(fileGroup__in=list(new_groups)).values_list('pk', flat=True)
+            )
+        else:
+            try:
+                old = RegistrationSchoolFileMaster.objects.get(pk=self.pk)
+                old_groups = set(old.groups.values_list('id', flat=True))
+                new_groups = set(self.groups.values_list('id', flat=True))
+                from Subscriptions.models import RegistrationForm
+                affected_rf_ids.update(
+                    RegistrationForm.objects.filter(fileGroup__in=list(old_groups | new_groups)).values_list('pk', flat=True)
+                )
+                form_data_changed = (
+                    old.formMasterData != self.formMasterData
+                    and self.formMasterData
+                    and isinstance(self.formMasterData, dict)
+                    and self.formMasterData.get("fields")
+                )
+                name_changed = old.name != self.name
+                # --- Correction spécifique pour les fichiers existants (PDF, DOC, etc.) ---
+                # Si le nom change et qu'on a un fichier existant, on doit renommer physiquement le fichier
+                if old.file and not self.file and name_changed:
+                    old_file_path = old.file.path
+                    ext = os.path.splitext(old_file_path)[1]
+                    clean_name = (self.name or 'document').replace(' ', '_').replace('/', '_')
+                    new_filename = f"{clean_name}{ext}"
+                    new_rel_path = os.path.join(os.path.dirname(old.file.name), new_filename)
+                    new_abs_path = os.path.join(os.path.dirname(old_file_path), new_filename)
+                    logger.info(f"Renommage fichier: {old_file_path} -> {new_abs_path}")
+                    try:
+                        if not os.path.exists(new_abs_path):
+                            os.rename(old_file_path, new_abs_path)
+                            self.file.name = new_rel_path
+                            logger.info(f"self.file.name après renommage: {self.file.name}")
+                            super().save(update_fields=["file"])
+                        else:
+                            logger.info(f"Le fichier cible existe déjà: {new_abs_path}")
+                    except Exception as e:
+                        logger.error(f"Erreur lors du renommage du fichier master: {e}")
+                elif old.file and self.file and self.file != old.file:
+                    old.file.delete(save=False)
+                elif old.file and form_data_changed:
+                    old.file.delete(save=False)
+                    self.file = None
+            except RegistrationSchoolFileMaster.DoesNotExist:
+                pass
+
+        # Harmonisation : gestion du fichier (dynamique ou existant) sans appeler registration_school_file_master_upload_to
+        # Pour les formulaires dynamiques (PDF à générer)
+        if not self.file and self.formMasterData and isinstance(self.formMasterData, dict) and self.formMasterData.get("fields"):
+            try:
+                from Subscriptions.util import generate_form_json_pdf
+                pdf_filename = f"{self.name or 'formulaire'}.pdf"
+                abs_path = os.path.join(settings.MEDIA_ROOT, self.file.field.upload_to(self, pdf_filename))
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                if os.path.exists(abs_path):
+                    try:
+                        os.remove(abs_path)
+                        logger.info(f"Suppression fichier existant: {abs_path}")
+                    except Exception as e:
+                        logger.error(f"Erreur suppression fichier existant avant save: {e}")
+                pdf_file = generate_form_json_pdf(self, self.formMasterData)
+                logger.info(f"Sauvegarde PDF dynamique: {pdf_filename}")
+                self.file.save(pdf_filename, pdf_file, save=False)
+                logger.info(f"self.file.name après save PDF dynamique: {self.file.name}")
+                super().save(update_fields=["file"])
+            except Exception as e:
+                logger.error(f"Erreur lors de la génération automatique du PDF pour le master {self.pk}: {e}")
+        # Pour les fichiers existants uploadés
+        elif self.file and hasattr(self.file, 'name') and self.name:
+            # On force le nom du fichier (nom du master + extension) si besoin
+            ext = os.path.splitext(self.file.name)[1]
+            clean_name = (self.name or 'document').replace(' ', '_').replace('/', '_')
+            final_file_name = f"{clean_name}{ext}"
+            # Si le nom ne correspond pas, on renomme le fichier physique et le FileField
+            if os.path.basename(self.file.name) != final_file_name:
+                current_path = self.file.path
+                abs_path = os.path.join(settings.MEDIA_ROOT, self.file.field.upload_to(self, final_file_name))
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                if os.path.exists(abs_path):
+                    try:
+                        os.remove(abs_path)
+                        logger.info(f"Suppression fichier existant: {abs_path}")
+                    except Exception as e:
+                        logger.error(f"Erreur suppression fichier existant avant renommage: {e}")
+                try:
+                    os.rename(current_path, abs_path)
+                    self.file.name = os.path.relpath(abs_path, settings.MEDIA_ROOT)
+                    logger.info(f"Déplacement fichier existant: {current_path} -> {abs_path}")
+                    super().save(update_fields=["file"])
+                except Exception as e:
+                    logger.error(f"Erreur lors du déplacement du fichier existant: {e}")
+
+        # 4. Synchronisation des templates pour tous les dossiers d'inscription concernés (création ou modification)
+        try:
+            from Subscriptions.util import create_templates_for_registration_form
+            from Subscriptions.models import RegistrationForm
+            for rf_id in affected_rf_ids:
+                try:
+                    rf = RegistrationForm.objects.get(pk=rf_id)
+                    create_templates_for_registration_form(rf)
+                except Exception as e:
+                    logger.error(f"Erreur lors de la synchronisation des templates pour RF {rf_id} après modification du master {self.pk}: {e}")
+        except Exception as e:
+            logger.error(f"Erreur globale lors de la synchronisation des templates après modification du master {self.pk}: {e}")
+    def delete(self, *args, **kwargs):
+        # Supprimer le fichier physique du master si présent
+        if self.file and hasattr(self.file, 'path') and os.path.exists(self.file.path):
+            try:
+                self.file.delete(save=False)
+            except Exception as e:
+                logger.error(f"Erreur lors de la suppression du fichier master: {e}")
+        super().delete(*args, **kwargs)
+
 ####### Parent files masters (documents à fournir par les parents) #######
 class RegistrationParentFileMaster(models.Model):
     groups = models.ManyToManyField(RegistrationFileGroup, related_name='parent_file_masters', blank=True)
@@ -354,7 +486,7 @@ class RegistrationParentFileMaster(models.Model):
 ############################################################
 
 def registration_school_file_upload_to(instance, filename):
-    return f"registration_files/{instance.registration_form.establishment.name}/dossier_rf_{instance.registration_form.pk}/school/{filename}"
+    return f"{instance.registration_form.establishment.name}/dossier_{instance.registration_form.student.last_name}_{instance.registration_form.student.first_name}/{filename}"
 
 def registration_parent_file_upload_to(instance, filename):
     return f"registration_files/{instance.registration_form.establishment.name}/dossier_rf_{instance.registration_form.pk}/parent/{filename}"

Back-End/Subscriptions/util.py

@@ -109,6 +109,7 @@ def create_templates_for_registration_form(register_form):
     )
 
     created = []
+    logger.info("util.create_templates_for_registration_form - create_templates_for_registration_form")
 
     # Récupérer les masters du fileGroup courant
     current_group = getattr(register_form, "fileGroup", None)
@@ -135,6 +136,7 @@ def create_templates_for_registration_form(register_form):
 
     school_masters = RegistrationSchoolFileMaster.objects.filter(groups=current_group).distinct()
     parent_masters = RegistrationParentFileMaster.objects.filter(groups=current_group).distinct()
+    logger.info("util.create_templates_for_registration_form - school_masters récupérés")
 
     school_master_ids = {m.pk for m in school_masters}
     parent_master_ids = {m.pk for m in parent_masters}
@@ -162,6 +164,7 @@ def create_templates_for_registration_form(register_form):
             logger.info("Deleted obsolete parent template %s for RF %s", getattr(tmpl, "pk", None), register_form.pk)
 
     # Créer les school templates manquants
+    logger.info("util.create_templates_for_registration_form - Créer les school templates manquants")
     for m in school_masters:
         exists = RegistrationSchoolFileTemplate.objects.filter(master=m, registration_form=register_form).exists()
         if exists:
@@ -169,44 +172,61 @@ def create_templates_for_registration_form(register_form):
         base_slug = (m.name or "master").strip().replace(" ", "_")[:40]
         slug = f"{base_slug}_{register_form.pk}_{m.pk}"
 
-        # Si le master a un fichier uploadé (formulaire existant)
-        file_to_attach = None
-        if m.file:
-            import os
-            from django.core.files import File as DjangoFile
-            master_file_path = m.file.path
-            if os.path.exists(master_file_path):
-                filename = os.path.basename(master_file_path)
-                # Générer le chemin cible pour le template élève
-                dest_path = registration_school_file_upload_to(None, filename)
-                dest_dir = os.path.dirname(os.path.join(settings.MEDIA_ROOT, dest_path))
-                os.makedirs(dest_dir, exist_ok=True)
-                # Copier le fichier dans le dossier cible
-                dest_full_path = os.path.join(settings.MEDIA_ROOT, dest_path)
-                with open(master_file_path, 'rb') as src, open(dest_full_path, 'wb') as dst:
-                    dst.write(src.read())
-                # Préparer le File Django à attacher au template
-                with open(dest_full_path, 'rb') as f:
-                    file_to_attach = DjangoFile(f, name=dest_path)
+        # --- Correction : Générer un nom de fichier unique uniquement si le master n'a pas de fichier ---
+        file_name = None
+        if m.file and hasattr(m.file, 'name') and m.file.name:
+            # Utiliser le nom du fichier tel qu'il est stocké dans le master (pas de suffixe aléatoire ici)
+            file_name = os.path.basename(m.file.name)
+            logger.info(f"util.create_templates_for_registration_form - file_name 1 : {file_name}")
+        elif m.file:
+            file_name = str(m.file)
         else:
-            # Générer le PDF du template à partir du JSON du master
+            # Générer le PDF si besoin (rare ici)
             try:
                 pdf_file = generate_form_json_pdf(register_form, m.formMasterData)
-                file_to_attach = pdf_file
+                file_name = os.path.basename(pdf_file.name)
             except Exception as e:
                 logger.error(f"Erreur lors de la génération du PDF pour le template: {e}")
-                file_to_attach = None
+                file_name = None
 
-        tmpl = RegistrationSchoolFileTemplate.objects.create(
+        logger.info(f"util.create_templates_for_registration_form - file_name : {file_name}")
+
+        tmpl = RegistrationSchoolFileTemplate(
             master=m,
             registration_form=register_form,
             name=m.name or "",
             formTemplateData=m.formMasterData or [],
             slug=slug,
-            file=file_to_attach,
         )
+        if file_name:
+            from django.core.files.base import ContentFile
+            # Vérifier si le fichier existe déjà dans MEDIA_ROOT (copie du master)
+            upload_rel_path = registration_school_file_upload_to(
+                type("Tmp", (), {
+                    "registration_form": register_form,
+                    "establishment": getattr(register_form, "establishment", None),
+                    "student": getattr(register_form, "student", None)
+                })(),
+                file_name
+            )
+            abs_path = os.path.join(settings.MEDIA_ROOT, upload_rel_path)
+            master_file_path = m.file.path if m.file and hasattr(m.file, 'path') else None
+
+            # Si le fichier n'existe pas dans le dossier cible, le copier depuis le master
+            if master_file_path and not os.path.exists(abs_path):
+                try:
+                    import shutil
+                    os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                    shutil.copy2(master_file_path, abs_path)
+                    logger.info(f"util.create_templates_for_registration_form - Copie du fichier master {master_file_path} -> {abs_path}")
+                except Exception as e:
+                    logger.error(f"Erreur lors de la copie du fichier master pour le template: {e}")
+
+            # Associer le fichier existant (ou copié) au template
+            tmpl.file.name = upload_rel_path
+        tmpl.save()
         created.append(tmpl)
-        logger.info("Created school template %s from master %s for RF %s", tmpl.pk, m.pk, register_form.pk)
+        logger.info("util.create_templates_for_registration_form - Created school template %s from master %s for RF %s", tmpl.pk, m.pk, register_form.pk)
 
     # Créer les parent templates manquants
     for m in parent_masters:

Back-End/Subscriptions/views/registration_school_file_masters_views.py

@@ -139,6 +139,7 @@ class RegistrationSchoolFileMasterSimpleView(APIView):
 
             # Pour chaque RF appartenant aux groupes retirés -> nettoyer les templates (idempotent)
             if removed_group_ids:
+                logger.info("REMOVE IDs")
                 try:
                     rfs_removed = RegistrationForm.objects.filter(fileGroup__in=list(removed_group_ids)).distinct()
                     for rf in rfs_removed:
@@ -151,6 +152,7 @@ class RegistrationSchoolFileMasterSimpleView(APIView):
 
             # Pour chaque RF appartenant aux groupes ajoutés -> créer les templates manquants
             if added_group_ids:
+                logger.info("ADD IDs")
                 try:
                     rfs_added = RegistrationForm.objects.filter(fileGroup__in=list(added_group_ids)).distinct()
                     for rf in rfs_added: