feat: Gestion du planning [3]

Back-End/Planning/views.py

@@ -1,18 +1,32 @@
 from django.http.response import JsonResponse
 from rest_framework.views import APIView
 from django.utils import timezone
+from dateutil.relativedelta import relativedelta
 
-from .models import Planning, Events
+from .models import Planning, Events, RecursionType
 
 from .serializers import PlanningSerializer, EventsSerializer
 
 from N3wtSchool import bdd
 
+
 class PlanningView(APIView):
     def get(self, request):
-        plannings=bdd.getAllObjects(Planning)
-        planning_serializer=PlanningSerializer(plannings, many=True)
+        establishment_id = request.GET.get('establishment_id', None)
+        planning_mode = request.GET.get('planning_mode', None)
 
+        plannings = bdd.getAllObjects(Planning)
+
+        if establishment_id is not None:
+            plannings = plannings.filter(establishment=establishment_id)
+
+        # Filtrer en fonction du planning_mode
+        if planning_mode == "classSchedule":
+            plannings = plannings.filter(school_class__isnull=False)
+        elif planning_mode == "planning":
+            plannings = plannings.filter(school_class__isnull=True)
+
+        planning_serializer = PlanningSerializer(plannings.distinct(), many=True)
         return JsonResponse(planning_serializer.data, safe=False)
 
     def post(self, request):
@@ -56,17 +70,63 @@ class PlanningWithIdView(APIView):
 
 class EventsView(APIView):
     def get(self, request):
-        events = bdd.getAllObjects(Events)
+        establishment_id = request.GET.get('establishment_id', None)
+        planning_mode = request.GET.get('planning_mode', None)
+        filterParams = {}
+        plannings=[]
+        events = Events.objects.all()
+        if establishment_id is not None :
+            filterParams['establishment'] = establishment_id
+        if planning_mode is not None:
+            filterParams['school_class__isnull'] = (planning_mode!="classSchedule")
+        if filterParams:
+            plannings = Planning.objects.filter(**filterParams)
+            events = Events.objects.filter(planning__in=plannings)
         events_serializer = EventsSerializer(events, many=True)
         return JsonResponse(events_serializer.data, safe=False)
 
     def post(self, request):
         events_serializer = EventsSerializer(data=request.data)
         if events_serializer.is_valid():
-            events_serializer.save()
+            event = events_serializer.save()
+
+            # Gérer les événements récurrents
+            if event.recursionType != RecursionType.RECURSION_NONE:
+                self.create_recurring_events(event)
+
             return JsonResponse(events_serializer.data, status=201)
         return JsonResponse(events_serializer.errors, status=400)
 
+    def create_recurring_events(self, event):
+        current_start = event.start
+        current_end = event.end
+
+        while current_start < event.recursionEnd:
+            if event.recursionType == RecursionType.RECURSION_DAILY:
+                current_start += relativedelta(days=1)
+                current_end += relativedelta(days=1)
+            elif event.recursionType == RecursionType.RECURSION_WEEKLY:
+                current_start += relativedelta(weeks=1)
+                current_end += relativedelta(weeks=1)
+            elif event.recursionType == RecursionType.RECURSION_MONTHLY:
+                current_start += relativedelta(months=1)
+                current_end += relativedelta(months=1)
+            else:
+                break  # Pour d'autres types de récurrence non gérés
+
+            # Créer une nouvelle occurrence
+            Events.objects.create(
+                planning=event.planning,
+                title=event.title,
+                description=event.description,
+                start=current_start,
+                end=current_end,
+                recursionEnd=event.recursionEnd,
+                recursionType=event.recursionType,  # Les occurrences ne sont pas récurrentes
+                color=event.color,
+                location=event.location,
+            )
+
 class EventsWithIdView(APIView):
     def put(self, request, id):
         try:
@@ -92,6 +152,18 @@ class EventsWithIdView(APIView):
 class UpcomingEventsView(APIView):
     def get(self, request):
         current_date = timezone.now()
-        upcoming_events = Events.objects.filter(start__gte=current_date)
+        establishment_id = request.GET.get('establishment_id', None)
+
+        if establishment_id is not None:
+            # Filtrer les plannings par establishment_id et sans school_class
+            plannings = Planning.objects.filter(establishment=establishment_id, school_class__isnull=True)
+            # Filtrer les événements associés à ces plannings et qui sont à venir
+            upcoming_events = Events.objects.filter(planning__in=plannings, start__gte=current_date)
+        else:
+            # Récupérer tous les événements à venir si aucun establishment_id n'est fourni
+            # et les plannings ne doivent pas être rattachés à une school_class
+            plannings = Planning.objects.filter(school_class__isnull=True)
+            upcoming_events = Events.objects.filter(planning__in=plannings, start__gte=current_date)
+
         events_serializer = EventsSerializer(upcoming_events, many=True)
         return JsonResponse(events_serializer.data, safe=False)