Merge pull request #17 from DevOps-Cloud-Team5/SCRUM-83-Manipulate-lectures

add support for lecture manipulation

Author: Imafe

api/serializers.py

@@ -6,7 +6,7 @@
 from rest_framework_simplejwt.serializers import TokenObtainPairSerializer
 from rest_framework.validators import UniqueValidator
 
-from .models import AccountRoles, Course
+from .models import AccountRoles, Course, CourseLecture, LectureTypes
 
 User = get_user_model()
 
@@ -29,6 +29,11 @@ class CourseSerializer(serializers.ModelSerializer):
     class Meta:
         model = Course
         fields = '__all__'
+        
+class LectureSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = CourseLecture
+        fields = '__all__'
 
 # Defines the rules for registering a new user. Required fields, validation rules etc.
 class CreateUserSerializer(serializers.ModelSerializer):
@@ -73,8 +78,6 @@ def create(self, validated_data):
         c.save()
         return c
 
-
- 
 class MassEnrollSerializer(serializers.Serializer):
     usernames = serializers.ListField(required=True, allow_empty=False, child=serializers.CharField(max_length=150))
 
@@ -88,4 +91,32 @@ def validate_enroll(self, username):
 
     def validate(self, attrs):
         for username in attrs["usernames"]: self.validate_enroll(username)
+        return attrs
+    
+class AddLectureSerializer(serializers.Serializer):
+    MINIMUM_LECTURE_LENGTH = 10 # Minimum lecture length of 10 minutes
+    
+    start_time = serializers.DateTimeField(required=True)
+    end_time = serializers.DateTimeField(required=True)
+    lecture_type = serializers.CharField(required=True)
+
+    def validate(self, attrs):
+        start_time, end_time = attrs["start_time"], attrs["end_time"]
+        if start_time > end_time:
+            raise serializers.ValidationError({"error": f"end_time has to be after start_time"})
+        
+        lecture_length = (end_time - start_time).seconds / 60
+        if lecture_length < self.MINIMUM_LECTURE_LENGTH:
+            raise serializers.ValidationError({"error": f"lecture has to be at least {self.MINIMUM_LECTURE_LENGTH} minutes"})
+            
+        lecture_type = attrs["lecture_type"]
+        if lecture_type not in LectureTypes.values: 
+            raise serializers.ValidationError({"error": f"invalid lecture type: '{lecture_type}'"})
+        
+        course : Course = self.context.get("course")
+        for lecture in course.get_lectures():
+            for timestamp in [start_time, end_time]:
+                if lecture.start_time < timestamp and timestamp < lecture.end_time:
+                    raise serializers.ValidationError({"error": "there is already an active lecture during this time range"})
+        
         return attrs

api/urls.py

