refactor: Création de nouveaux composants / update formulaire de

création de classe (#2)

Back-End/GestionEnseignants/apps.py

@@ -3,8 +3,8 @@ from django.db.models.signals import post_migrate
 
 def create_specialite(sender, **kwargs):
     from .models import Specialite
-    if not Specialite.objects.filter(nom='TRANSVERSE').exists():
-        Specialite.objects.create(nom='TRANSVERSE', codeCouleur='#FF0000')
+    if not Specialite.objects.filter(nom='GROUPE').exists():
+        Specialite.objects.create(nom='GROUPE', codeCouleur='#FF0000')
 
 class GestionenseignantsConfig(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'

Back-End/GestionEnseignants/models.py

@@ -3,6 +3,7 @@ from GestionLogin.models import Profil
 from django.db.models import JSONField
 from django.db.models.signals import post_save
 from django.dispatch import receiver
+from django.contrib.postgres.fields import ArrayField
 
 class Specialite(models.Model):
     nom = models.CharField(max_length=100)
@@ -18,31 +19,36 @@ class Enseignant(models.Model):
     mail = models.EmailField(unique=True)
     specialites = models.ManyToManyField(Specialite, related_name='enseignants')
     profilAssocie = models.ForeignKey(Profil, on_delete=models.CASCADE, null=True, blank=True)
+    dateCreation = models.DateTimeField(auto_now=True)
 
     def __str__(self):
         return f"{self.nom} {self.prenom}"
 
 class Classe(models.Model):
-    nom_ambiance = models.CharField(max_length=255)
+    nom_ambiance = models.CharField(max_length=255, null=True, blank=True)
     tranche_age = models.JSONField()
     nombre_eleves = models.PositiveIntegerField()
     langue_enseignement = models.CharField(max_length=255)
     annee_scolaire = models.CharField(max_length=9)
     dateCreation = models.DateTimeField(auto_now_add=True)
     enseignants = models.ManyToManyField(Enseignant, related_name='classes')
+    niveaux = models.JSONField(default=list)
 
     def __str__(self):
         return self.nom_ambiance
 
 class Planning(models.Model):
+    PLANNING_TYPE_CHOICES = [
+        (1, 'Annuel'),
+        (2, 'Semestriel'),
+        (3, 'Trimestriel')
+    ]
+
     classe = models.OneToOneField(Classe, on_delete=models.SET_NULL, null=True, blank=True, related_name='planning')
-    emploiDuTemps = JSONField(default=list)
+    emploiDuTemps = JSONField(default=dict)
+    type = models.IntegerField(choices=PLANNING_TYPE_CHOICES, default=1)
+    plageHoraire = models.JSONField(default=list)
+    joursOuverture = ArrayField(models.IntegerField(), default=list)
 
     def __str__(self):
         return f'Planning de {self.classe.nom_ambiance}'
-
-@receiver(post_save, sender=Classe)
-def create_planning(sender, instance, created, **kwargs): 
-    if created and not hasattr(instance, 'planning'): 
-        Planning.objects.create(classe=instance)
-

Back-End/GestionEnseignants/serializers.py

@@ -36,10 +36,11 @@ class EnseignantSerializer(serializers.ModelSerializer):
     profilAssocie = ProfilSerializer(read_only=True)
     DroitLabel = serializers.SerializerMethodField()
     DroitValue = serializers.SerializerMethodField()
+    dateCreation_formattee = serializers.SerializerMethodField()
 
     class Meta:
         model = Enseignant
-        fields = ['id', 'nom', 'prenom', 'mail', 'specialites', 'specialites_ids', 'classes_principal', 'profilAssocie', 'profilAssocie_id', 'DroitLabel', 'DroitValue']
+        fields = ['id', 'nom', 'prenom', 'mail', 'specialites', 'specialites_ids', 'classes_principal', 'profilAssocie', 'profilAssocie_id', 'DroitLabel', 'DroitValue', 'dateCreation', 'dateCreation_formattee']
 
     def create(self, validated_data):
         specialites_data = validated_data.pop('specialites', None)
@@ -67,63 +68,146 @@ class EnseignantSerializer(serializers.ModelSerializer):
     def get_DroitValue(self, obj): 
         return obj.profilAssocie.droit if obj.profilAssocie else None
 
+    def get_dateCreation_formattee(self, obj):
+        utc_time = timezone.localtime(obj.dateCreation) # Convertir en heure locale
+        local_tz = pytz.timezone(settings.TZ_APPLI)
+        local_time = utc_time.astimezone(local_tz)
+        return local_time.strftime("%d-%m-%Y %H:%M")
+
 class PlanningSerializer(serializers.ModelSerializer):
-    classe_id = serializers.PrimaryKeyRelatedField(queryset=Classe.objects.all(), source='classe')
+    emploiDuTemps = serializers.SerializerMethodField()
 
     class Meta:
         model = Planning
-        fields = ['id', 'classe', 'classe_id', 'emploiDuTemps']
+        fields = ['id', 'emploiDuTemps', 'type', 'plageHoraire', 'joursOuverture']
+
+    def get_emploiDuTemps(self, obj):
+        emploi_du_temps = obj.emploiDuTemps
+        if obj.classe:
+            enseignants = obj.classe.enseignants.all()  # Récupérer tous les enseignants associés à la classe
+
+            # Dictionnaire pour accéder rapidement aux spécialités des enseignants
+            specialite_enseignants = {}
+            for enseignant in enseignants:
+                for specialite in enseignant.specialites.all():
+                    if specialite.nom not in specialite_enseignants:
+                        specialite_enseignants[specialite.nom] = []
+                    specialite_enseignants[specialite.nom].append(f"{enseignant.prenom} {enseignant.nom}")
+
+            if obj.type == 1:  # Planning annuel
+                for day, events in emploi_du_temps.items():
+                    for event in events:
+                        # Ajouter les enseignants associés à la spécialité
+                        event['teachers'] = specialite_enseignants.get(event['matiere'], [])
+                        # Ajouter la couleur de la spécialité
+                        event['color'] = next(
+                            (specialite.codeCouleur for enseignant in enseignants for specialite in enseignant.specialites.all() if specialite.nom == event['matiere']),
+                            "#FFFFFF"  # Couleur par défaut si non trouvée
+                        )
+
+            elif obj.type in [2, 3]:  # Planning semestriel ou trimestriel
+                for period_key, period_value in emploi_du_temps.items():
+                    for day, events in period_value.items():
+                        if day in ['DateDebut', 'DateFin']:
+                            continue  # Ignorer les clés DateDebut et DateFin
+                        for event in events:
+                            print(f'event : {event}')
+                            # Ajouter les enseignants associés à la spécialité
+                            event['teachers'] = specialite_enseignants.get(event['matiere'], [])
+                            # Ajouter la couleur de la spécialité
+                            event['color'] = next(
+                                (specialite.codeCouleur for enseignant in enseignants for specialite in enseignant.specialites.all() if specialite.nom == event['matiere']),
+                                "#FFFFFF"  # Couleur par défaut si non trouvée
+                            )
+
+        return emploi_du_temps
+
+    def to_internal_value(self, data):
+        internal_value = super().to_internal_value(data)
+        internal_value['emploiDuTemps'] = data.get('emploiDuTemps', {})
+        return internal_value
 
 class ClasseSerializer(serializers.ModelSerializer):
     dateCreation_formattee = serializers.SerializerMethodField()
     enseignants = EnseignantSerializer(many=True, read_only=True)
     enseignants_ids = serializers.PrimaryKeyRelatedField(queryset=Enseignant.objects.all(), many=True, source='enseignants')
     eleves = serializers.SerializerMethodField()
-    planning = serializers.SerializerMethodField()
+    planning = PlanningSerializer()
 
     class Meta:
         model = Classe
-        fields = ['id', 'nom_ambiance', 'tranche_age', 'nombre_eleves', 'langue_enseignement', 'enseignants', 'enseignants_ids', 'annee_scolaire', 'dateCreation', 'dateCreation_formattee', 'eleves', 'planning']
+        fields = [
+            'id', 'nom_ambiance', 'tranche_age', 'nombre_eleves', 'langue_enseignement',
+            'enseignants', 'enseignants_ids', 'annee_scolaire', 'dateCreation',
+            'dateCreation_formattee', 'eleves', 'planning', 'niveaux'
+        ]
 
     def create(self, validated_data):
         planning_data = validated_data.pop('planning', None)
         enseignants_data = validated_data.pop('enseignants', [])
-        classe = Classe.objects.create(**validated_data)
+        niveaux_data = validated_data.pop('niveaux', [])
+
+        classe = Classe.objects.create(
+            nom_ambiance=validated_data.get('nom_ambiance', ''),
+            tranche_age=validated_data.get('tranche_age', []),
+            nombre_eleves=validated_data.get('nombre_eleves', 0),
+            langue_enseignement=validated_data.get('langue_enseignement', ''),
+            annee_scolaire=validated_data.get('annee_scolaire', ''),
+            niveaux=niveaux_data
+        )
+
         classe.enseignants.set(enseignants_data)
+
         if planning_data and not hasattr(classe, 'planning'):
-            Planning.objects.create(classe=classe, **planning_data)
+            Planning.objects.create(
+                classe=classe,
+                emploiDuTemps=planning_data.get('emploiDuTemps', {}),
+                type=planning_data.get('type', 1),
+                plageHoraire=planning_data.get('plageHoraire', []),
+                joursOuverture=planning_data.get('joursOuverture', [])
+            )
+
         return classe
 
     def update(self, instance, validated_data):
         planning_data = validated_data.pop('planning', None)
         enseignants_data = validated_data.pop('enseignants', [])
+        niveaux_data = validated_data.pop('niveaux', [])
+
         instance.nom_ambiance = validated_data.get('nom_ambiance', instance.nom_ambiance)
         instance.tranche_age = validated_data.get('tranche_age', instance.tranche_age)
         instance.nombre_eleves = validated_data.get('nombre_eleves', instance.nombre_eleves)
         instance.langue_enseignement = validated_data.get('langue_enseignement', instance.langue_enseignement)
         instance.annee_scolaire = validated_data.get('annee_scolaire', instance.annee_scolaire)
+        instance.niveaux = niveaux_data
+
         instance.save()
         instance.enseignants.set(enseignants_data)
-        if planning_data: 
+
+        if planning_data:
             planning = instance.planning
             planning.emploiDuTemps = planning_data.get('emploiDuTemps', planning.emploiDuTemps)
+            planning.type = planning_data.get('type', planning.type)
+            planning.plageHoraire = planning_data.get('plageHoraire', planning.plageHoraire)
+            planning.joursOuverture = planning_data.get('joursOuverture', planning.joursOuverture)
+
             planning.save()
+
         return instance
 
     def get_dateCreation_formattee(self, obj):
         utc_time = timezone.localtime(obj.dateCreation) # Convertir en heure locale
         local_tz = pytz.timezone(settings.TZ_APPLI)
         local_time = utc_time.astimezone(local_tz)
-
         return local_time.strftime("%d-%m-%Y %H:%M")
 
     def get_eleves(self, obj):
         elevesList = obj.eleves.all()
         filtered_eleves = []
         for eleve in elevesList:
-            ficheInscription=bdd.getObject(FicheInscription, "eleve__id", eleve.id)
+            ficheInscription = bdd.getObject(FicheInscription, "eleve__id", eleve.id)
             if ficheInscription.etat == ficheInscription.EtatDossierInscription.DI_VALIDE:
-                filtered_eleves.append(eleve) 
+                filtered_eleves.append(eleve)
         return EleveSerializer(filtered_eleves, many=True, read_only=True).data
 
     def get_planning(self, obj):

Back-End/GestionEnseignants/urls.py

@@ -1,6 +1,6 @@
 from django.urls import path, re_path
 
-from GestionEnseignants.views import EnseignantsView, EnseignantView, SpecialitesView, SpecialiteView, ClassesView, ClasseView
+from GestionEnseignants.views import EnseignantsView, EnseignantView, SpecialitesView, SpecialiteView, ClassesView, ClasseView, PlanningsView, PlanningView
 
 urlpatterns = [
     re_path(r'^enseignants$', EnseignantsView.as_view(), name="enseignants"),
@@ -14,4 +14,8 @@ urlpatterns = [
     re_path(r'^classes$', ClassesView.as_view(), name="classes"),
     re_path(r'^classe$', ClasseView.as_view(), name="classe"),
     re_path(r'^classe/([0-9]+)$', ClasseView.as_view(), name="classe"),
+
+    re_path(r'^plannings$', PlanningsView.as_view(), name="plannings"),
+    re_path(r'^planning$', PlanningView.as_view(), name="planning"),
+    re_path(r'^planning/([0-9]+)$', PlanningView.as_view(), name="planning"),
 ]

Back-End/GestionEnseignants/views.py

@@ -4,8 +4,8 @@ from django.utils.decorators import method_decorator
 from rest_framework.parsers import JSONParser
 from rest_framework.views import APIView
 from django.core.cache import cache
-from .models import Enseignant, Specialite, Classe
-from .serializers import EnseignantSerializer, SpecialiteSerializer, ClasseSerializer
+from .models import Enseignant, Specialite, Classe, Planning
+from .serializers import EnseignantSerializer, SpecialiteSerializer, ClasseSerializer, PlanningSerializer
 from N3wtSchool import bdd
 
 class EnseignantsView(APIView):
@@ -188,4 +188,42 @@ class ClasseView(APIView):
                 eleve.save()
             classe.delete()
     
-        return JsonResponse("La suppression de la classe a été effectuée avec succès", safe=False)
+        return JsonResponse("La suppression de la classe a été effectuée avec succès", safe=False)
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class PlanningsView(APIView):
+    def get(self, request):
+        schedulesList=bdd.getAllObjects(Planning)
+        schedules_serializer=PlanningSerializer(schedulesList, many=True)
+        return JsonResponse(schedules_serializer.data, safe=False)
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class PlanningView(APIView):
+    def get (self, request, _id):
+        planning = bdd.getObject(_objectName=Planning, _columnName='classe__id', _value=_id)
+        planning_serializer=PlanningSerializer(planning)
+
+        return JsonResponse(planning_serializer.data, safe=False)
+
+    def post(self, request):
+        planning_data=JSONParser().parse(request)
+        planning_serializer = PlanningSerializer(data=planning_data)
+
+        if planning_serializer.is_valid():
+            planning_serializer.save()
+            return JsonResponse(planning_serializer.data, safe=False)
+
+        return JsonResponse(planning_serializer.errors, safe=False)
+
+    def put(self, request, _id):
+        planning_data=JSONParser().parse(request)
+        planning = bdd.getObject(_objectName=Planning, _columnName='classe__id', _value=_id)
+        planning_serializer = PlanningSerializer(planning, data=planning_data)
+
+        if planning_serializer.is_valid():
+            planning_serializer.save()
+            return JsonResponse(planning_serializer.data, safe=False)
+
+        return JsonResponse(planning_serializer.errors, safe=False)