refactor: Traduction en anglais des modules "GestionInscription" et

"GestionLogin"

Back-End/School/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'School.apps.SchoolConfig'

Back-End/School/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

Back-End/School/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+def create_speciality(sender, **kwargs):
+    from .models import Speciality
+    if not Speciality.objects.filter(name='GROUPE').exists():
+        Speciality.objects.create(name='GROUPE', colorCode='#FF0000')
+
+class SchoolConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'School'
+
+    def ready(self):
+        post_migrate.connect(create_speciality, sender=self)

Back-End/School/models.py

@@ -0,0 +1,66 @@
+from django.db import models
+from Auth.models import Profile
+from django.db.models import JSONField
+from django.dispatch import receiver
+from django.contrib.postgres.fields import ArrayField
+
+LEVEL_CHOICES = [
+    (1, 'Très Petite Section (TPS)'),
+    (2, 'Petite Section (PS)'),
+    (3, 'Moyenne Section (MS)'),
+    (4, 'Grande Section (GS)'),
+    (5, 'Cours Préparatoire (CP)'),
+    (6, 'Cours Élémentaire 1 (CE1)'),
+    (7, 'Cours Élémentaire 2 (CE2)'),
+    (8, 'Cours Moyen 1 (CM1)'),
+    (9, 'Cours Moyen 2 (CM2)')
+]
+
+class Speciality(models.Model):
+    name = models.CharField(max_length=100)
+    updatedDate = models.DateTimeField(auto_now=True)
+    colorCode = models.CharField(max_length=7, default='#FFFFFF')
+
+    def __str__(self):
+        return self.name
+
+class Teacher(models.Model):
+    lastName = models.CharField(max_length=100)
+    firstName = models.CharField(max_length=100)
+    email = models.EmailField(unique=True)
+    specialities = models.ManyToManyField(Speciality, related_name='teachers')
+    associatedProfile = models.ForeignKey(Profile, on_delete=models.CASCADE, null=True, blank=True)
+    updatedDate = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f"{self.lastName} {self.firstName}"
+
+class SchoolClass(models.Model):
+    PLANNING_TYPE_CHOICES = [
+        (1, 'Annuel'),
+        (2, 'Semestriel'),
+        (3, 'Trimestriel')
+    ]
+
+    atmosphereName = models.CharField(max_length=255, null=True, blank=True)
+    ageGroup = models.JSONField()
+    numberOfStudents = models.PositiveIntegerField()
+    teachingLanguage = models.CharField(max_length=255)
+    schoolYear = models.CharField(max_length=9)
+    updatedDate = models.DateTimeField(auto_now_add=True)
+    teachers = models.ManyToManyField(Teacher, related_name='schoolClasses')
+    levels = ArrayField(models.IntegerField(choices=LEVEL_CHOICES), default=list)
+    type = models.IntegerField(choices=PLANNING_TYPE_CHOICES, default=1)
+    schedule = models.JSONField(default=list)
+    openingDays = ArrayField(models.IntegerField(), default=list)
+
+    def __str__(self):
+        return self.atmosphereName
+
+class Planning(models.Model):
+    level = models.IntegerField(choices=LEVEL_CHOICES, null=True, blank=True)
+    classModel = models.ForeignKey(SchoolClass, null=True, blank=True, related_name='plannings', on_delete=models.CASCADE)
+    schedule = JSONField(default=dict)
+
+    def __str__(self):
+        return f'Planning for {self.level} of {self.classModel.atmosphereName}'

Back-End/School/serializers.py

