[activites/views] Amélioration de l'API

activites/views.py

@@ -23,8 +23,10 @@ from rest_framework import viewsets
 from rest_framework.response import Response
 from rest_framework.decorators import detail_route
 
+from note_kfet.utils import to_bool
 from note_kfet.droits import D, Acl
 from note_kfet.views.mixins import NoteMixin
+from note_kfet.views.decorators import requires
 
 from comptes.models import Adherent
 
@@ -370,37 +372,27 @@ class ActiviteViewSet(viewsets.GenericViewSet):
     queryset = Activite.objects.all()
     serializer_class = ActiviteSerializer
 
-    def get_queryset(self):
-        qs = super().get_queryset().filter()
-        if not self.request.user.has_perm("activites.activite_gerer", Acl.BASIQUE):
-            return qs.filter(Q(organisateur=self.request.user) | Q(valide_par__isnull=False))
-        else:
-            return qs
-
     def list(self, request):
         """
             Renvoie la liste des activités enregistrées.
-            Le paramètre 'show' peut prendre deux valeurs : 'normal' pour
-            afficher seulement les activités en cours ou à venir, ou 'all' pour
-            afficher toutes les activités. La valeur par défaut est 'normal'.
+            Le paramètre 'all' peut prendre deux valeurs : 'false' pour
+            afficher seulement les activités en cours ou à venir, ou 'true' pour
+            afficher toutes les activités. La valeur par défaut est 'false'.
             Les données doivent:
                 -   être envoyées via un requête GET
-                -   contenir dans la querystring le paramètre 'show'
+                -   contenir dans la querystring le paramètre 'all'
         """