@@ -17,6 +17,9 @@
 from rest_framework_simplejwt.views import TokenRefreshView, TokenVerifyView, TokenBlacklistView
 from drf_spectacular.views import SpectacularAPIView, SpectacularSwaggerView
 from .views import (
+                    AddLectureView,
+                    GetCourseLecturesView,
+                    GetLectureView,
                     MassEnrollCourseView,
                     test, 
                     genAdmin, 
@@ -62,6 +65,16 @@
     path('course/mass_enroll/<pk>', MassEnrollCourseView.as_view(), name='course_mass_enroll'),
     path('course/get/<pk>', GetCourseByName.as_view(), name='course_get'),
     path('course/getall/', GetCoursesAll.as_view(), name='course_getall'),
+    
+    path('course/lecture/<pk>/get', GetCourseLecturesView.as_view(), name='course_get_lecture'),
+    path('course/lecture/<pk>/add', AddLectureView.as_view(), name='course_add_lecture'),
+    # path('course/lecture/<pk>/update', GetCourseByName.as_view(), name='lecture_add'), # TODO
+    # path('course/lecture/<pk>/delete', GetCourseByName.as_view(), name='lecture_add'),
+
+    path('lecture/<pk>/get', GetLectureView.as_view(), name='lecture_get'),
+    path('lecture/<pk>/student_att', GetLectureView.as_view(), name='lecture_get'),
+    path('lecture/<pk>/teacher_att', GetLectureView.as_view(), name='lecture_get'),
+
 
     # Documentation
     path('schema/', SpectacularAPIView.as_view(), name='schema'),

api/views.py

@@ -13,8 +13,8 @@
 from drf_spectacular.utils import extend_schema, OpenApiResponse
 
 from .permissions import IsTeacher, IsAdmin, IsStudent
-from .models import Course, AccountRoles
-from .serializers import CustomTokenSerializer, CreateUserSerializer, MassEnrollSerializer, UserSerializer, CourseCreateSerializer, CourseSerializer
+from .models import Course, AccountRoles, CourseLecture
+from .serializers import AddLectureSerializer, CustomTokenSerializer, CreateUserSerializer, LectureSerializer, MassEnrollSerializer, UserSerializer, CourseCreateSerializer, CourseSerializer
 
 import pdb
 
@@ -110,11 +110,10 @@ class GetUserByUsername(generics.RetrieveAPIView):
 
     def get(self, _, username):
         queryset = self.get_queryset().filter(username=username)
-        serializer = self.serializer_class(queryset, many=True)
-        if len(serializer.data) == 0:
+        if not queryset:
             return Response({"error": f"user '{username}' not found"}, status=status.HTTP_404_NOT_FOUND)
-        else:
-            return Response(serializer.data, status=status.HTTP_200_OK)
+        serializer = self.serializer_class(queryset[0])
+        return Response(serializer.data, status=status.HTTP_200_OK)
 
 class GetUsersByRole(generics.ListAPIView):
     authentication_classes = [JWTAuthentication]
@@ -175,6 +174,35 @@ class DestroyCourseView(generics.DestroyAPIView):
     queryset = Course.objects.all()
     serializer_class = CourseSerializer
 
+class GetCourseByName(generics.RetrieveAPIView):
+    authentication_classes = [JWTAuthentication]
+    permission_classes = [IsStudent]
+    
+    queryset = Course.objects.all()
+    serializer_class = CourseSerializer
+
+    def get(self, _, pk):
+        queryset = self.get_queryset().filter(pk=pk)
+        if not queryset:
+            return Response({"error": f"course id '{pk}' not found"}, status=status.HTTP_404_NOT_FOUND)
+        serializer = self.serializer_class(queryset[0])
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+class GetCoursesAll(generics.ListAPIView):
+    authentication_classes = [JWTAuthentication]
+    permission_classes = [IsStudent]
+    
+    queryset = Course.objects.all()
+    serializer_class = CourseSerializer
+
+    def get(self, _):
+        queryset = self.get_queryset()
+        serializer = self.serializer_class(queryset, many=True)
+        if len(serializer.data) == 0:
+            return Response({"error": "no courses found"}, status=status.HTTP_404_NOT_FOUND)
+        else:
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
 class EnrollCourseView(generics.GenericAPIView):
     authentication_classes = [JWTAuthentication]
     permission_classes = [IsStudent]
@@ -223,32 +251,68 @@ def post(self, request, *args, **kwargs):
 
         return Response({"ok": f"succesfully enrolled {len(usernames)} students"}, status=status.HTTP_200_OK)
 
-class GetCourseByName(generics.RetrieveAPIView):
+class GetCourseLecturesView(generics.ListAPIView):
     authentication_classes = [JWTAuthentication]
     permission_classes = [IsStudent]
+    lookup_field = 'pk'
 
     queryset = Course.objects.all()
     serializer_class = CourseSerializer
 
-    def get(self, _, pk):
-        queryset = self.get_queryset().filter(pk=pk)
-        serializer = self.serializer_class(queryset, many=True)
+    def get(self, _, *args, **kwargs):
+        course : Course = self.get_object()
+        lectures = course.get_lectures()      
+        serializer = LectureSerializer(lectures, many=True)
         if len(serializer.data) == 0:
-            return Response({"error": f"course id '{pk}' not found"}, status=status.HTTP_404_NOT_FOUND)
+            return Response({"error": "no lectures found"}, status=status.HTTP_404_NOT_FOUND)
         else:
             return Response(serializer.data, status=status.HTTP_200_OK)
 
-class GetCoursesAll(generics.ListAPIView):
+class AddLectureView(generics.GenericAPIView):
     authentication_classes = [JWTAuthentication]
-    permission_classes = [IsStudent]
+    permission_classes = [IsTeacher]
+    lookup_field = 'pk'
 
     queryset = Course.objects.all()
     serializer_class = CourseSerializer
+    
+    def post(self, request, *args, **kwargs):
+        course : Course = self.get_object()
+        result = AddLectureSerializer(data=request.data, context={ "course": course })
+        result.is_valid(raise_exception=True)
+        
+        data = result.data
+        course.add_lecture_to_course(data["start_time"], data["end_time"], data["lecture_type"])
+        
+        return Response({"ok": f"successfully created lecture"}, status=status.HTTP_200_OK)
+    
+class GetLectureView(generics.RetrieveAPIView):
+    authentication_classes = [JWTAuthentication]
+    permission_classes = [IsStudent]
+    
+    queryset = CourseLecture.objects.all()
+    serializer_class = LectureSerializer
 
-    def get(self, _):
-        queryset = self.get_queryset()
-        serializer = self.serializer_class(queryset, many=True)
-        if len(serializer.data) == 0:
-            return Response({"error": "no courses found"}, status=status.HTTP_404_NOT_FOUND)
-        else:
-            return Response(serializer.data, status=status.HTTP_200_OK)
+    def get(self, _, pk):
+        queryset = self.get_queryset().filter(pk=pk)
+        if not queryset:
+            return Response({"error": f"course id '{pk}' not found"}, status=status.HTTP_404_NOT_FOUND)
+        serializer = self.serializer_class(queryset[0])
+        return Response(serializer.data, status=status.HTTP_200_OK)
+    
+class SetStudentAttView(generics.GenericAPIView):
+    authentication_classes = [JWTAuthentication]
+    permission_classes = [IsStudent]
+    lookup_field = 'pk'
+    
+    queryset = CourseLecture.objects.all()
+    serializer_class = CourseLecture
+    
+    def post(self, request, *args, **kwargs):
+        if request.user.role != AccountRoles.STUDENT:
+            return Response({"error": f"only a student can set their attendence to a lecture"}, status=status.HTTP_200_OK)
+            
+        course : CourseLecture = self.get_object()
+        
+        
+        return Response({"ok": f"successfully set attendence"}, status=status.HTTP_200_OK)