chore: Initial Commit

feat: Gestion des inscriptions [#1]
feat(frontend): Création des vues pour le paramétrage de l'école [#2]
feat: Gestion du login [#6]
fix: Correction lors de la migration des modèle [#8]
feat: Révision du menu principal [#9]
feat: Ajout d'un footer [#10]
feat: Création des dockers compose pour les environnements de
développement et de production [#12]
doc(ci): Mise en place de Husky et d'un suivi de version automatique [#14]

Back-End/GestionEnseignants/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'GestionEnseignants.apps.GestionenseignantsConfig'

Back-End/GestionEnseignants/admin.py

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

Back-End/GestionEnseignants/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class GestionenseignantsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'GestionEnseignants'

Back-End/GestionEnseignants/models.py

@@ -0,0 +1,32 @@
+from django.db import models
+
+class Specialite(models.Model):
+    nom = models.CharField(max_length=100)
+    dateCreation = models.DateTimeField(auto_now=True)
+    codeCouleur = models.CharField(max_length=7, default='#FFFFFF')
+
+    def __str__(self):
+        return self.nom
+
+class Enseignant(models.Model):
+    nom = models.CharField(max_length=100)
+    prenom = models.CharField(max_length=100)
+    mail = models.EmailField(unique=True)
+    specialite = models.ForeignKey(Specialite, on_delete=models.SET_NULL, null=True, blank=True, related_name='enseignants')
+
+    def __str__(self):
+        return f"{self.nom} {self.prenom}"
+
+class Classe(models.Model):
+    nom_ambiance = models.CharField(max_length=255)
+    tranche_age = models.JSONField()
+    nombre_eleves = models.PositiveIntegerField()
+    langue_enseignement = models.CharField(max_length=255)
+    annee_scolaire = models.CharField(max_length=9)
+    dateCreation = models.DateTimeField(auto_now_add=True)
+    specialites = models.ManyToManyField(Specialite, related_name='classes')
+    enseignant_principal = models.ForeignKey(Enseignant, on_delete=models.SET_NULL, null=True, blank=True, related_name='classes_principal')
+                                          
+    def __str__(self):
+        return self.nom_ambiance
+

Back-End/GestionEnseignants/serializers.py

@@ -0,0 +1,83 @@
+from rest_framework import serializers
+from .models import Enseignant, Specialite, Classe
+from N3wtSchool import settings
+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 ClasseSerializer(serializers.ModelSerializer):
+    specialites = SpecialiteSerializer(many=True, read_only=True)
+    specialites_ids = serializers.PrimaryKeyRelatedField(queryset=Specialite.objects.all(), many=True, source='specialites')
+    dateCreation_formattee = serializers.SerializerMethodField()
+    enseignant_principal = serializers.SerializerMethodField()
+    enseignant_principal_id = serializers.PrimaryKeyRelatedField(queryset=Enseignant.objects.all(), source='enseignant_principal', write_only=False, read_only=False)
+
+    class Meta:
+        model = Classe
+        fields = ['id', 'nom_ambiance', 'tranche_age', 'nombre_eleves', 'langue_enseignement', 'specialites', 'specialites_ids', 'enseignant_principal', 'enseignant_principal_id', 'annee_scolaire', 'dateCreation', 'dateCreation_formattee']
+
+    def get_enseignant_principal(self, obj):
+        from .serializers import EnseignantDetailSerializer
+        if obj.enseignant_principal:
+            return EnseignantDetailSerializer(obj.enseignant_principal).data
+        return None
+
+    def create(self, validated_data):
+        specialites_data = validated_data.pop('specialites', [])
+        classe = Classe.objects.create(**validated_data)
+        classe.specialites.set(specialites_data)
+        return classe
+
+    def update(self, instance, validated_data):
+        specialites_data = validated_data.pop('specialites', [])
+        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.enseignant_principal = validated_data.get('enseignant_principal', instance.enseignant_principal)
+        instance.save()
+        instance.specialites.set(specialites_data)
+        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")
+
+class EnseignantSerializer(serializers.ModelSerializer):
+    specialite = SpecialiteSerializer(read_only=True)
+    specialite_id = serializers.PrimaryKeyRelatedField(queryset=Specialite.objects.all(), source='specialite', write_only=False, read_only=False)
+    classes_principal = ClasseSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Enseignant
+        fields = ['id', 'nom', 'prenom', 'mail', 'specialite', 'specialite_id', 'classes_principal']
+    
+    def create(self, validated_data):
+        specialite = validated_data.pop('specialite', None)
+        enseignant = Enseignant.objects.create(**validated_data)
+        enseignant.specialite = specialite
+        enseignant.save()
+        return enseignant
+
+class EnseignantDetailSerializer(serializers.ModelSerializer):
+    specialite = SpecialiteSerializer(read_only=True)
+
+    class Meta:
+        model = Enseignant
+        fields = ['id', 'nom', 'prenom', 'mail', 'specialite']

Back-End/GestionEnseignants/tests.py

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

Back-End/GestionEnseignants/urls.py

@@ -0,0 +1,17 @@
+from django.urls import path, re_path
+
+from GestionEnseignants.views import EnseignantsView, EnseignantView, SpecialitesView, SpecialiteView, ClassesView, ClasseView
+
+urlpatterns = [
+    re_path(r'^enseignants$', EnseignantsView.as_view(), name="enseignants"),
+    re_path(r'^enseignant$', EnseignantView.as_view(), name="enseignant"),
+    re_path(r'^enseignant/([0-9]+)$', EnseignantView.as_view(), name="enseignant"),
+
+    re_path(r'^specialites$', SpecialitesView.as_view(), name="specialites"),
+    re_path(r'^specialite$', SpecialiteView.as_view(), name="specialite"),
+    re_path(r'^specialite/([0-9]+)$', SpecialiteView.as_view(), name="specialite"),
+
+    re_path(r'^classes$', ClassesView.as_view(), name="classes"),
+    re_path(r'^classe$', ClasseView.as_view(), name="classe"),
+    re_path(r'^classe/([0-9]+)$', ClasseView.as_view(), name="classe"),
+]

Back-End/GestionEnseignants/views.py

@@ -0,0 +1,180 @@
+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 Enseignant, Specialite, Classe
+from .serializers import EnseignantSerializer, SpecialiteSerializer, ClasseSerializer
+from N3wtSchool import bdd
+
+class EnseignantsView(APIView):
+    def get(self, request):
+        enseignantsList=bdd.getAllObjects(Enseignant)
+        enseignants_serializer=EnseignantSerializer(enseignantsList, many=True)
+
+        return JsonResponse(enseignants_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):
+        enseignant = bdd.getObject(_objectName=Enseignant, _columnName='id', _value=_id)
+        enseignant_serializer=EnseignantSerializer(enseignant)
+
+        return JsonResponse(enseignant_serializer.data, safe=False)
+
+    def post(self, request):
+        enseignant_data=JSONParser().parse(request)
+        enseignant_serializer = EnseignantSerializer(data=enseignant_data)
+
+        if enseignant_serializer.is_valid():
+            enseignant_serializer.save()
+            
+            return JsonResponse(enseignant_serializer.data, safe=False)           
+
+        return JsonResponse(enseignant_serializer.errors, safe=False)
+
+    def put(self, request, _id):
+        enseignant_data=JSONParser().parse(request)
+        enseignant = bdd.getObject(_objectName=Enseignant, _columnName='id', _value=_id)
+        enseignant_serializer = EnseignantSerializer(enseignant, data=enseignant_data)
+        if enseignant_serializer.is_valid():
+            enseignant_serializer.save()
+            return JsonResponse(enseignant_serializer.data, safe=False)
+
+        return JsonResponse(enseignant_serializer.errors, safe=False)
+
+    def delete(self, request, _id):
+        enseignant = bdd.getObject(_objectName=Enseignant, _columnName='id', _value=_id)
+        if enseignant != None:
+            enseignant.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 SpecialitesView(APIView):
+    def get(self, request):
+        specialitesList=bdd.getAllObjects(Specialite)
+        specialites_serializer=SpecialiteSerializer(specialitesList, many=True)
+
+        return JsonResponse(specialites_serializer.data, safe=False)
+
+    def post(self, request):
+        specialites_data=JSONParser().parse(request)
+        all_valid = True
+        for specialite_data in specialites_data:
+            specialite_serializer = SpecialiteSerializer(data=specialite_data)
+
+            if specialite_serializer.is_valid():
+                specialite_serializer.save()
+            else:
+                all_valid = False
+                break
+        if all_valid:
+            specialitesList = bdd.getAllObjects(Specialite)
+            specialites_serializer = SpecialiteSerializer(specialitesList, many=True)
+
+        return JsonResponse(specialite_serializer.errors, safe=False)
+
+
+@method_decorator(csrf_protect, name='dispatch')
+@method_decorator(ensure_csrf_cookie, name='dispatch')
+class SpecialiteView(APIView):
+    def get (self, request, _id):
+        specialite = bdd.getObject(_objectName=Specialite, _columnName='id', _value=_id)
+        specialite_serializer=SpecialiteSerializer(specialite)
+
+        return JsonResponse(specialite_serializer.data, safe=False)
+
+    def post(self, request):
+        specialite_data=JSONParser().parse(request)
+        specialite_serializer = SpecialiteSerializer(data=specialite_data)
+
+        if specialite_serializer.is_valid():
+            specialite_serializer.save()
+            return JsonResponse(specialite_serializer.data, safe=False)
+
+        return JsonResponse(specialite_serializer.errors, safe=False)
+
+    def put(self, request, _id):
+        specialite_data=JSONParser().parse(request)
+        specialite = bdd.getObject(_objectName=Specialite, _columnName='id', _value=_id)
+        specialite_serializer = SpecialiteSerializer(specialite, data=specialite_data)
+        if specialite_serializer.is_valid():
+            specialite_serializer.save()
+            return JsonResponse(specialite_serializer.data, safe=False)
+
+        return JsonResponse(specialite_serializer.errors, safe=False)
+
+    def delete(self, request, _id):
+        specialite = bdd.getObject(_objectName=Specialite, _columnName='id', _value=_id)
+        if specialite != None:
+            specialite.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(Classe)
+        classes_serializer=ClasseSerializer(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 = ClasseSerializer(data=classe_data)
+
+            if classe_serializer.is_valid():
+                classe_serializer.save()
+            else:
+                all_valid = False
+                break
+            
+        if all_valid:
+            classesList = bdd.getAllObjects(Classe)
+            classes_serializer = ClasseSerializer(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):
+        classe = bdd.getObject(_objectName=Classe, _columnName='id', _value=_id)
+        classe_serializer=ClasseSerializer(classe)
+
+        return JsonResponse(classe_serializer.data, safe=False)
+
+    def post(self, request):
+        classe_data=JSONParser().parse(request)
+        classe_serializer = ClasseSerializer(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)
+        classe = bdd.getObject(_objectName=Classe, _columnName='id', _value=_id)
+        classe_serializer = ClasseSerializer(classe, 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):
+        classe = bdd.getObject(_objectName=Classe, _columnName='id', _value=_id)
+        if classe != None:
+            classe.delete()
+    
+        return JsonResponse("La suppression de la classe a été effectuée avec succès", safe=False)