Merge branch 'db_and_monitoring' into 'QA_RELEASE'

Db and monitoring

See merge request !41

MonitorLecturerApp/api.py

@@ -28,12 +28,13 @@ class LecturerVideoAPI(APIView):
     def post(self, request):
 
         serializer = LectureRecordedVideoSerializer(data=request.data)
+        data = {}
 
         if serializer.is_valid(raise_exception=ValueError):
             # serializer.create(validated_data=request.data)
-            serializer.create(validated_data=request.data)
+            data = serializer.create(validated_data=request.data)
 
-        return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(data, status=status.HTTP_201_CREATED)
 
 
 ##### END OF LECTURER VIDEO SECTION #####
@@ -59,7 +60,10 @@ class ActivityRecognitionAPI(APIView):
             walking_count=percentages["walking_perct"]
         ).save()
 
-        return Response({"response": percentages})
+        return Response({
+            "response": percentages,
+            "created": True
+        })
 
     def post(self, request):
         pass
@@ -103,7 +107,8 @@ class ProcessLecturerFrameRecognitionsAPI(APIView):
 
         return Response({
             "frame_recognitions": frame_recognitions,
-            "fps": fps
+            "fps": fps,
+            "created": True
         })
 
 
@@ -247,7 +252,8 @@ class ProcessLectureAudioAnalysis(APIView):
 
 
         return Response({
-            "response": "success"
+            "response": "success",
+            "created": True
         }, status=status.HTTP_201_CREATED)
 
 

MonitorLecturerApp/logic/lecturer_batch_process.py

 import requests
+import json
 
 # this method lists down the main methods that need to be executed when the lecturer performance module is under operation
 def lecturer_batch_process(video_name, audio_name):
 
+    is_all_processed = False
+
     # As the first step, calculate the lectuer activity details
-    lecturer_activity_resp = requests.get('http://127.0.0.1:8000/activities/?video_name=' + video_name)
+    # lecturer_activity_resp = requests.get('http://127.0.0.1:8000/activities/?video_name=' + video_name)
+    lecturer_activity_resp = requests.get('http://127.0.0.1:8000/activities/', params={'video_name': video_name})
+
+    # if the lecturer activity is created
+    if lecturer_activity_resp.json()['created']:
 
         # save the lecturer video frame recognitions
-    lecturer_video_frame_recognitions_resp = requests.get('http://127.0.0.1:8000/process-lecturer-video-frame-recognitions/?video_name=' + video_name)
+        # lecturer_video_frame_recognitions_resp = requests.get('http://127.0.0.1:8000/process-lecturer-video-frame-recognitions/?video_name=' + video_name)
+        lecturer_video_frame_recognitions_resp = requests.get('http://127.0.0.1:8000/process-lecturer-video-frame-recognitions/', params={'video_name': video_name})
+
+        # if the lecture video frame recognitions are created
+        if lecturer_video_frame_recognitions_resp.json()['created']:
 
             # processing the lecture audio
             lecture_audio_text_resp = requests.get('http://127.0.0.1:8000/lecturer/process-lecture-audio-analysis')
 
+            # if the lecturer audio text is processed
+            if lecture_audio_text_resp.json()['created']:
+                is_all_processed = True
+
+
+    return is_all_processed
 
 # this method will save the lecturer video details
 def save_lecturer_video_details(video):
 
-    lecturer_video_resp = requests.post('http://127.0.0.1:8000/lecturer-video', video)
\ No newline at end of file
+
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    # convert the data into JSON string
+    video_json_str = json.dumps(video)
+
+    lecturer_video_resp = requests.post(url='http://127.0.0.1:8000/lecturer/lecturer-video/', data=video_json_str, headers=headers)
+
+    response = lecturer_video_resp.json()
+
+    return response[0]
+
+
+# if __name__ == '__main__':
+#
+#     video = {
+#         "lecturer": 1,
+#         "subject": 16,
+#         "lecturer_date": "2020-12-09",
+#         "lecture_video_name": "Video_test_19.mp4",
+#         "lecture_video_length": "00:45:06"
+#     }
+#
+#     response = save_lecturer_video_details(video)
+#
+#     print('response: ', response)
\ No newline at end of file

MonitorLecturerApp/serializers.py

@@ -7,10 +7,9 @@ from .models import RegisterTeacher, LecturerActivityFrameRecognitions
 from .models import LecturerAudioText, LecturerVideoMetaData, LecturerVideo, LectureRecordedVideo
 from FirstApp.logic import id_generator as ig
 
-
-
 import datetime
 
+
 class RegisterTeacherSerializer(serializers.ModelSerializer):
     class Meta:
         model = RegisterTeacher
@@ -39,6 +38,46 @@ class LectureRecordedVideoSerializer(serializers.ModelSerializer):
         model = LectureRecordedVideo
         fields = '__all__'
 
+    # this method will validate the input data
+    def to_internal_value(self, data):
+        lecturer = None
+        subject = None
+
+        lecturer_data = data.get('lecturer')
+        subject_data = data.get('subject')
+
+        # serialize the lecturer data
+        lecturer = Lecturer.objects.filter(id=lecturer_data)
+        subject = Subject.objects.filter(id=subject_data)
+
+        lecturer_ser_data = LecturerSerializer(lecturer, many=True).data[0]
+        subject_ser_data = SubjectSerializer(subject, many=True).data[0]
+
+        # retrieve the last lecture video details
+        last_lec_video = LectureRecordedVideo.objects.order_by('lecture_video_id').last()
+        # create the next lecture video id
+        new_lecture_video_id = ig.generate_new_id(last_lec_video.lecture_video_id)
+
+        # if both subject and lecturer details are available
+        if len(lecturer) == 1 & len(subject) == 1:
+            str_video_length = data.get('lecture_video_length')
+            video_length_parts = str_video_length.split(':')
+            video_length = datetime.timedelta(minutes=int(video_length_parts[0]),
+                                              seconds=int(video_length_parts[1]),
+                                              milliseconds=int(video_length_parts[2]))
+
+        # this data will be passed as validated data
+        validated_data = {
+            'lecture_video_id': new_lecture_video_id,
+            'lecturer': lecturer_ser_data,
+            'subject': subject_ser_data,
+            'lecturer_date': data.get('lecturer_date'),
+            'lecture_video_name': data.get('lecture_video_name'),
+            'lecture_video_length': video_length
+        }
+
+        return super(LectureRecordedVideoSerializer, self).to_internal_value(validated_data)
+
     # this method will override the 'create' method
     def create(self, validated_data):
         lecturer = None
@@ -73,8 +112,12 @@ class LectureRecordedVideoSerializer(serializers.ModelSerializer):
                 lecture_video_length=video_length
             )
 
+            # retrieve the created object
+            created_lecture_video = LectureRecordedVideo.objects.filter(lecture_video_id=lecture_video)
+            create_lecture_video_ser = LectureRecordedVideoSerializer(created_lecture_video, many=True)
+            create_lecture_video_ser_data = create_lecture_video_ser.data
 
-            return lecture_video
+            return create_lecture_video_ser_data
 
         return None