n3wt-school/Back-End/GestionEnseignants/serializers.py

from rest_framework import serializers
from .models import Enseignant, Specialite, Classe, Planning, NIVEAU_CHOICES
from GestionInscriptions.models import FicheInscription
from GestionInscriptions.serializers import EleveSerializer
from GestionLogin.serializers import ProfilSerializer
from GestionLogin.models import Profil
from N3wtSchool import settings, bdd
from django.utils import timezone
import pytz

class SpecialiteSerializer(serializers.ModelSerializer):
    dateCreation_formattee = serializers.SerializerMethodField()
    class Meta:
        model = Specialite
        fields = '__all__'
    
    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 EnseignantDetailSerializer(serializers.ModelSerializer):
    specialites = SpecialiteSerializer(many=True, read_only=True)

    class Meta:
        model = Enseignant
        fields = ['id', 'nom', 'prenom', 'mail', 'specialites']

class EnseignantSerializer(serializers.ModelSerializer):
    specialites = SpecialiteSerializer(many=True, read_only=True)
    specialites_ids = serializers.PrimaryKeyRelatedField(queryset=Specialite.objects.all(), many=True, source='specialites')
    profilAssocie_id = serializers.PrimaryKeyRelatedField(queryset=Profil.objects.all(), source='profilAssocie', write_only=False, read_only=False)
    classes_principal = serializers.PrimaryKeyRelatedField(many=True, read_only=True, source='classes')
    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', 'dateCreation', 'dateCreation_formattee']

    def create(self, validated_data):
        specialites_data = validated_data.pop('specialites', None)
        profilAssocie = validated_data.pop('profilAssocie', None)
        enseignant = Enseignant.objects.create(**validated_data)
        enseignant.specialites.set(specialites_data)
        if profilAssocie:
            enseignant.profilAssocie = profilAssocie
        enseignant.save()
        return enseignant

    def update(self, instance, validated_data):
        specialites_data = validated_data.pop('specialites', [])
        instance.nom = validated_data.get('nom', instance.nom)
        instance.prenom = validated_data.get('prenom', instance.prenom)
        instance.mail = validated_data.get('mail', instance.mail)
        instance.profilAssocie = validated_data.get('profilAssocie', instance.profilAssocie)
        instance.save()
        instance.specialites.set(specialites_data)
        return instance

    def get_DroitLabel(self, obj): 
        return obj.profilAssocie.get_droit_display() if obj.profilAssocie else None

    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):
    # emploiDuTemps = serializers.SerializerMethodField()

    class Meta:
        model = Planning
        fields = ['id', 'niveau', 'emploiDuTemps']

    # 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.classe.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.classe.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()
    niveaux = serializers.ListField(child=serializers.ChoiceField(choices=NIVEAU_CHOICES))
    plannings_read = serializers.SerializerMethodField()
    plannings = PlanningSerializer(many=True, write_only=True)

    class Meta:
        model = Classe
        fields = [
            'id', 'nom_ambiance', 'tranche_age', 'nombre_eleves', 'langue_enseignement',
            'enseignants', 'enseignants_ids', 'annee_scolaire', 'dateCreation',
            'dateCreation_formattee', 'eleves', 'niveaux', 'type', 'plage_horaire',
            'jours_ouverture', 'plannings', 'plannings_read'
        ]

    def create(self, validated_data):
        enseignants_data = validated_data.pop('enseignants', [])
        niveaux_data = validated_data.pop('niveaux', [])
        plannings_data = validated_data.pop('plannings', [])
        
        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,
            type=validated_data.get('type', 1),  # Ajouté ici
            plage_horaire=validated_data.get('plage_horaire', ['08:30', '17:30']),  # Ajouté ici
            jours_ouverture=validated_data.get('jours_ouverture', [1, 2, 4, 5])  # Ajouté ici
        )

        classe.enseignants.set(enseignants_data)

        for planning_data in plannings_data:
            Planning.objects.create(
                classe=classe,
                niveau=planning_data['niveau'],
                emploiDuTemps=planning_data.get('emploiDuTemps', {})
            )

        return classe

    def update(self, instance, validated_data):
        enseignants_data = validated_data.pop('enseignants', [])
        niveaux_data = validated_data.pop('niveaux', [])
        plannings_data = validated_data.pop('plannings', [])

        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.type = validated_data.get('type', instance.type)  # Ajouté ici
        instance.plage_horaire = validated_data.get('plage_horaire', instance.plage_horaire)  # Ajouté ici
        instance.jours_ouverture = validated_data.get('jours_ouverture', instance.jours_ouverture)  # Ajouté ici

        instance.save()
        instance.enseignants.set(enseignants_data)

        existing_plannings = {planning.niveau: planning for planning in instance.plannings.all()}

        for planning_data in plannings_data:
            niveau = planning_data['niveau']
            if niveau in existing_plannings:
                # Mettre à jour le planning existant
                planning = existing_plannings[niveau]
                planning.emploiDuTemps = planning_data.get('emploiDuTemps', planning.emploiDuTemps)
                planning.save()
            else:
                # Créer un nouveau planning si niveau non existant
                Planning.objects.create(
                    classe=instance,
                    niveau=niveau,
                    emploiDuTemps=planning_data.get('emploiDuTemps', {})
                )

        return instance

    def get_dateCreation_formattee(self, obj):
        utc_time = timezone.localtime(obj.dateCreation)
        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)
            if ficheInscription.etat == ficheInscription.EtatDossierInscription.DI_VALIDE:
                filtered_eleves.append(eleve)
        return EleveSerializer(filtered_eleves, many=True, read_only=True).data

    def get_plannings_read(self, obj):
        plannings = obj.plannings.all()
        niveaux_dict = {niveau: {'niveau': niveau, 'planning': None} for niveau in obj.niveaux}
        
        for planning in plannings:
            if planning.niveau in niveaux_dict:
                niveaux_dict[planning.niveau]['planning'] = PlanningSerializer(planning).data
        
        return list(niveaux_dict.values())