-        show = self.request.query_params.get('show', 'normal')
-        if show not in ['normal', 'all']:
+        show_all = to_bool(request.query_params.get('all', False))
+        if show_all is None:
             return Response(
-                {"detail" : "Paramètre 'show' incorrect"},
+                {"detail" : "Paramètre 'all' incorrect"},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        lookup_args = {'fin__gte' : timezone.now()} if show == "normal" else {}
-        qs = super().get_queryset().filter(**lookup_args)
-        serializer = self.get_serializer(
-            qs,
-            many=True,
-            fields=['id', 'intitule', 'description', 'debut', 'fin', 'liste_invitation'],
-        )
+        lookup_args = {'fin__gte' : timezone.now()} if show_all else {}
+        qs = self.get_queryset().filter(**lookup_args)
+        fields = ['id', 'intitule', 'description', 'debut', 'fin', 'liste_invitation']
+        serializer = self.get_serializer(qs, many=True, fields=fields)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     def retrieve(self, request, pk=None):
@@ -410,44 +402,35 @@ class ActiviteViewSet(viewsets.GenericViewSet):
                 -   être envoyées via une requête GET
         """
         fields = ['id', 'intitule', 'description', 'debut', 'fin', 'liste_invitation']
-        if self.request.user.has_perm("activites.activite_gerer", Acl.LIMITE):
+        if self.request.user.has_perm("activites.activite_gerer", Acl.BASIQUE):
             fields += ['organisateur', 'valide_par']
 
         serializer = self.get_serializer(self.get_object(), fields=fields)
-        return Response(serializer.data)
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
+    @requires("activites.activite_ajouter")
     def create(self, request):
         """
             Ajoute une nouvelle activité.
             Les données doivent:
                 -   être envoyées via une requête POST
-                -
         """
-        if not request.user.has_perm("activites.activite_ajouter", Acl.LIMITE):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
 
-        if ('organisateur' in request.data
-                and request.user.has_perm("activites.activite_ajouter", Acl.ETENDU)):
-            pass
-        elif 'organisateur' in request.data.dict():
+        if (not request.user.has_perm("activites.activite_ajouter", Acl.ETENDU)
+                and serializer.validated_data['organisateur'] != request.user):
             return Response(
                 {
-                    "detail" : "Vous ne pouvez pas indiquer d'organisateur",
+                    "detail" : "Vous ne pouvez pas indiquer un autre organisateur que vous-même",
                 },
                 status=status.HTTP_403_FORBIDDEN
             )
-        else:
-            # L'organisateur n'a pas été spécifié, mais de toute façon l'utilisateur n'a
-            # pas le droit de le faire
-            request.data['organisateur'] = request.user
-
-        serializer = self.get_serializer(data=request.data)
-        if not serializer.is_valid():
-            return Response({}, status=status.HTTP_400_BAD_REQUEST)
 
         activite = serializer.save()
         return Response({"id" : activite.id}, status=status.HTTP_201_CREATED)
 
+    @requires("activites.activite_modifier")
     def partial_update(self, request, pk=None):
         """
             Modifie une activité donnée. Il n'est pas possible de valider ou dévalider
@@ -455,17 +438,16 @@ class ActiviteViewSet(viewsets.GenericViewSet):
             Les données doivent :
                 -   être envoyées via une requête PATCH
         """
-        if not request.user.has_perm("activites.activite_modifier", Acl.LIMITE):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
-        if 'valide_par' in request.data:
-            return Response(
-                {"detail" : "Impossible de valider/dévalider une activité"}, # XXX: C'est pas très clair
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
         fields = ['intitule', 'description', 'debut', 'fin', 'liste_invitation', 'organisateur']
         activite = self.get_object()
+        if (activite.organisateur != request.user
+                and not request.user.has_perm("activites.activite_modifier", Acl.ETENDU)):
+            return Response(
+                {
+                    "detail" : "Vous ne pouvez pas modifier cette activité",
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
         serializer = self.get_serializer(activite, data=request.data, partial=True, fields=fields)
         serializer.is_valid(raise_exception=True)
         if ('organisateur' in serializer.validated_data
@@ -479,46 +461,35 @@ class ActiviteViewSet(viewsets.GenericViewSet):
         return Response({}, status=status.HTTP_200_OK)
 
     @detail_route(methods=['patch'])
-    def status(self, request, pk=None):
+    @requires("activites.activite_gerer", Acl.ETENDU)
+    def valide(self, request, pk=None):
         """
             Valide ou dévalide une activité.
             Les données doivent :
                 -   être envoyées via une requête PATCH
-                -   contenir un unique paramètre 'action' pouvant valoir 'valider' ou 'devalider'
+                -   contenir un unique paramètre 'valide' pouvant valoir 'true' ou 'false'
         """
-        if not request.user.has_perm("activites.activite_gerer", Acl.ETENDU):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
-        action = request.data.get('action', None)
-        if action not in ['valider', 'devalider']:
-            return Response({"detail" : "Paramètre 'action' invalide"}, status=status.HTTP_400_BAD_REQUEST)
+        valide = to_bool(request.data.get('valide', None))
+        if valide is None:
+            return Response(
+                {"detail" : "Paramètre 'valide' manquant"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
 
         activite = self.get_object()
-        if activite.valide_par is None and action == 'devalider':
-            # L'activité est dévalidée, mais on demande de nouveau une dévalidation
-            return Response({"detail" : "L'activité est déjà dévalidée"}, status=status.HTTP_409_CONFLICT)
-        elif action == 'devalider':
-            # L'activité est validée, et on demande sa dévalidation
-            activite.valide_par = None
-        elif activite.valide_par is None:
-            # L'activité est dévalidée, et on demande sa validation
-            activite.valide_par = request.user
-        else:
-            # L'activité est validée, mais on demande de nouveau sa validation
-            return Response({"detail" : "L'activité est déjà validée"}, status=status.HTTP_409_CONFLICT)
-
-        activite.save()
+        serializer = self.get_serializer(
+            activite, data=request.data, partial=True, fields=['valide'],
+        )
+        serializer.save()
         return Response({}, status=status.HTTP_200_OK)
 
+    @requires("activites.activite_modifier")
     def destroy(self, request, pk=None):
         """
             Supprime une activité.
             Les données doivent :
                 -   être envoyées via une requête DELETE
         """
-        if not request.user.has_perm("activites.activite_modifier", Acl.LIMITE):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
         activite = self.get_object()
         if (activite.organisateur != request.user
                 and not request.user.has_perm("activites.activite_modifier", Acl.ETENDU)):
@@ -538,83 +509,72 @@ class InviteViewSet(viewsets.GenericViewSet):
     """
         Un ensemble du vues pour gérer les invités
     """
+    queryset = Invite.objects.all()
     serializer_class = InviteSerializer
 
     def get_queryset(self):
-        return Invite.objects.filter(activite=self.kwargs['activite_pk'])
+        lookup_args = {
+            'activite' : self.kwargs['activite_pk'],
+            'activite__liste_invitation' : True,
+        }
+        return super().get_queryset().filter(**lookup_args)
 
+    @requires("activites.activite_gerer", Acl.TOTAL)
     def list(self, request, activite_pk=None):
         """
             Renvoie la liste des invités à une activité donnée.
             Les données doivent :
                 -   être envoyées via une requête GET
         """
-        if not request.user.has_perm("activites.activite_gerer", Acl.TOTAL):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
-        if not Activite.objects.get(pk=self.kwargs['activite_pk']).liste_invitation:
-            return Response(
-                {"detail" : "Cette activité n'a pas de liste d'invités"},
-                status=status.HTTP_404_NOT_FOUND,
-            )
-
         serializer = self.get_serializer(self.get_queryset(), many=True)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
+    @requires("activites.activite_gerer", Acl.TOTAL)
     def retrieve(self, request, pk=None, activite_pk=None):
         """
             Renvoie les informations concernant un invité donné.
             Les données doivent :
                 -   être envoyées via une requête GET
         """
-        if not request.user.has_perm("activites.activite_gerer", Acl.TOTAL):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
         invite = self.get_object()
         serializer = self.get_serializer(invite)
         return Response(serializer.data, status=status.HTTP_200_OK)
 
-    def create(self, request, pk=None, activite_pk=None):
+    @requires("activites.invite_inviter", Acl.LIMITE)
+    def create(self, request, activite_pk=None):
         """
             Ajoute un invité à l'activité courante
             Les données doivent :
                 -   être envoyées via une requête POST
         """
-        if not request.user.has_perm("activites.invite_inviter", Acl.LIMITE):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
         activite = Activite.objects.get(pk=activite_pk)
         if not activite.liste_invitation:
             # Pas de liste d'invités pour cette activité
             return Response(
                 {"detail" : "Il n'y a pas de liste d'invités pour cette activité"},
-                status=status.HTTP_400_BAD_REQUEST,
+                status=status.HTTP_409_CONFLICT,
             )
 
-        if ('invite_par' in request.data
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        if (serializer.validated_data['invite_par'] != request.user
                 and not request.user.has_perm("activites.invite_inviter", Acl.TOTAL)):
             return Response(
                 {"detail" : "Vous ne pouvez inviter une personne qu'en vôtre nom"},
                 status=status.HTTP_403_FORBIDDEN,
             )
-        else:
-            request.data['invite_par'] = request.user.pk
-        request.data['activite'] = activite.pk
 
-        serializer = self.get_serializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
         serializer.save()
         return Response({}, status=status.HTTP_201_CREATED)
 
+    @requires("activites.invite_supprimer")
     def destroy(self, request, pk=None, activite_pk=None):
         """
             Supprime un invité à une activité donnée.
             Les données doivent :
                 -   être envoyées via une requête DELETE
         """
-        if not request.user.has_perm("activites.invite_supprimer", Acl.LIMITE):
-            return Response({}, status=status.HTTP_403_FORBIDDEN)
-
         invite = self.get_object()
         if (invite.invite_par != request.user
                 and not request.user.has_perm("activites.invite_supprimer", Acl.TOTAL)):