@@ -0,0 +1,194 @@
+from rest_framework import serializers
+from .models import Teacher, Speciality, SchoolClass, Planning, LEVEL_CHOICES
+from Subscriptions.models import RegistrationForm
+from Subscriptions.serializers import StudentSerializer
+from Auth.serializers import ProfileSerializer
+from Auth.models import Profile
+from N3wtSchool import settings, bdd
+from django.utils import timezone
+import pytz
+
+class SpecialitySerializer(serializers.ModelSerializer):
+    creationDateFormatted = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Speciality
+        fields = '__all__'
+
+    def get_creationDateFormatted(self, obj):
+        utc_time = timezone.localtime(obj.updatedDate) # 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 TeacherDetailSerializer(serializers.ModelSerializer):
+    specialities = SpecialitySerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Teacher
+        fields = ['id', 'lastName', 'firstName', 'email', 'specialities']
+
+class TeacherSerializer(serializers.ModelSerializer):
+    specialities = SpecialitySerializer(many=True, read_only=True)
+    specialties_ids = serializers.PrimaryKeyRelatedField(queryset=Speciality.objects.all(), many=True, source='specialities')
+    associatedProfile_id = serializers.PrimaryKeyRelatedField(queryset=Profile.objects.all(), source='associatedProfile', write_only=False, read_only=False)
+    mainClasses = serializers.PrimaryKeyRelatedField(many=True, read_only=True, source='schoolClasses')
+    associatedProfile = ProfileSerializer(read_only=True)
+    rightLabel = serializers.SerializerMethodField()
+    rightValue = serializers.SerializerMethodField()
+    creationDateFormatted = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Teacher
+        fields = ['id', 'lastName', 'firstName', 'email', 'specialities', 'specialties_ids', 'mainClasses', 'associatedProfile', 'associatedProfile_id', 'rightLabel', 'rightValue', 'updatedDate', 'creationDateFormatted']
+
+    def create(self, validated_data):
+        specialties_data = validated_data.pop('specialities', None)
+        associatedProfile = validated_data.pop('associatedProfile', None)
+        teacher = Teacher.objects.create(**validated_data)
+        teacher.specialities.set(specialties_data)
+        if associatedProfile:
+            teacher.associatedProfile = associatedProfile
+        teacher.save()
+        return teacher
+
+    def update(self, instance, validated_data):
+        specialties_data = validated_data.pop('specialities', [])
+        instance.lastName = validated_data.get('lastName', instance.lastName)
+        instance.firstName = validated_data.get('firstName', instance.firstName)
+        instance.email = validated_data.get('email', instance.email)
+        instance.associatedProfile = validated_data.get('associatedProfile', instance.associatedProfile)
+        instance.save()
+        instance.specialities.set(specialties_data)
+        return instance
+
+    def get_rightLabel(self, obj): 
+        return obj.associatedProfile.get_right_display() if obj.associatedProfile else None
+
+    def get_rightValue(self, obj): 
+        return obj.associatedProfile.right if obj.associatedProfile else None
+
+    def get_creationDateFormatted(self, obj):
+        utc_time = timezone.localtime(obj.updatedDate) # 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 PlanningSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Planning
+        fields = ['id', 'level', 'schedule']
+
+    def to_internal_value(self, data):
+        internal_value = super().to_internal_value(data)
+        internal_value['schedule'] = data.get('schedule', {})
+        return internal_value
+
+class SchoolClassSerializer(serializers.ModelSerializer):
+    creationDateFormatted = serializers.SerializerMethodField()
+    teachers = TeacherSerializer(many=True, read_only=True)
+    teachers_ids = serializers.PrimaryKeyRelatedField(queryset=Teacher.objects.all(), many=True, source='teachers')
+    students = serializers.SerializerMethodField()
+    levels = serializers.ListField(child=serializers.ChoiceField(choices=LEVEL_CHOICES))
+    plannings_read = serializers.SerializerMethodField()
+    plannings = PlanningSerializer(many=True, write_only=True)
+
+    class Meta:
+        model = SchoolClass
+        fields = [
+            'id', 'atmosphereName', 'ageGroup', 'numberOfStudents', 'teachingLanguage',
+            'teachers', 'teachers_ids', 'schoolYear', 'updatedDate',
+            'creationDateFormatted', 'students', 'levels', 'type', 'schedule',
+            'openingDays', 'plannings', 'plannings_read'
+        ]
+
+    def create(self, validated_data):
+        teachers_data = validated_data.pop('teachers', [])
+        levels_data = validated_data.pop('levels', [])
+        plannings_data = validated_data.pop('plannings', [])
+        
+        classModel = SchoolClass.objects.create(
+            atmosphereName=validated_data.get('atmosphereName', ''),
+            ageGroup=validated_data.get('ageGroup', []),
+            numberOfStudents=validated_data.get('numberOfStudents', 0),
+            teachingLanguage=validated_data.get('teachingLanguage', ''),
+            schoolYear=validated_data.get('schoolYear', ''),
+            levels=levels_data,
+            type=validated_data.get('type', 1),  # Added here
+            schedule=validated_data.get('schedule', ['08:30', '17:30']),  # Added here
+            openingDays=validated_data.get('openingDays', [1, 2, 4, 5])  # Added here
+        )
+
+        classModel.teachers.set(teachers_data)
+
+        for planning_data in plannings_data:
+            Planning.objects.create(
+                classModel=classModel,
+                level=planning_data['level'],
+                schedule=planning_data.get('schedule', {})
+            )
+
+        return classModel
+
+    def update(self, instance, validated_data):
+        teachers_data = validated_data.pop('teachers', [])
+        levels_data = validated_data.pop('levels', [])
+        plannings_data = validated_data.pop('plannings', [])
+
+        instance.atmosphereName = validated_data.get('atmosphereName', instance.atmosphereName)
+        instance.ageGroup = validated_data.get('ageGroup', instance.ageGroup)
+        instance.numberOfStudents = validated_data.get('numberOfStudents', instance.numberOfStudents)
+        instance.teachingLanguage = validated_data.get('teachingLanguage', instance.teachingLanguage)
+        instance.schoolYear = validated_data.get('schoolYear', instance.schoolYear)
+        instance.levels = levels_data
+        instance.type = validated_data.get('type', instance.type)  # Added here
+        instance.schedule = validated_data.get('schedule', instance.schedule)  # Added here
+        instance.openingDays = validated_data.get('openingDays', instance.openingDays)  # Added here
+
+        instance.save()
+        instance.teachers.set(teachers_data)
+
+        existing_plannings = {planning.level: planning for planning in instance.plannings.all()}
+
+        for planning_data in plannings_data:
+            level = planning_data['level']
+            if level in existing_plannings:
+                # Update existing planning
+                planning = existing_plannings[level]
+                planning.schedule = planning_data.get('schedule', planning.schedule)
+                planning.save()
+            else:
+                # Create new planning if level not existing
+                Planning.objects.create(
+                    classModel=instance,
+                    level=level,
+                    schedule=planning_data.get('schedule', {})
+                )
+
+        return instance
+
+    def get_creationDateFormatted(self, obj):
+        utc_time = timezone.localtime(obj.updatedDate)
+        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_students(self, obj):
+        studentsList = obj.students.all()
+        filtered_students = []
+        for student in studentsList:
+            registrationForm = bdd.getObject(RegistrationForm, "student__id", student.id)
+            if registrationForm.status == registrationForm.RegistrationFormStatus.RF_VALIDATED:
+                filtered_students.append(student)
+        return StudentSerializer(filtered_students, many=True, read_only=True).data
+
+    def get_plannings_read(self, obj):
+        plannings = obj.plannings.all()
+        levels_dict = {level: {'level': level, 'planning': None} for level in obj.levels}
+        
+        for planning in plannings:
+            if planning.level in levels_dict:
+                levels_dict[planning.level]['planning'] = PlanningSerializer(planning).data
+        
+        return list(levels_dict.values())

