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

from rest_framework import serializers
from GestionInscriptions.models import FicheInscription, Eleve, Responsable, Frere, Langue
from GestionLogin.models import Profil
from GestionLogin.serializers import ProfilSerializer
from GestionMessagerie.models import Messagerie
from GestionNotification.models import Notification
from N3wtSchool import settings
from django.utils import timezone
import pytz

class LanguesSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    class Meta:
        model = Langue
        fields = '__all__'

class FrereSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    class Meta:
        model = Frere
        fields = '__all__'

class ResponsableSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    profil_associe = serializers.SerializerMethodField()
    class Meta:
        model = Responsable
        fields = '__all__'

    def get_profil_associe(self, obj):
        return obj.profilAssocie.email

class EleveSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    responsables = ResponsableSerializer(many=True, required=False)
    freres = FrereSerializer(many=True, required=False)
    langues = LanguesSerializer(many=True, required=False)
    class Meta:
        model = Eleve
        fields = '__all__'

    def get_or_create_packages(self, responsables_data):
        responsables_ids = []
        for responsable_data in responsables_data:
            responsable_instance, created = Responsable.objects.get_or_create(  id=responsable_data.get('id'), 
                                                                                defaults=responsable_data)
            responsables_ids.append(responsable_instance.id)
        return responsables_ids
    
    def create(self, validated_data):
        responsables_data = validated_data.pop('responsables', [])
        freres_data = validated_data.pop('freres', [])
        langues_data = validated_data.pop('languesParlees', [])
        eleve = Eleve.objects.create(**validated_data)
        eleve.responsables.set(self.get_or_create_packages(responsables_data))
        eleve.freres.set(self.get_or_create_packages(freres_data))
        eleve.languesParlees.set(self.get_or_create_packages(langues_data))
        
        return eleve

    def create_or_update_packages(self, responsables_data):
        responsables_ids = []
        

        for responsable_data in responsables_data:
            responsable_instance, created = Responsable.objects.update_or_create(   id=responsable_data.get('id'), 
                                                                                    defaults=responsable_data)

            responsables_ids.append(responsable_instance.id)
        return responsables_ids

    def update(self, instance, validated_data):
        responsables_data = validated_data.pop('responsables', [])
        freres_data = validated_data.pop('freres', [])
        langues_data = validated_data.pop('languesParlees', [])
        if responsables_data:
            instance.responsables.set(self.create_or_update_packages(responsables_data))
        if freres_data:
            instance.freres.set(self.create_or_update_packages(freres_data))
        if langues_data:
            instance.freres.set(self.create_or_update_packages(langues_data))

        for field in self.fields:
            try:
                setattr(instance, field, validated_data[field])
            except KeyError:
                pass
        instance.save()

        return instance

class FicheInscriptionSerializer(serializers.ModelSerializer):
    eleve = EleveSerializer(many=False, required=True)
    fichierInscription = serializers.FileField(required=False)
    etat_label = serializers.SerializerMethodField()
    dateMAJ_formattee = serializers.SerializerMethodField()
    class Meta:
        model = FicheInscription
        fields = '__all__'
    
    def create(self, validated_data):
        eleve_data = validated_data.pop('eleve')
        eleve = EleveSerializer.create(EleveSerializer(), eleve_data)
        ficheEleve = FicheInscription.objects.create(eleve=eleve, **validated_data)
        return ficheEleve
    
    def update(self, instance, validated_data):
        eleve_data = validated_data.pop('eleve')
        eleve = instance.eleve
        eleve_serializer = EleveSerializer.update(EleveSerializer(), eleve, eleve_data)

        for field in self.fields:
            try:
                setattr(instance, field, validated_data[field])
            except KeyError:
                pass
        instance.save()
        
        return instance
    
    def get_etat_label(self, obj): 
        return obj.get_etat_display()

    def get_dateMAJ_formattee(self, obj):
        utc_time = timezone.localtime(obj.dateMAJ) # 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 EleveByParentSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    class Meta:
        model = Eleve
        fields = ['id', 'nom', 'prenom']
    
    def __init__(self, *args, **kwargs):
        super(EleveByParentSerializer , self).__init__(*args, **kwargs)
        for field in self.fields:
            self.fields[field].required = False

class FicheInscriptionByParentSerializer(serializers.ModelSerializer):
    eleve = EleveByParentSerializer(many=False, required=True)
    class Meta:
        model = FicheInscription
        fields = ['eleve', 'etat']
    
    def __init__(self, *args, **kwargs):
        super(FicheInscriptionByParentSerializer, self).__init__(*args, **kwargs)
        for field in self.fields:
            self.fields[field].required = False

class ResponsableByDICreationSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    class Meta:
        model = Responsable
        fields = ['id', 'nom', 'prenom', 'mail', 'profilAssocie']

class EleveByDICreationSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    responsables = ResponsableByDICreationSerializer(many=True, required=False)
    class Meta:
        model = Eleve
        fields = ['id', 'nom', 'prenom', 'responsables']
    
    def __init__(self, *args, **kwargs):
        super(EleveByDICreationSerializer , self).__init__(*args, **kwargs)
        for field in self.fields:
            self.fields[field].required = False

class NotificationSerializer(serializers.ModelSerializer):
    typeNotification_label = serializers.ReadOnlyField()
    class Meta:
        model = Notification
        fields = '__all__'