Add backend for bookable office hours

- Created new Booking model, serializer, permission, urls, and viewset

Author: dkwncho

backend/ohq/models.py

@@ -4,7 +4,11 @@
 from django.dispatch import receiver
 from email_tools.emails import send_email
 from phonenumber_field.modelfields import PhoneNumberField
-
+from schedule.models import Event, Occurrence
+from django.utils.translation import gettext, gettext_lazy as _
+from django.template.defaultfilters import date
+from django.conf import settings as django_settings
+from django.urls import reverse
 
 User = settings.AUTH_USER_MODEL
 
@@ -447,3 +451,25 @@ class Meta:
 
     def __str__(self):
         return f"{self.user}: {self.metric}"
+
+class Booking(models.Model):
+    """
+    Booking within an occurrence
+    """
+
+    occurrence = models.ForeignKey(Occurrence, on_delete=models.CASCADE)
+    user = models.ForeignKey(User, on_delete=models.CASCADE, blank=True, null=True)
+    start = models.DateTimeField(_("start"), db_index=True, blank=True)
+    end = models.DateTimeField(_("end"), db_index=True, blank=True)
+
+    class Meta:
+        verbose_name = _("booking")
+        verbose_name_plural = _("bookings")
+        ordering = ["start"]
+        index_together = (("start", "end"),)
+
+    def __str__(self):
+        return gettext("%(start)s to %(end)s") % {
+            "start": date(self.start, django_settings.DATE_FORMAT),
+            "end": date(self.end, django_settings.DATE_FORMAT),
+        }

backend/ohq/permissions.py

@@ -2,7 +2,7 @@
 from rest_framework import permissions
 from schedule.models import Event, EventRelation, Occurrence
 
-from ohq.models import Course, Membership, Question
+from ohq.models import Course, Membership, Question, Booking
 
 
 # Hierarchy of permissions is usually:
@@ -504,3 +504,69 @@ def has_permission(self, request, view):
             return True
 
         return True
+
+class BookingPermission(permissions.BasePermission):
+    def get_membership_from_event(self, request, event):
+        event_course_relation = EventRelation.objects.filter(event=event).first()
+        membership = Membership.objects.filter(
+            course_id=event_course_relation.object_id, user=request.user
+        ).first()
+        return membership
+    
+    def has_object_permission(self, request, view, obj):
+        if view.action in ["retrieve"]:
+            booking = Booking.objects.filter(pk=view.kwargs["pk"]).first()
+            membership = self.get_membership_from_event(request=request, event=booking.occurrence.event)
+            return membership is not None
+
+        if view.action in ["update", "partial_update"]:
+            booking = Booking.objects.filter(pk=view.kwargs["pk"]).first()
+            membership = self.get_membership_from_event(request=request, event=booking.occurrence.event)
+
+            if membership is not None:
+                if membership.is_ta:
+                    return True
+                else:
+                    updated_fields = request.data.keys()
+                    restricted_student_fields = ["occurrence", "start", "end"] # allowed_student_field would be "user"
+
+                    for field in updated_fields:
+                        if field in restricted_student_fields:
+                            return False
+                    if "user" in updated_fields:
+                        if booking.user is not None: # Doesn’t allow a student to update user if someone already booked the slot
+                            return False
+                        else:
+                            return True
+            else:
+                return False    
+
+        return False
+    
+    def has_permission(self, request, view):
+        if not request.user.is_authenticated:
+            return False
+
+        # Anonymous users can't do anything
+        if view.action in ["create"]:
+            course_pk = request.data.get("course_id", None)
+            if course_pk is None:
+                return False
+
+            course = Course.objects.get(pk=course_pk)
+            membership = Membership.objects.filter(course=course, user=request.user).first()
+
+            if membership is None:
+                return False
+            return membership.is_ta
+
+        if view.action in ["list"]:
+            # if any member of the course in the list is not accessible, return false
+            course_ids = request.GET.getlist("course")
+            for course in course_ids:
+                membership = Membership.objects.filter(course=course, user=request.user).first()
+                if membership is None:
+                    return False
+            return True
+
+        return True

backend/ohq/serializers.py

@@ -22,6 +22,7 @@
     QueueStatistic,
     Semester,
     Tag,
+    Booking,
 )
 from ohq.sms import sendSMSVerification
 from ohq.tasks import sendUpNextNotificationTask
@@ -592,4 +593,16 @@ class OccurrenceSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Occurrence
-        fields = ("id", "title", "description", "location", "start", "end", "cancelled", "event")
+        fields = ("id", "title", "description", "location", "start", "end", "cancelled", "event", "interval")
+
+class BookingSerializer(serializers.ModelSerializer):
+    """
+    Serializer for booking
+    """
+
+    occurrence = OccurrenceSerializer(read_only=True)
+
+    class Meta:
+        model = Booking
+        fields = ("id", "occurrence", "user", "start", "end")  
+

backend/ohq/urls.py

@@ -19,6 +19,7 @@
     SemesterViewSet,
     TagViewSet,
     UserView,
+    BookingViewSet,
 )
 
 
@@ -29,6 +30,7 @@
 router.register("courses", CourseViewSet, basename="course")
 router.register("events", EventViewSet, basename="event")
 router.register("occurrences", OccurrenceViewSet, basename="occurrence")
