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

from rest_framework import serializers
from .models import RegistrationFile, RegistrationForm, Student, Guardian, Sibling, Language, RegistrationFee
from School.models import SchoolClass
from Auth.models import Profile
from Auth.serializers import ProfileSerializer
from GestionMessagerie.models import Messagerie
from GestionNotification.models import Notification
from N3wtSchool import settings
from django.utils import timezone
import pytz
from datetime import datetime

class RegistrationFileSerializer(serializers.ModelSerializer):
    class Meta:
        model = RegistrationFile
        fields = '__all__'

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

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

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

class GuardianSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    associated_profile = serializers.PrimaryKeyRelatedField(queryset=Profile.objects.all(), required=True)
    associated_profile_email = serializers.SerializerMethodField()

    class Meta:
        model = Guardian
        fields = '__all__'

    def get_associated_profile_email(self, obj):
        return obj.associated_profile.email


class StudentSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    guardians = GuardianSerializer(many=True, required=False)
    siblings = SiblingSerializer(many=True, required=False)
    languages = LanguageSerializer(many=True, required=False)
    associated_class_id = serializers.PrimaryKeyRelatedField(queryset=SchoolClass.objects.all(), source='associated_class', required=False, write_only=False, read_only=False)
    age = serializers.SerializerMethodField()
    formatted_birth_date = serializers.SerializerMethodField()
    birth_date = serializers.DateField(input_formats=['%d-%m-%Y', '%Y-%m-%d'], required=False, allow_null=True)
    associated_class_name = serializers.SerializerMethodField()

    class Meta:
        model = Student
        fields = '__all__'

    def get_or_create_packages(self, guardians_data):
        guardians_ids = []
        for guardian_data in guardians_data:
            guardian_instance, created = Guardian.objects.get_or_create(
                id=guardian_data.get('id'),
                defaults=guardian_data
            )
            guardians_ids.append(guardian_instance.id)
        return guardians_ids

    def create(self, validated_data):
        guardians_data = validated_data.pop('guardians', [])
        siblings_data = validated_data.pop('siblings', [])
        languages_data = validated_data.pop('spoken_languages', [])
        student = Student.objects.create(**validated_data)
        student.guardians.set(self.get_or_create_packages(guardians_data))
        student.siblings.set(self.get_or_create_packages(siblings_data))
        student.spoken_languages.set(self.get_or_create_packages(languages_data))

        return student

    def create_or_update_packages(self, guardians_data):
        guardians_ids = []
        for guardian_data in guardians_data:
            guardian_instance, created = Guardian.objects.update_or_create(
                id=guardian_data.get('id'),
                defaults=guardian_data
            )
            guardians_ids.append(guardian_instance.id)
        return guardians_ids

    def update(self, instance, validated_data):
        guardians_data = validated_data.pop('guardians', [])
        siblings_data = validated_data.pop('siblings', [])
        languages_data = validated_data.pop('spoken_languages', [])
        if guardians_data:
            instance.guardians.set(self.create_or_update_packages(guardians_data))
        if siblings_data:
            instance.siblings.set(self.create_or_update_packages(siblings_data))
        if languages_data:
            instance.spoken_languages.set(self.create_or_update_packages(languages_data))

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

        return instance

    def get_age(self, obj):
        return obj.age

    def get_formatted_birth_date(self, obj):
        return obj.formatted_birth_date

    def get_associated_class_name(self, obj):
        return obj.associated_class.atmosphereName if obj.associated_class else None

class RegistrationFormSerializer(serializers.ModelSerializer):
    student = StudentSerializer(many=False, required=False)
    registration_file = serializers.FileField(required=False)
    status_label = serializers.SerializerMethodField()
    formatted_last_update = serializers.SerializerMethodField()

    class Meta:
        model = RegistrationForm
        fields = '__all__'

    def create(self, validated_data):
        student_data = validated_data.pop('student')
        student = StudentSerializer.create(StudentSerializer(), student_data)
        registrationForm = RegistrationForm.objects.create(student=student, **validated_data)
        return registrationForm

    def update(self, instance, validated_data):
        student_data = validated_data.pop('student', None)
        if student_data:
            student = instance.student
            StudentSerializer.update(StudentSerializer(), student, student_data)

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

        return instance

    def get_status_label(self, obj):
        return obj.get_status_display()

    def get_formatted_last_update(self, obj):
        utc_time = timezone.localtime(obj.last_update) # Convert to local time
        local_tz = pytz.timezone(settings.TZ_APPLI)
        local_time = utc_time.astimezone(local_tz)

        return local_time.strftime("%d-%m-%Y %H:%M")

class StudentByParentSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)

    class Meta:
        model = Student
        fields = ['id', 'last_name', 'first_name']

    def __init__(self, *args, **kwargs):
        super(StudentByParentSerializer, self).__init__(*args, **kwargs)
        for field in self.fields:
            self.fields[field].required = False

class RegistrationFormByParentSerializer(serializers.ModelSerializer):
    student = StudentByParentSerializer(many=False, required=True)

    class Meta:
        model = RegistrationForm
        fields = ['student', 'status']

    def __init__(self, *args, **kwargs):
        super(RegistrationFormByParentSerializer, self).__init__(*args, **kwargs)
        for field in self.fields:
            self.fields[field].required = False

class GuardianByDICreationSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)

    class Meta:
        model = Guardian
        fields = ['id', 'last_name', 'first_name', 'email', 'associated_profile']

class StudentByRFCreationSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(required=False)
    guardians = GuardianByDICreationSerializer(many=True, required=False)

    class Meta:
        model = Student
        fields = ['id', 'last_name', 'first_name', 'guardians']

    def __init__(self, *args, **kwargs):
        super(StudentByRFCreationSerializer, self).__init__(*args, **kwargs)
        for field in self.fields:
            self.fields[field].required = False

class NotificationSerializer(serializers.ModelSerializer):
    notification_type_label = serializers.ReadOnlyField()

    class Meta:
        model = Notification
        fields = '__all__'