Session status tracking

mcserver/admin.py

@@ -54,6 +54,7 @@ class SessionAdmin(admin.ModelAdmin):
         'id', 'user', 'subject',
         'public',
         'created_at', 'updated_at', 'server',
+        'status', 'status_changed',
         'trashed', 'trashed_at',
     )
     raw_id_fields = ('user', 'subject')

mcserver/models.py

@@ -68,6 +68,9 @@ class Session(models.Model):
     public = models.BooleanField(blank=False, null=False, default=False)
     server = models.GenericIPAddressField(null=True, blank=True)
 
+    status = models.CharField(max_length=64, default="init", blank=True, db_index=True)
+    status_changed = models.DateTimeField(null=True, blank=True, default=timezone.now, db_index=True)
+
     subject = models.ForeignKey(
         'Subject', blank=True, null=True,
         related_name='sessions',

mcserver/serializers.py

@@ -190,6 +190,24 @@ class Meta:
         ]
 
 
+class SessionStatusSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Session
+        fields = ['status']
+
+
+class SessionIdSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Session
+        fields = ['id']
+
+
+class SessionFilteringSerializer(serializers.Serializer):
+    status = serializers.CharField(max_length=64, required=True)
+    date_range = serializers.ListField(child=serializers.DateField(), required=False)
+    username = serializers.CharField(max_length=64, required=False)
+
+
 class SubjectSerializer(serializers.ModelSerializer):
     class Meta:
         model = Subject

mcserver/views.py

@@ -1310,7 +1310,75 @@ def neutral_img(self, request, pk):
             raise APIException(_("neutral_image_retrieve_error") % {"uuid": str(pk)})
 
         return Response(data)
-
+
+
+    @action(detail=False, methods=['post'], permission_classes=[IsAdmin | IsBackend | IsOwner])
+    def get_session_statuses(self, request):
+        from .serializers import SessionIdSerializer, SessionFilteringSerializer
+        try:
+            filtering_serializer = SessionFilteringSerializer(data=request.data)
+            serializer = SessionIdSerializer(Session.objects.none(), many=True)
+            if filtering_serializer.is_valid():
+                status_str = filtering_serializer.validated_data.get('status')
+                date_range = filtering_serializer.validated_data.get('date_range')
+                filter_kwargs = {'status': status_str}
+                if date_range:
+                    filter_kwargs['status_changed__gte'] = date_range[0]
+                    filter_kwargs['status_changed__lte'] = date_range[1]
+                if not IsAdmin().has_permission(request, self) and not IsBackend().has_permission(request, self):
+                    filter_kwargs['user'] = request.user
+                else:
+                    if 'username' in filtering_serializer.validated_data:
+                        filter_kwargs['user__username'] = filtering_serializer.validated_data.get('username')
+
+                sessions = Session.objects.filter(**filter_kwargs)
+                serializer = SessionIdSerializer(sessions, many=True)
+        except Http404:
+            if settings.DEBUG:
+                raise Exception(_("error") % {"error_message": str(traceback.format_exc())})
+            raise NotFound(_("session_uuid_not_found") % {"uuid": str(pk)})
+        except ValueError:
+            if settings.DEBUG:
+                raise Exception(_("error") % {"error_message": str(traceback.format_exc())})
+            raise NotFound(_("session_uuid_not_valid") % {"uuid": str(pk)})
+        except Exception:
+            if settings.DEBUG:
+                raise Exception(_("error") % {"error_message": str(traceback.format_exc())})
+            raise APIException(_("session_remove_error"))
+
+        return Response(serializer.data)
+
+
+    @action(detail=True, methods=['post'], permission_classes=[IsAdmin | IsBackend])
+    def set_session_status(self, request, pk):
+        from .serializers import SessionStatusSerializer
+        try:
+            if pk == 'undefined':
+                raise ValueError(_("undefined_uuid"))
+
+            session = get_object_or_404(Session, pk=pk)
+            serializer = SessionStatusSerializer(data=request.data)
+            if serializer.is_valid():
+                session.status = serializer.validated_data['status']
+                session.status_changed = timezone.now()
+                session.save()
+
+        except Http404:
+            if settings.DEBUG:
+                raise Exception(_("error") % {"error_message": str(traceback.format_exc())})
+            raise NotFound(_("session_uuid_not_found") % {"uuid": str(pk)})
+        except ValueError:
+            if settings.DEBUG:
+                raise Exception(_("error") % {"error_message": str(traceback.format_exc())})
+            raise NotFound(_("session_uuid_not_valid") % {"uuid": str(pk)})
+        except Exception:
+            if settings.DEBUG:
+                raise Exception(_("error") % {"error_message": str(traceback.format_exc())})
+            raise APIException(_("session_remove_error"))
+
+        return Response(serializer.data)
+
+
 
 ## Processing machine:
 # A worker asks whether there is any trial to process