+router.register("bookings", BookingViewSet, basename="booking")
 
 course_router = routers.NestedSimpleRouter(router, "courses", lookup="course")
 course_router.register("queues", QueueViewSet, basename="queue")

backend/ohq/views.py

@@ -19,6 +19,8 @@
 from django.http import HttpResponseBadRequest, JsonResponse
 from django.utils import timezone
 from django.utils.crypto import get_random_string
+from django.utils.translation import gettext_lazy as _
+from django.conf import settings as django_settings
 from django_auto_prefetching import prefetch
 from django_filters.rest_framework import DjangoFilterBackend
 from drf_excel.mixins import XLSXFileMixin
@@ -46,6 +48,7 @@
     QueueStatistic,
     Semester,
     Tag,
+    Booking,
 )
 from ohq.pagination import QuestionSearchPagination
 from ohq.permissions import (
@@ -63,6 +66,7 @@
     QueuePermission,
     QueueStatisticPermission,
     TagPermission,
+    BookingPermission,
 )
 from ohq.schemas import EventSchema, MassInviteSchema, OccurrenceSchema
 from ohq.serializers import (
@@ -81,6 +85,7 @@
     SemesterSerializer,
     TagSerializer,
     UserPrivateSerializer,
+    BookingSerializer,
 )
 from ohq.sms import sendSMSVerification
 
@@ -741,15 +746,15 @@ class OccurrenceViewSet(
     You must specify all of the fields or use a patch request.
 
     partial_update:
-    Update certain fields in the Occurrece.
+    Update certain fields in the Occurrence.
     """
 
     serializer_class = OccurrenceSerializer
     permission_classes = [OccurrencePermission | IsSuperuser]
     schema = OccurrenceSchema()
 
     def list(self, request, *args, **kwargs):
-        # ensure timezone consitency
+        # ensure timezone consistency
         course_ids = request.GET.getlist("course")
         filter_start = datetime.strptime(
             request.GET.get("filter_start"), "%Y-%m-%dT%H:%M:%SZ"
@@ -772,6 +777,103 @@ def list(self, request, *args, **kwargs):
 
         serializer = OccurrenceSerializer(occurrences, many=True)
         return JsonResponse(serializer.data, safe=False)
+    
+    def update(self, request, *args, **kwargs):
+        occurrence = self.get_object()
+        old_start = occurrence.start
+        old_end = occurrence.end
+        occurrence.start = datetime.strptime(request.data.get("start"), "%Y-%m-%dT%H:%M:%SZ").replace(
+            tzinfo=utc
+        )
+        occurrence.end = datetime.strptime(request.data.get("end"), "%Y-%m-%dT%H:%M:%SZ").replace(
+            tzinfo=utc
+        )
+        start_delta = occurrence.start - old_start
+        end_delta = occurrence.end - old_end
+        occurrence.save()
+
+        bookings = Booking.objects.filter(occurrence=occurrence).order_by("start")
+
+        for booking in bookings:
+            booking.start += start_delta
+            booking.end += end_delta
+            booking.save()
+
+        serializer = OccurrenceSerializer(occurrence)
+        return JsonResponse(serializer.data, safe=False)
 
     def get_queryset(self):
         return Occurrence.objects.filter(pk=self.kwargs["pk"])
+
+class BookingViewSet(
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.CreateModelMixin,
+    mixins.UpdateModelMixin,
+    viewsets.GenericViewSet,
+):
+    """
+    retrieve:
+    Return a Booking.
+
+    list:
+    You should pass in an occurrence id, and all the bookings related to that occurrence will be returned to you.
+    Return a list of bookings.
+
+    create:
+    Create a booking.
+    occurrenceId is required in body.
+
+    update:
+    Update all fields in a Booking.
+    You must specify all of the fields or use a patch request.
+
+    partial_update:
+    Update certain fields in the Booking.
+    """
+
+    serializer_class = BookingSerializer
+    permission_classes = [BookingPermission | IsSuperuser]
+
+    def create(self, request, *args, **kwargs):        
+        occurrence_id = request.data.get("occurrence")
+        occurrence = Occurrence.objects.get(id=occurrence_id) 
+        user = request.user
+        existing_bookings = Booking.objects.filter(occurrence=occurrence).order_by("start")
+
+        if existing_bookings.exists():
+            last_booking = existing_bookings.last()
+            start = last_booking.end
+        else:
+            start = occurrence.start
+        
+        end = start + occurrence.interval
+
+        if start < occurrence.start or end > occurrence.end:
+            raise ValidationError(_("Booking times must be within the occurrence's time range."))
+
+        booking = Booking(
+            occurrence=occurrence,
+            user=user,
+            start=start,
+            end=end,
+        )
+
+        booking.save()
+
+        serializer = BookingSerializer(booking)
+        return JsonResponse(serializer.data, safe=False)
+    
+    def list(self,request, *args, **kwargs):
+        occurrence_id = request.GET.get("occurrence")
+        if occurrence_id is None:
+            raise ValidationError(_(f"Occurrence id is required."))
+        
+        occurrence = Occurrence.objects.get(id=occurrence_id) 
+        existing_bookings = Booking.objects.filter(occurrence=occurrence).order_by("start")
+
+        serializer = BookingSerializer(existing_bookings, many=True)
+        return JsonResponse(serializer.data, safe=False)
+    
+    def get_queryset(self):
+        return Booking.objects.filter(pk=self.kwargs["pk"])