Merge remote-tracking branch 'origin/WIP_Inscriptions' into develop

Back-End/N3wtSchool/renderers.py

@@ -4,11 +4,22 @@ from django.template.loader import get_template
 
 from xhtml2pdf import pisa
 
+class PDFResult:
+    def __init__(self, content):
+        self.content = content
+
 def render_to_pdf(template_src, context_dict={}):
+    """
+    Génère un PDF à partir d'un template HTML et retourne le contenu en mémoire.
+    """
     template = get_template(template_src)
-    html  = template.render(context_dict)
+    html = template.render(context_dict)
     result = BytesIO()
     pdf = pisa.pisaDocument(BytesIO(html.encode("UTF-8")), result)
+    
     if pdf.err:
-        return HttpResponse("Invalid PDF", status_code=400, content_type='text/plain')
-    return HttpResponse(result.getvalue(), content_type='application/pdf')
+        # Lever une exception ou retourner None en cas d'erreur
+        raise ValueError("Erreur lors de la génération du PDF.")
+
+    # Retourner le contenu du PDF en mémoire
+    return PDFResult(result.getvalue())

Back-End/School/management/commands/init_mock_datas.py

@@ -6,8 +6,8 @@ from Subscriptions.models import (
     Fee,
     Discount,
     RegistrationFileGroup,
-    RegistrationTemplateMaster,
-    RegistrationTemplate
+    RegistrationSchoolFileMaster,
+    RegistrationSchoolFileTemplate
 )
 from Auth.models import Profile, ProfileRole
 from School.models import (

Back-End/Subscriptions/models.py

@@ -9,6 +9,8 @@ from Establishment.models import Establishment
 
 from datetime import datetime
 
+import os
+
 class Language(models.Model):
     """
     Représente une langue parlée par l’élève.
@@ -83,7 +85,7 @@ class Student(models.Model):
     siblings = models.ManyToManyField(Sibling, blank=True)
 
     # Many-to-Many Relationship
-    registration_files = models.ManyToManyField('RegistrationTemplate', blank=True, related_name='students')
+    registration_files = models.ManyToManyField('RegistrationSchoolFileTemplate', blank=True, related_name='students')
 
     # Many-to-Many Relationship
     spoken_languages = models.ManyToManyField(Language, blank=True)
@@ -163,19 +165,13 @@ class RegistrationFileGroup(models.Model):
     def __str__(self):
         return self.name
 
+    def __str__(self):
+        return f'{self.group.name} - {self.id}'
+
 def registration_file_path(instance, filename):
     # Génère le chemin : registration_files/dossier_rf_{student_id}/filename
     return f'registration_files/dossier_rf_{instance.student_id}/{filename}'
 
-class RegistrationTemplateMaster(models.Model):
-    groups = models.ManyToManyField(RegistrationFileGroup, related_name='template_masters', blank=True)
-    id = models.IntegerField(primary_key=True)
-    name = models.CharField(max_length=255, default="")
-    is_required = models.BooleanField(default=False)
-
-    def __str__(self):
-        return f'{self.group.name} - {self.id}'
-
 class RegistrationForm(models.Model):
     class RegistrationFormStatus(models.IntegerChoices):
         RF_IDLE = 0, _('Pas de dossier d\'inscription')
@@ -211,7 +207,7 @@ class RegistrationForm(models.Model):
     # Many-to-Many Relationship
     discounts = models.ManyToManyField(Discount, blank=True, related_name='register_forms')
     fileGroup = models.ForeignKey(RegistrationFileGroup,
-                                 on_delete=models.CASCADE,
+                                 on_delete=models.SET_NULL,
                                  related_name='register_forms',
                                  null=True,
                                  blank=True)
@@ -223,16 +219,58 @@ class RegistrationForm(models.Model):
     def __str__(self):
         return "RF_" + self.student.last_name + "_" + self.student.first_name
 
-def registration_file_upload_to(instance, filename):
-    return f"registration_files/dossier_rf_{instance.registration_form.pk}/{filename}"
+    def save(self, *args, **kwargs):
+        # Vérifier si un fichier existant doit être remplacé
+        if self.pk:  # Si l'objet existe déjà dans la base de données
+            try:
+                old_instance = RegistrationForm.objects.get(pk=self.pk)
+                if old_instance.sepa_file and old_instance.sepa_file != self.sepa_file:
+                    # Supprimer l'ancien fichier
+                    old_instance.sepa_file.delete(save=False)
+            except RegistrationForm.DoesNotExist:
+                pass  # L'objet n'existe pas encore, rien à supprimer
 
-class RegistrationTemplate(models.Model):
-    master = models.ForeignKey(RegistrationTemplateMaster, on_delete=models.CASCADE, related_name='templates', blank=True)
+        # Appeler la méthode save originale
+        super().save(*args, **kwargs)
+
+def registration_school_file_upload_to(instance, filename):
+    return f"registration_files/dossier_rf_{instance.registration_form.pk}/school/{filename}"
+
+def registration_parent_file_upload_to(instance, filename):
+    return f"registration_files/dossier_rf_{instance.registration_form.pk}/parent/{filename}"
+
+#############################################################
+####################### MASTER FILES ########################
+#############################################################
+
+####### DocuSeal masters (documents école, à signer ou pas) #######
+class RegistrationSchoolFileMaster(models.Model):
+    groups = models.ManyToManyField(RegistrationFileGroup, related_name='school_file_masters', blank=True)
+    id = models.IntegerField(primary_key=True)
+    name = models.CharField(max_length=255, default="")
+    is_required = models.BooleanField(default=False)
+
+    def __str__(self):
+        return f'{self.group.name} - {self.id}'
+
+####### Parent files masters (documents à fournir par les parents) #######
+class RegistrationParentFileMaster(models.Model):
+    groups = models.ManyToManyField(RegistrationFileGroup, related_name='parent_file_masters', blank=True)
+    name = models.CharField(max_length=255, default="")
+    description = models.CharField(blank=True, null=True)
+
+############################################################
+####################### CLONE FILES ########################
+############################################################
+
+####### DocuSeal templates (par dossier d'inscription) #######
+class RegistrationSchoolFileTemplate(models.Model):
+    master = models.ForeignKey(RegistrationSchoolFileMaster, on_delete=models.CASCADE, related_name='school_file_templates', blank=True)
     id = models.IntegerField(primary_key=True)
     slug = models.CharField(max_length=255, default="")
     name = models.CharField(max_length=255, default="")
-    registration_form = models.ForeignKey(RegistrationForm, on_delete=models.CASCADE, related_name='templates', blank=True)
-    file = models.FileField(null=True,blank=True, upload_to=registration_file_upload_to)
+    registration_form = models.ForeignKey(RegistrationForm, on_delete=models.CASCADE, related_name='school_file_templates', blank=True)
+    file = models.FileField(null=True,blank=True, upload_to=registration_school_file_upload_to)
 
     def __str__(self):
         return self.name
@@ -242,8 +280,42 @@ class RegistrationTemplate(models.Model):
         """
         Récupère tous les fichiers liés à un dossier d’inscription donné.
         """
-        registration_files = RegistrationTemplate.objects.filter(registration_form=register_form_id)
+        registration_files = RegistrationSchoolFileTemplate.objects.filter(registration_form=register_form_id)
         filenames = []
         for reg_file in registration_files:
             filenames.append(reg_file.file.path)
-        return filenames
+        return filenames
+
+####### Parent files templates (par dossier d'inscription) #######
+class RegistrationParentFileTemplate(models.Model):
+    master = models.ForeignKey(RegistrationParentFileMaster, on_delete=models.CASCADE, related_name='parent_file_templates', blank=True)
+    registration_form = models.ForeignKey(RegistrationForm, on_delete=models.CASCADE, related_name='parent_file_templates', blank=True)
+    file = models.FileField(null=True,blank=True, upload_to=registration_parent_file_upload_to)
+
+    def __str__(self):
+        return self.name
+
+    def save(self, *args, **kwargs):
+        if self.pk:  # Si l'objet existe déjà dans la base de données
+            try:
+                old_instance = RegistrationParentFileTemplate.objects.get(pk=self.pk)
+                if old_instance.file and (not self.file or self.file.name == ''):
+                    if os.path.exists(old_instance.file.path):
+                        old_instance.file.delete(save=False)
+                        self.file = None
+                    else:
+                        print(f"Le fichier {old_instance.file.path} n'existe pas.")
+            except RegistrationParentFileTemplate.DoesNotExist:
+                print("Ancienne instance introuvable.")
+        super().save(*args, **kwargs)
+
+    @staticmethod
+    def get_files_from_rf(register_form_id):
+        """
+        Récupère tous les fichiers liés à un dossier d’inscription donné.
+        """
+        registration_files = RegistrationParentFileTemplate.objects.filter(registration_form=register_form_id)
+        filenames = []
+        for reg_file in registration_files:
+            filenames.append(reg_file.file.path)
+        return filenames

Back-End/Subscriptions/serializers.py

@@ -1,5 +1,5 @@
 from rest_framework import serializers
-from .models import RegistrationFileGroup, RegistrationForm, Student, Guardian, Sibling, Language, RegistrationTemplateMaster, RegistrationTemplate
+from .models import RegistrationFileGroup, RegistrationForm, Student, Guardian, Sibling, Language, RegistrationSchoolFileMaster, RegistrationSchoolFileTemplate, RegistrationParentFileMaster, RegistrationParentFileTemplate
 from School.models import SchoolClass, Fee, Discount, FeeType
 from School.serializers import FeeSerializer, DiscountSerializer
 from Auth.models import ProfileRole, Profile
@@ -12,18 +12,43 @@ import pytz
 from datetime import datetime
 import Subscriptions.util as util
 
-class RegistrationTemplateMasterSerializer(serializers.ModelSerializer):
+class RegistrationSchoolFileMasterSerializer(serializers.ModelSerializer):
     id = serializers.IntegerField(required=False)
     class Meta:
-        model = RegistrationTemplateMaster
+        model = RegistrationSchoolFileMaster
         fields = '__all__'
 
-class RegistrationTemplateSerializer(serializers.ModelSerializer):
+class RegistrationParentFileMasterSerializer(serializers.ModelSerializer):
     id = serializers.IntegerField(required=False)
     class Meta:
-        model = RegistrationTemplate
+        model = RegistrationParentFileMaster
         fields = '__all__'
 
+class RegistrationSchoolFileTemplateSerializer(serializers.ModelSerializer):
+    id = serializers.IntegerField(required=False)
+    file_url = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RegistrationSchoolFileTemplate
+        fields = '__all__'
+
+    def get_file_url(self, obj):
+        # Retourne l'URL complète du fichier si disponible
+        return obj.file.url if obj.file else None
+
+class RegistrationParentFileTemplateSerializer(serializers.ModelSerializer):
+    id = serializers.IntegerField(required=False)
+    file_url = serializers.SerializerMethodField()
+    master_name = serializers.CharField(source='master.name', read_only=True)
+    master_description = serializers.CharField(source='master.description', read_only=True)
+    class Meta:
+        model = RegistrationParentFileTemplate
+        fields = '__all__'
+
+    def get_file_url(self, obj):
+        # Retourne l'URL complète du fichier si disponible
+        return obj.file.url if obj.file else None
+
 class GuardianSimpleSerializer(serializers.ModelSerializer):
     associated_profile_email = serializers.SerializerMethodField()
 
@@ -199,7 +224,7 @@ class RegistrationFormSerializer(serializers.ModelSerializer):
     sepa_file = serializers.FileField(required=False)
     status_label = serializers.SerializerMethodField()
     formatted_last_update = serializers.SerializerMethodField()
-    registration_files = RegistrationTemplateSerializer(many=True, required=False)
+    registration_files = RegistrationSchoolFileTemplateSerializer(many=True, required=False)
     fees = serializers.PrimaryKeyRelatedField(queryset=Fee.objects.all(), many=True, required=False)
     discounts = serializers.PrimaryKeyRelatedField(queryset=Discount.objects.all(), many=True, required=False)
     totalRegistrationFees = serializers.SerializerMethodField()
@@ -280,7 +305,7 @@ class RegistrationFormByParentSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = RegistrationForm
-        fields = ['student', 'status']
+        fields = ['student', 'status', 'sepa_file']
 
     def __init__(self, *args, **kwargs):
         super(RegistrationFormByParentSerializer, self).__init__(*args, **kwargs)

Back-End/Subscriptions/urls.py

@@ -7,16 +7,27 @@ from .views import RegisterFormView, RegisterFormWithIdView, send, resend, archi
 # SubClasses
 from .views import StudentView, GuardianView, ChildrenListView, StudentListView, DissociateGuardianView
 # Files
-from .views import RegistrationTemplateMasterView, RegistrationTemplateMasterSimpleView, RegistrationTemplateView, RegistrationTemplateSimpleView
+from .views import (
+    RegistrationSchoolFileMasterView, 
+    RegistrationSchoolFileMasterSimpleView, 
+    RegistrationSchoolFileTemplateView, 
+    RegistrationSchoolFileTemplateSimpleView, 
+    RegistrationParentFileMasterSimpleView, 
+    RegistrationParentFileMasterView,
+    RegistrationParentFileTemplateSimpleView,
+    RegistrationParentFileTemplateView
+)
+
 from .views import RegistrationFileGroupView, RegistrationFileGroupSimpleView, get_registration_files_by_group
-from .views import registration_file_views, get_templates_by_rf
+from .views import registration_file_views, get_school_file_templates_by_rf, get_parent_file_templates_by_rf
 
 urlpatterns = [
     re_path(r'^registerForms/(?P<id>[0-9]+)/archive$', archive, name="archive"),
     re_path(r'^registerForms/(?P<id>[0-9]+)/resend$', resend, name="resend"),
     re_path(r'^registerForms/(?P<id>[0-9]+)/send$', send, name="send"),
     re_path(r'^registerForms/(?P<id>[0-9]+)$', RegisterFormWithIdView.as_view(), name="registerForm"),
-    re_path(r'^registerForms/(?P<id>[0-9]+)/templates$', get_templates_by_rf, name="get_templates_by_rf"),
+    re_path(r'^registerForms/(?P<id>[0-9]+)/school_file_templates$', get_school_file_templates_by_rf, name="get_school_file_templates_by_rf"),
+    re_path(r'^registerForms/(?P<id>[0-9]+)/parent_file_templates$', get_parent_file_templates_by_rf, name="get_parent_file_templates_by_rf"),
     re_path(r'^registerForms$', RegisterFormView.as_view(), name="registerForms"),
 
     # Page INSCRIPTION - Liste des élèves
@@ -33,11 +44,17 @@ urlpatterns = [
     re_path(r'^registrationFileGroups/(?P<id>[0-9]+)/templates$', get_registration_files_by_group, name="get_registration_files_by_group"),
     re_path(r'^registrationFileGroups$', RegistrationFileGroupView.as_view(), name='registrationFileGroups'),
     
-    re_path(r'^registrationTemplateMasters/(?P<id>[0-9]+)$', RegistrationTemplateMasterSimpleView.as_view(), name='registrationTemplateMasters'),
-    re_path(r'^registrationTemplateMasters$', RegistrationTemplateMasterView.as_view(), name='registrationTemplateMasters'),
+    re_path(r'^registrationSchoolFileMasters/(?P<id>[0-9]+)$', RegistrationSchoolFileMasterSimpleView.as_view(), name='registrationSchoolFileMasters'),
+    re_path(r'^registrationSchoolFileMasters$', RegistrationSchoolFileMasterView.as_view(), name='registrationSchoolFileMasters'),
 
-    re_path(r'^registrationTemplates/(?P<id>[0-9]+)$', RegistrationTemplateSimpleView.as_view(), name='registrationTemplates'),
-    re_path(r'^registrationTemplates$', RegistrationTemplateView.as_view(), name="registrationTemplates"),
+    re_path(r'^registrationParentFileMasters/(?P<id>[0-9]+)$', RegistrationParentFileMasterSimpleView.as_view(), name='registrationParentFileMasters'),
+    re_path(r'^registrationParentFileMasters$', RegistrationParentFileMasterView.as_view(), name="registrationParentFileMasters"),
+
+    re_path(r'^registrationSchoolFileTemplates/(?P<id>[0-9]+)$', RegistrationSchoolFileTemplateSimpleView.as_view(), name='registrationSchoolFileTemplates'),
+    re_path(r'^registrationSchoolFileTemplates$', RegistrationSchoolFileTemplateView.as_view(), name="registrationSchoolFileTemplates"),
+
+    re_path(r'^registrationParentFileTemplates/(?P<id>[0-9]+)$', RegistrationParentFileTemplateSimpleView.as_view(), name='registrationParentFileTemplates'),
+    re_path(r'^registrationParentFileTemplates$', RegistrationParentFileTemplateView.as_view(), name="registrationSchoolFileTregistrationParentFileTemplatesemplates"),
 
     re_path(r'^students/(?P<student_id>[0-9]+)/guardians/(?P<guardian_id>[0-9]+)/dissociate', DissociateGuardianView.as_view(), name='dissociate-guardian'),
 

Back-End/Subscriptions/util.py

@@ -19,6 +19,9 @@ from rest_framework.parsers import JSONParser
 from PyPDF2 import PdfMerger
 
 import shutil
+import logging
+
+logger = logging.getLogger(__name__)
 
 def recupereListeFichesInscription():
     """
@@ -121,7 +124,6 @@ def rfToPDF(registerForm, filename):
     Génère le PDF d'un dossier d'inscription et l'associe au RegistrationForm.
     """
     filename = filename.replace(" ", "_")
-    
     data = {
         'pdf_title': f"Dossier d'inscription de {registerForm.student.first_name}",
         'signatureDate': convertToStr(_now(), '%d-%m-%Y'),
@@ -131,20 +133,37 @@ def rfToPDF(registerForm, filename):
 
     # Générer le PDF
     pdf = renderers.render_to_pdf('pdfs/dossier_inscription.html', data)
+    if not pdf:
+        raise ValueError("Erreur lors de la génération du PDF.")
 
     # Vérifier si un fichier avec le même nom existe déjà et le supprimer
-    if registerForm.registration_file and os.path.exists(registerForm.registration_file.path):
-        os.remove(registerForm.registration_file.path)
-        registerForm.registration_file.delete(save=False)
+    if registerForm.registration_file and registerForm.registration_file.name:
+        # Vérifiez si le chemin est déjà absolu ou relatif
+        if os.path.isabs(registerForm.registration_file.name):
+            existing_file_path = registerForm.registration_file.name
+        else:
+            existing_file_path = os.path.join(settings.MEDIA_ROOT, registerForm.registration_file.name.lstrip('/'))
+
+        # Vérifier si le fichier existe et le supprimer
+        if os.path.exists(existing_file_path):
+            print(f'exist ! REMOVE')
+            os.remove(existing_file_path)
+            registerForm.registration_file.delete(save=False)
+        else:
+            print(f'File does not exist: {existing_file_path}')
 
     # Enregistrer directement le fichier dans le champ registration_file
-    registerForm.registration_file.save(
-        os.path.basename(filename),
-        File(BytesIO(pdf.content)),  # Utilisation de BytesIO pour éviter l'écriture sur le disque
-        save=True
-    )
+    try:
+        registerForm.registration_file.save(
+            os.path.basename(filename),  # Utiliser uniquement le nom de fichier
+            File(BytesIO(pdf.content)),
+            save=True
+        )
+    except Exception as e:
+        logger.error(f"Erreur lors de la sauvegarde du fichier PDF : {e}")
+        raise
 
-    return registerForm.registration_file.path
+    return registerForm.registration_file
 
 def delete_registration_files(registerForm):
     """

Back-End/Subscriptions/views/__init__.py

@@ -1,5 +1,14 @@
-from .register_form_views import RegisterFormView, RegisterFormWithIdView, send, resend, archive, get_templates_by_rf
-from .registration_file_views import RegistrationTemplateMasterView, RegistrationTemplateMasterSimpleView, RegistrationTemplateView, RegistrationTemplateSimpleView
+from .register_form_views import RegisterFormView, RegisterFormWithIdView, send, resend, archive, get_school_file_templates_by_rf, get_parent_file_templates_by_rf
+from .registration_file_views import (
+    RegistrationSchoolFileMasterView, 
+    RegistrationSchoolFileMasterSimpleView, 
+    RegistrationSchoolFileTemplateView, 
+    RegistrationSchoolFileTemplateSimpleView, 
+    RegistrationParentFileMasterView, 
+    RegistrationParentFileMasterSimpleView,
+    RegistrationParentFileTemplateSimpleView,
+    RegistrationParentFileTemplateView
+)
 from .registration_file_group_views import RegistrationFileGroupView, RegistrationFileGroupSimpleView, get_registration_files_by_group
 from .student_views import StudentView, StudentListView, ChildrenListView
 from .guardian_views import GuardianView, DissociateGuardianView
@@ -10,14 +19,19 @@ __all__ = [
     'send',
     'resend',
     'archive',
-    'RegistrationTemplateView',
-    'RegistrationTemplateSimpleView',
-    'RegistrationTemplateMasterView',
-    'RegistrationTemplateMasterSimpleView',
+    'RegistrationSchoolFileTemplateView',
+    'RegistrationSchoolFileTemplateSimpleView',
+    'RegistrationParentFileMasterSimpleView',
+    'RegistrationParentFileMasterView',
+    'RegistrationSchoolFileMasterView',
+    'RegistrationSchoolFileMasterSimpleView',
+    'RegistrationParentFileTemplateSimpleView',
+    'RegistrationParentFileTemplateView',
     'RegistrationFileGroupView',
     'RegistrationFileGroupSimpleView',
     'get_registration_files_by_group',
-    'get_templates_by_rf',
+    'get_school_file_templates_by_rf',
+    'get_parent_file_templates_by_rf'
     'StudentView',
     'StudentListView',
     'ChildrenListView',

Back-End/Subscriptions/views/register_form_views.py

@@ -14,9 +14,9 @@ from django.core.files import File
 import Subscriptions.mailManager as mailer
 import Subscriptions.util as util
 
-from Subscriptions.serializers import RegistrationFormSerializer
+from Subscriptions.serializers import RegistrationFormSerializer, RegistrationSchoolFileTemplateSerializer, RegistrationParentFileTemplateSerializer
 from Subscriptions.pagination import CustomPagination
-from Subscriptions.models import Student, Guardian, RegistrationForm, RegistrationTemplate, RegistrationFileGroup
+from Subscriptions.models import Student, Guardian, RegistrationForm, RegistrationSchoolFileTemplate, RegistrationFileGroup, RegistrationParentFileTemplate
 from Subscriptions.automate import updateStateMachine
 
 from N3wtSchool import settings, bdd
@@ -254,30 +254,37 @@ class RegisterFormWithIdView(APIView):
         if _status == RegistrationForm.RegistrationFormStatus.RF_UNDER_REVIEW:
             try:
                 # Génération de la fiche d'inscription au format PDF
-                base_dir = f"data/registration_files/dossier_rf_{registerForm.pk}"
+                base_dir = os.path.join(settings.MEDIA_ROOT, f"registration_files/dossier_rf_{registerForm.pk}")
                 os.makedirs(base_dir, exist_ok=True)
 
                 # Fichier PDF initial
-                initial_pdf = f"{base_dir}/rf_{registerForm.student.last_name}_{registerForm.student.first_name}.pdf"
+                initial_pdf = f"{base_dir}/Inscription_{registerForm.student.last_name}_{registerForm.student.first_name}.pdf"
                 registerForm.registration_file = util.rfToPDF(registerForm, initial_pdf)
                 registerForm.save()
 
                 # Récupération des fichiers d'inscription
-                fileNames = RegistrationTemplate.get_files_from_rf(registerForm.pk)
-                if registerForm.registration_file:
-                  fileNames.insert(0, registerForm.registration_file.path)
+                # fileNames = RegistrationSchoolFileTemplate.get_files_from_rf(registerForm.pk)
+                # if registerForm.registration_file:
+                #   fileNames.insert(0, registerForm.registration_file.path)
 
-                # Création du fichier PDF Fusionné
-                merged_pdf_content = util.merge_files_pdf(fileNames)
+                # # Création du fichier PDF Fusionné
+                # merged_pdf_content = util.merge_files_pdf(fileNames)
 
-                # Mise à jour du champ registration_file avec le fichier fusionné
-                registerForm.registration_file.save(
-                    f"dossier_complet_{registerForm.pk}.pdf",
-                    File(merged_pdf_content),
-                    save=True
-                )
+                # # Mise à jour du champ registration_file avec le fichier fusionné
+                # registerForm.registration_file.save(
+                #     f"dossier_complet.pdf",
+                #     File(merged_pdf_content),
+                #     save=True
+                # )
+                
                 # Mise à jour de l'automate
-                updateStateMachine(registerForm, 'EVENT_SIGNATURE')
+                # Vérification de la présence du fichier SEPA
+                if registerForm.sepa_file:
+                    # Mise à jour de l'automate pour SEPA
+                    updateStateMachine(registerForm, 'EVENT_SIGNATURE_SEPA')
+                else:
+                    # Mise à jour de l'automate pour une signature classique
+                    updateStateMachine(registerForm, 'EVENT_SIGNATURE')
             except Exception as e:
                 return JsonResponse({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
@@ -413,10 +420,40 @@ def resend(request,id):
     operation_summary="Récupérer les fichiers à signer d'un dossier d'inscription donné"
 )
 @api_view(['GET'])
-def get_templates_by_rf(request, id):
+def get_school_file_templates_by_rf(request, id):
     try:
-        templates = RegistrationTemplate.objects.filter(registration_form=id)
-        templates_data = list(templates.values())
-        return JsonResponse(templates_data, safe=False)
-    except RegistrationFileGroup.DoesNotExist:
-        return JsonResponse({'error': 'Le groupe de fichiers n\'a pas été trouvé'}, status=404)
+        # Récupérer les templates associés au RegistrationForm donné
+        templates = RegistrationSchoolFileTemplate.objects.filter(registration_form=id)
+        
+        # Sérialiser les données
+        serializer = RegistrationSchoolFileTemplateSerializer(templates, many=True)
+        
+        # Retourner les données sérialisées
+        return JsonResponse(serializer.data, safe=False)
+    except RegistrationSchoolFileTemplate.DoesNotExist:
+        return JsonResponse({'error': 'Aucun template trouvé pour ce dossier d\'inscription'}, status=status.HTTP_404_NOT_FOUND)
+    
+@swagger_auto_schema(
+    method='get',
+    responses={200: openapi.Response('Success', schema=openapi.Schema(
+        type=openapi.TYPE_OBJECT,
+        properties={
+            'message': openapi.Schema(type=openapi.TYPE_STRING)
+        }
+    ))},
+    operation_description="Récupère les pièces à fournir d'un dossier d'inscription donné",
+    operation_summary="Récupérer les pièces à fournir d'un dossier d'inscription donné"
+)
+@api_view(['GET'])
+def get_parent_file_templates_by_rf(request, id):
+    try:
+        # Récupérer les pièces à fournir associés au RegistrationForm donné
+        parent_files = RegistrationParentFileTemplate.objects.filter(registration_form=id)
+        
+        # Sérialiser les données
+        serializer = RegistrationParentFileTemplateSerializer(parent_files, many=True)
+        
+        # Retourner les données sérialisées
+        return JsonResponse(serializer.data, safe=False)
+    except RegistrationParentFileTemplate.DoesNotExist:
+        return JsonResponse({'error': 'Aucune pièce à fournir trouvée pour ce dossier d\'inscription'}, status=status.HTTP_404_NOT_FOUND)

Back-End/Subscriptions/views/registration_file_group_views.py

@@ -8,7 +8,7 @@ from drf_yasg.utils import swagger_auto_schema
 from drf_yasg import openapi
 
 from Subscriptions.serializers import RegistrationFileGroupSerializer
-from Subscriptions.models import RegistrationFileGroup, RegistrationTemplateMaster
+from Subscriptions.models import RegistrationFileGroup, RegistrationSchoolFileMaster
 from N3wtSchool import bdd
 
 class RegistrationFileGroupView(APIView):
@@ -124,7 +124,7 @@ class RegistrationFileGroupSimpleView(APIView):
 def get_registration_files_by_group(request, id):
     try:
         group = RegistrationFileGroup.objects.get(id=id)
-        templateMasters = RegistrationTemplateMaster.objects.filter(groups=group)
+        templateMasters = RegistrationSchoolFileMaster.objects.filter(groups=group)
         templates_data = list(templateMasters.values())
         return JsonResponse(templates_data, safe=False)
     except RegistrationFileGroup.DoesNotExist:

Back-End/Subscriptions/views/registration_file_views.py

@@ -6,64 +6,64 @@ from rest_framework.response import Response
 from rest_framework.views import APIView
 from rest_framework import status
 
-from Subscriptions.serializers import RegistrationTemplateMasterSerializer, RegistrationTemplateSerializer
-from Subscriptions.models import RegistrationTemplateMaster, RegistrationTemplate
+from Subscriptions.serializers import RegistrationSchoolFileMasterSerializer, RegistrationSchoolFileTemplateSerializer, RegistrationParentFileMasterSerializer, RegistrationParentFileTemplateSerializer
+from Subscriptions.models import RegistrationSchoolFileMaster, RegistrationSchoolFileTemplate, RegistrationParentFileMaster, RegistrationParentFileTemplate
 from N3wtSchool import bdd
 
-class RegistrationTemplateMasterView(APIView):
+class RegistrationSchoolFileMasterView(APIView):
     @swagger_auto_schema(
         operation_description="Récupère tous les masters de templates d'inscription",
-        responses={200: RegistrationTemplateMasterSerializer(many=True)}
+        responses={200: RegistrationSchoolFileMasterSerializer(many=True)}
     )
     def get(self, request):
-        masters = RegistrationTemplateMaster.objects.all()
-        serializer = RegistrationTemplateMasterSerializer(masters, many=True)
+        masters = RegistrationSchoolFileMaster.objects.all()
+        serializer = RegistrationSchoolFileMasterSerializer(masters, many=True)
         return Response(serializer.data)
 
     @swagger_auto_schema(
         operation_description="Crée un nouveau master de template d'inscription",
-        request_body=RegistrationTemplateMasterSerializer,
+        request_body=RegistrationSchoolFileMasterSerializer,
         responses={
-            201: RegistrationTemplateMasterSerializer,
+            201: RegistrationSchoolFileMasterSerializer,
             400: "Données invalides"
         }
     )
     def post(self, request):
-        serializer = RegistrationTemplateMasterSerializer(data=request.data)
+        serializer = RegistrationSchoolFileMasterSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save()
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-class RegistrationTemplateMasterSimpleView(APIView):
+class RegistrationSchoolFileMasterSimpleView(APIView):
     @swagger_auto_schema(
         operation_description="Récupère un master de template d'inscription spécifique",
         responses={
-            200: RegistrationTemplateMasterSerializer,
+            200: RegistrationSchoolFileMasterSerializer,
             404: "Master non trouvé"
         }
     )
     def get(self, request, id):
-        master = bdd.getObject(_objectName=RegistrationTemplateMaster, _columnName='id', _value=id)
+        master = bdd.getObject(_objectName=RegistrationSchoolFileMaster, _columnName='id', _value=id)
         if master is None:
             return JsonResponse({"errorMessage":'Le master de template n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
-        serializer = RegistrationTemplateMasterSerializer(master)
+        serializer = RegistrationSchoolFileMasterSerializer(master)
         return JsonResponse(serializer.data, safe=False)
 
     @swagger_auto_schema(
         operation_description="Met à jour un master de template d'inscription existant",
-        request_body=RegistrationTemplateMasterSerializer,
+        request_body=RegistrationSchoolFileMasterSerializer,
         responses={
-            200: RegistrationTemplateMasterSerializer,
+            200: RegistrationSchoolFileMasterSerializer,
             400: "Données invalides",
             404: "Master non trouvé"
         }
     )
     def put(self, request, id):
-        master = bdd.getObject(_objectName=RegistrationTemplateMaster, _columnName='id', _value=id)
+        master = bdd.getObject(_objectName=RegistrationSchoolFileMaster, _columnName='id', _value=id)
         if master is None:
             return JsonResponse({'erreur': 'Le master de template n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
-        serializer = RegistrationTemplateMasterSerializer(master, data=request.data)
+        serializer = RegistrationSchoolFileMasterSerializer(master, data=request.data)
         if serializer.is_valid():
             serializer.save()
             return Response(serializer.data, status=status.HTTP_200_OK)
@@ -77,67 +77,67 @@ class RegistrationTemplateMasterSimpleView(APIView):
         }
     )
     def delete(self, request, id):
-        master = bdd.getObject(_objectName=RegistrationTemplateMaster, _columnName='id', _value=id)
+        master = bdd.getObject(_objectName=RegistrationSchoolFileMaster, _columnName='id', _value=id)
         if master is not None:
             master.delete()
             return JsonResponse({'message': 'La suppression du master de template a été effectuée avec succès'}, safe=False, status=status.HTTP_204_NO_CONTENT)
         else:
             return JsonResponse({'erreur': 'Le master de template n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
 
-class RegistrationTemplateView(APIView):
+class RegistrationSchoolFileTemplateView(APIView):
     @swagger_auto_schema(
         operation_description="Récupère tous les templates d'inscription",
-        responses={200: RegistrationTemplateSerializer(many=True)}
+        responses={200: RegistrationSchoolFileTemplateSerializer(many=True)}
     )
     def get(self, request):
-        templates = RegistrationTemplate.objects.all()
-        serializer = RegistrationTemplateSerializer(templates, many=True)
+        templates = RegistrationSchoolFileTemplate.objects.all()
+        serializer = RegistrationSchoolFileTemplateSerializer(templates, many=True)
         return Response(serializer.data)
 
     @swagger_auto_schema(
         operation_description="Crée un nouveau template d'inscription",
-        request_body=RegistrationTemplateSerializer,
+        request_body=RegistrationSchoolFileTemplateSerializer,
         responses={
-            201: RegistrationTemplateSerializer,
+            201: RegistrationSchoolFileTemplateSerializer,
             400: "Données invalides"
         }
     )
     def post(self, request):
-        serializer = RegistrationTemplateSerializer(data=request.data)
+        serializer = RegistrationSchoolFileTemplateSerializer(data=request.data)
         if serializer.is_valid():
             serializer.save()
             return Response(serializer.data, status=status.HTTP_201_CREATED)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
-class RegistrationTemplateSimpleView(APIView):
+class RegistrationSchoolFileTemplateSimpleView(APIView):
     @swagger_auto_schema(
         operation_description="Récupère un template d'inscription spécifique",
         responses={
-            200: RegistrationTemplateSerializer,
+            200: RegistrationSchoolFileTemplateSerializer,
             404: "Template non trouvé"
         }
     )
     def get(self, request, id):
-        template = bdd.getObject(_objectName=RegistrationTemplate, _columnName='id', _value=id)
+        template = bdd.getObject(_objectName=RegistrationSchoolFileTemplate, _columnName='id', _value=id)
         if template is None:
             return JsonResponse({"errorMessage":'Le template d\'inscription n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
-        serializer = RegistrationTemplateSerializer(template)
+        serializer = RegistrationSchoolFileTemplateSerializer(template)
         return JsonResponse(serializer.data, safe=False)
 
     @swagger_auto_schema(
         operation_description="Met à jour un template d'inscription existant",
-        request_body=RegistrationTemplateSerializer,
+        request_body=RegistrationSchoolFileTemplateSerializer,
         responses={
-            200: RegistrationTemplateSerializer,
+            200: RegistrationSchoolFileTemplateSerializer,
             400: "Données invalides",
             404: "Template non trouvé"
         }
     )
     def put(self, request, id):
-        template = bdd.getObject(_objectName=RegistrationTemplate, _columnName='id', _value=id)
+        template = bdd.getObject(_objectName=RegistrationSchoolFileTemplate, _columnName='id', _value=id)
         if template is None:
             return JsonResponse({'erreur': 'Le template d\'inscription n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
-        serializer = RegistrationTemplateSerializer(template, data=request.data)
+        serializer = RegistrationSchoolFileTemplateSerializer(template, data=request.data)
         if serializer.is_valid():
             serializer.save()
             return Response({'message': 'Template mis à jour avec succès', 'data': serializer.data}, status=status.HTTP_200_OK)
@@ -151,7 +151,156 @@ class RegistrationTemplateSimpleView(APIView):
         }
     )
     def delete(self, request, id):
-        template = bdd.getObject(_objectName=RegistrationTemplate, _columnName='id', _value=id)
+        template = bdd.getObject(_objectName=RegistrationSchoolFileTemplate, _columnName='id', _value=id)
+        if template is not None:
+            template.delete()
+            return JsonResponse({'message': 'La suppression du template a été effectuée avec succès'}, safe=False, status=status.HTTP_204_NO_CONTENT)
+        else:
+            return JsonResponse({'erreur': 'Le template n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
+
+class RegistrationParentFileMasterView(APIView):
+    @swagger_auto_schema(
+        operation_description="Récupère tous les fichiers parents",
+        responses={200: RegistrationParentFileMasterSerializer(many=True)}
+    )
+    def get(self, request):
+        templates = RegistrationParentFileMaster.objects.all()
+        serializer = RegistrationParentFileMasterSerializer(templates, many=True)
+        return Response(serializer.data)
+
+    @swagger_auto_schema(
+        operation_description="Crée un nouveau fichier parent",
+        request_body=RegistrationParentFileMasterSerializer,
+        responses={
+            201: RegistrationParentFileMasterSerializer,
+            400: "Données invalides"
+        }
+    )
+    def post(self, request):
+        serializer = RegistrationParentFileMasterSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+class RegistrationParentFileMasterSimpleView(APIView):
+    @swagger_auto_schema(
+        operation_description="Récupère un fichier parent spécifique",
+        responses={
+            200: RegistrationParentFileMasterSerializer,
+            404: "Fichier parent non trouvé"
+        }
+    )
+    def get(self, request, id):
+        template = bdd.getObject(_objectName=RegistrationParentFileMaster, _columnName='id', _value=id)
+        if template is None:
+            return JsonResponse({"errorMessage":'Le fichier parent n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
+        serializer = RegistrationParentFileMasterSerializer(template)
+        return JsonResponse(serializer.data, safe=False)
+
+    @swagger_auto_schema(
+        operation_description="Met à jour un fichier parent existant",
+        request_body=RegistrationParentFileMasterSerializer,
+        responses={
+            200: RegistrationParentFileMasterSerializer,
+            400: "Données invalides",
+            404: "Fichier parent non trouvé"
+        }
+    )
+    def put(self, request, id):
+        template = bdd.getObject(_objectName=RegistrationParentFileMaster, _columnName='id', _value=id)
+        if template is None:
+            return JsonResponse({'erreur': 'Le fichier parent n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
+        serializer = RegistrationParentFileMasterSerializer(template, data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response({'message': 'Fichier parent mis à jour avec succès', 'data': serializer.data}, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @swagger_auto_schema(
+        operation_description="Supprime un fichier parent",
+        responses={
+            204: "Suppression réussie",
+            404: "Fichier parent non trouvé"
+        }
+    )
+    def delete(self, request, id):
+        template = bdd.getObject(_objectName=RegistrationParentFileMaster, _columnName='id', _value=id)
+        if template is not None:
+            template.delete()
+            return JsonResponse({'message': 'La suppression du fichier parent a été effectuée avec succès'}, safe=False, status=status.HTTP_204_NO_CONTENT)
+        else:
+            return JsonResponse({'erreur': 'Le fichier parent n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
+
+class RegistrationParentFileTemplateView(APIView):
+    @swagger_auto_schema(
+        operation_description="Récupère tous les templates d'inscription",
+        responses={200: RegistrationParentFileTemplateSerializer(many=True)}
+    )
+    def get(self, request):
+        templates = RegistrationParentFileTemplate.objects.all()
+        serializer = RegistrationParentFileTemplateSerializer(templates, many=True)
+        return Response(serializer.data)
+
+    @swagger_auto_schema(
+        operation_description="Crée un nouveau template d'inscription",
+        request_body=RegistrationParentFileTemplateSerializer,
+        responses={
+            201: RegistrationParentFileTemplateSerializer,
+            400: "Données invalides"
+        }
+    )
+    def post(self, request):
+        serializer = RegistrationParentFileTemplateSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+class RegistrationParentFileTemplateSimpleView(APIView):
+    @swagger_auto_schema(
+        operation_description="Récupère un template d'inscription spécifique",
+        responses={
+            200: RegistrationParentFileTemplateSerializer,
+            404: "Template non trouvé"
+        }
+    )
+    def get(self, request, id):
+        template = bdd.getObject(_objectName=RegistrationParentFileTemplate, _columnName='id', _value=id)
+        if template is None:
+            return JsonResponse({"errorMessage":'Le template d\'inscription n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
+        serializer = RegistrationParentFileTemplateSerializer(template)
+        return JsonResponse(serializer.data, safe=False)
+
+    @swagger_auto_schema(
+        operation_description="Met à jour un template d'inscription existant",
+        request_body=RegistrationParentFileTemplateSerializer,
+        responses={
+            200: RegistrationParentFileTemplateSerializer,
+            400: "Données invalides",
+            404: "Template non trouvé"
+        }
+    )
+    def put(self, request, id):
+        template = bdd.getObject(_objectName=RegistrationParentFileTemplate, _columnName='id', _value=id)
+        if template is None:
+            return JsonResponse({'erreur': 'Le template d\'inscription n\'a pas été trouvé'}, safe=False, status=status.HTTP_404_NOT_FOUND)
+
+        serializer = RegistrationParentFileTemplateSerializer(template, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+            return Response({'message': 'Template mis à jour avec succès', 'data': serializer.data}, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @swagger_auto_schema(
+        operation_description="Supprime un template d'inscription",
+        responses={
+            204: "Suppression réussie",
+            404: "Template non trouvé"
+        }
+    )
+    def delete(self, request, id):
+        template = bdd.getObject(_objectName=RegistrationParentFileTemplate, _columnName='id', _value=id)
         if template is not None:
             template.delete()
             return JsonResponse({'message': 'La suppression du template a été effectuée avec succès'}, safe=False, status=status.HTTP_204_NO_CONTENT)

Back-End/Subscriptions/views/student_views.py

@@ -96,6 +96,13 @@ class ChildrenListView(APIView):
         
         students = bdd.getObjects(_objectName=RegistrationForm, _columnName='student__guardians__profile_role__profile__id', _value=id)
         if students:
-            students = students.filter(establishment=establishment_id).distinct()
+            students = students.filter(
+            establishment=establishment_id,
+            status__in=[
+                RegistrationForm.RegistrationFormStatus.RF_SENT,
+                RegistrationForm.RegistrationFormStatus.RF_UNDER_REVIEW,
+                RegistrationForm.RegistrationFormStatus.RF_SEPA_SENT
+            ]
+        ).distinct()
         students_serializer = RegistrationFormByParentSerializer(students, many=True)
         return JsonResponse(students_serializer.data, safe=False)