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

from rest_framework import serializers
from .models import Enseignant, Specialite, Classe, Planning
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', '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 = 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', 'niveaux'
        ]

    def create(self, validated_data):
        planning_data = validated_data.pop('planning', None)
        enseignants_data = validated_data.pop('enseignants', [])
        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,
                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:
            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)
            if ficheInscription.etat == ficheInscription.EtatDossierInscription.DI_VALIDE:
                filtered_eleves.append(eleve)
        return EleveSerializer(filtered_eleves, many=True, read_only=True).data

    def get_planning(self, obj):
        from .serializers import PlanningSerializer
        if obj.planning:
            return PlanningSerializer(obj.planning).data
        return None