Back-End/School/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

Back-End/School/urls.py

@@ -0,0 +1,21 @@
+from django.urls import path, re_path
+
+from School.views import TeachersView, EnseignantView, SpecialitiesView, SpecialityView, ClassesView, ClasseView, PlanningsView, PlanningView
+
+urlpatterns = [
+    re_path(r'^teachers$', TeachersView.as_view(), name="teachers"),
+    re_path(r'^teacher$', EnseignantView.as_view(), name="teacher"),
+    re_path(r'^teacher/([0-9]+)$', EnseignantView.as_view(), name="teacher"),
+
+    re_path(r'^specialities$', SpecialitiesView.as_view(), name="specialities"),
+    re_path(r'^speciality$', SpecialityView.as_view(), name="speciality"),
+    re_path(r'^speciality/([0-9]+)$', SpecialityView.as_view(), name="speciality"),
+
+    re_path(r'^schoolClasses$', ClassesView.as_view(), name="schoolClasses"),
+    re_path(r'^schoolClass$', ClasseView.as_view(), name="schoolClass"),
+    re_path(r'^schoolClass/([0-9]+)$', ClasseView.as_view(), name="schoolClass"),
+
+    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/School/views.py

@@ -0,0 +1,245 @@
+from django.http.response import JsonResponse
+from django.views.decorators.csrf import ensure_csrf_cookie, csrf_protect
+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 Teacher, Speciality, SchoolClass, Planning
+from .serializers import TeacherSerializer, SpecialitySerializer, SchoolClassSerializer, PlanningSerializer
+from N3wtSchool import bdd
+
+class TeachersView(APIView):
+    def get(self, request):
+        teachersList=bdd.getAllObjects(Teacher)
+        teachers_serializer=TeacherSerializer(teachersList, many=True)
+
+        return JsonResponse(teachers_serializer.data, safe=False)
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class EnseignantView(APIView):
+    def get (self, request, _id):
+        teacher = bdd.getObject(_objectName=Teacher, _columnName='id', _value=_id)
+        teacher_serializer=TeacherSerializer(teacher)
+
+        return JsonResponse(teacher_serializer.data, safe=False)
+
+    def post(self, request):
+        teacher_data=JSONParser().parse(request)
+        teacher_serializer = TeacherSerializer(data=teacher_data)
+
+        if teacher_serializer.is_valid():
+            teacher_serializer.save()
+            
+            return JsonResponse(teacher_serializer.data, safe=False)           
+
+        return JsonResponse(teacher_serializer.errors, safe=False)
+
+    def put(self, request, _id):
+        teacher_data=JSONParser().parse(request)
+        teacher = bdd.getObject(_objectName=Teacher, _columnName='id', _value=_id)
+        teacher_serializer = TeacherSerializer(teacher, data=teacher_data)
+        if teacher_serializer.is_valid():
+            teacher_serializer.save()
+            return JsonResponse(teacher_serializer.data, safe=False)
+
+        return JsonResponse(teacher_serializer.errors, safe=False)
+
+    def delete(self, request, _id):
+        teacher = bdd.getObject(_objectName=Teacher, _columnName='id', _value=_id)
+        if teacher is not None:
+            if teacher.profilAssocie:
+                print('Suppression du profil associé')
+                teacher.profilAssocie.delete()
+            teacher.delete()
+            return JsonResponse({'message': 'La suppression de l\'teacher a été effectuée avec succès'}, safe=False)
+        else:
+            return JsonResponse({'erreur': 'L\'teacher n\'a pas été trouvé'}, safe=False)
+
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class SpecialitiesView(APIView):
+    def get(self, request):
+        specialitiesList=bdd.getAllObjects(Speciality)
+        specialities_serializer=SpecialitySerializer(specialitiesList, many=True)
+
+        return JsonResponse(specialities_serializer.data, safe=False)
+
+    def post(self, request):
+        specialities_data=JSONParser().parse(request)
+        all_valid = True
+        for speciality_data in specialities_data:
+            speciality_serializer = SpecialitySerializer(data=speciality_data)
+
+            if speciality_serializer.is_valid():
+                speciality_serializer.save()
+            else:
+                all_valid = False
+                break
+        if all_valid:
+            specialitiesList = bdd.getAllObjects(Speciality)
+            specialities_serializer = SpecialitySerializer(specialitiesList, many=True)
+
+            return JsonResponse(specialities_serializer.data, safe=False)
+
+        return JsonResponse(speciality_serializer.errors, safe=False)
+
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class SpecialityView(APIView):
+    def get (self, request, _id):
+        speciality = bdd.getObject(_objectName=Speciality, _columnName='id', _value=_id)
+        speciality_serializer=SpecialitySerializer(speciality)
+
+        return JsonResponse(speciality_serializer.data, safe=False)
+
+    def post(self, request):
+        speciality_data=JSONParser().parse(request)
+        speciality_serializer = SpecialitySerializer(data=speciality_data)
+
+        if speciality_serializer.is_valid():
+            speciality_serializer.save()
+            return JsonResponse(speciality_serializer.data, safe=False)
+
+        return JsonResponse(speciality_serializer.errors, safe=False)
+
+    def put(self, request, _id):
+        speciality_data=JSONParser().parse(request)
+        speciality = bdd.getObject(_objectName=Speciality, _columnName='id', _value=_id)
+        speciality_serializer = SpecialitySerializer(speciality, data=speciality_data)
+        if speciality_serializer.is_valid():
+            speciality_serializer.save()
+            return JsonResponse(speciality_serializer.data, safe=False)
+
+        return JsonResponse(speciality_serializer.errors, safe=False)
+
+    def delete(self, request, _id):
+        speciality = bdd.getObject(_objectName=Speciality, _columnName='id', _value=_id)
+        if speciality != None:
+            speciality.delete()
+    
+        return JsonResponse("La suppression de la spécialité a été effectuée avec succès", safe=False)
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class ClassesView(APIView):
+    def get(self, request):        
+        classesList=bdd.getAllObjects(SchoolClass)
+        classes_serializer=SchoolClassSerializer(classesList, many=True)
+        return JsonResponse(classes_serializer.data, safe=False)
+
+    def post(self, request):
+        all_valid = True
+        classes_data=JSONParser().parse(request)
+        for classe_data in classes_data:
+            classe_serializer = SchoolClassSerializer(data=classe_data)
+
+            if classe_serializer.is_valid():
+                classe_serializer.save()
+            else:
+                all_valid = False
+                break
+            
+        if all_valid:
+            classesList = bdd.getAllObjects(SchoolClass)
+            classes_serializer = SchoolClassSerializer(classesList, many=True)
+
+            return JsonResponse(classes_serializer.data, safe=False)
+
+        return JsonResponse(classe_serializer.errors, safe=False)
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class ClasseView(APIView):
+    def get (self, request, _id):
+        schoolClass = bdd.getObject(_objectName=SchoolClass, _columnName='id', _value=_id)
+        classe_serializer=SchoolClassSerializer(schoolClass)
+
+        return JsonResponse(classe_serializer.data, safe=False)
+
+    def post(self, request):
+        classe_data=JSONParser().parse(request)
+        classe_serializer = SchoolClassSerializer(data=classe_data)
+
+        if classe_serializer.is_valid():
+            classe_serializer.save()            
+            return JsonResponse(classe_serializer.data, safe=False)
+
+        return JsonResponse(classe_serializer.errors, safe=False)
+
+    def put(self, request, _id):
+        classe_data=JSONParser().parse(request)
+        schoolClass = bdd.getObject(_objectName=SchoolClass, _columnName='id', _value=_id)
+        classe_serializer = SchoolClassSerializer(schoolClass, data=classe_data)
+        if classe_serializer.is_valid():
+            classe_serializer.save()
+            return JsonResponse(classe_serializer.data, safe=False)
+
+        return JsonResponse(classe_serializer.errors, safe=False)
+
+    def delete(self, request, _id):
+        schoolClass = bdd.getObject(_objectName=SchoolClass, _columnName='id', _value=_id)
+        if schoolClass is not None:
+            # Supprimer les plannings associés à la schoolClass
+            for planning in schoolClass.plannings.all():
+                print(f'Planning à supprimer : {planning}')
+                planning.delete()
+
+            # Retirer la schoolClass des élèves associés
+            for eleve in schoolClass.eleves.all():
+                print(f'Student à retirer de la schoolClass : {eleve}')
+                eleve.classeAssociee = None
+                eleve.save()
+
+            # Supprimer la schoolClass
+            schoolClass.delete()
+
+        return JsonResponse("La suppression de la schoolClass 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)
+        
+        try:
+            planning = Planning.objects.get(id=_id)
+        except Planning.DoesNotExist:
+            return JsonResponse({'error': 'No object found'}, status=404)
+        except Planning.MultipleObjectsReturned:
+            return JsonResponse({'error': 'Multiple objects found'}, status=400)
+
+        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)