endoreg-db 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

endoreg_db/views/raw_video_meta_validation_views.py

@@ -1,38 +1,148 @@
 from rest_framework.views import APIView
 from rest_framework.response import Response
 from rest_framework import status
+from django.http import FileResponse, Http404
+import mimetypes
+import os
 from ..models import RawVideoFile
-from ..serializers.raw_video_meta_validation import VideoFileForMetaSerializer
+from ..serializers.raw_video_meta_validation import VideoFileForMetaSerializer,SensitiveMetaUpdateSerializer
+from ..models import SensitiveMeta
+
 
 class VideoFileForMetaView(APIView):
     """
     API endpoint to fetch video metadata step-by-step.
-    If last_id is not provided  Returns the first video.
-     If last_id is given Returns the next available video.
+    Uses the serializer to get the first or next available video.
     """
 
-    ##need to change this fucntion , like the previous one
-
     def get(self, request):
         """
-        Handles:
-        First video if last_id is nt in query params.
-        Next video where id > last_id` if provided.
+        - Fetches the **first available video** if `last_id` is NOT provided.
+        - Fetches the **next available video** where `id > last_id` if provided.
+        - If no video is available, returns a structured error response.
         """
-        last_id = request.GET.get("last_id")  # Get last_id from query params (e.g., ?last_id=2)
+        last_id = request.GET.get("last_id")  # Get last_id from query params
+
+        #  Get the next video as a model instance
+        video_entry = VideoFileForMetaSerializer.get_next_video(last_id)
+
+        if video_entry is None:
+            return Response({"error": "No more videos available."}, status=status.HTTP_404_NOT_FOUND)
+
+        serialized_video = VideoFileForMetaSerializer(video_entry, context={'request': request})
+
+        # Check if required fields are missing
+        response_data = serialized_video.data
+        missing_fields = {}
+
+        if response_data.get('file') is None:
+            missing_fields['file'] = "No file associated with this entry."
+
+        if response_data.get('video_url') is None:
+            missing_fields['video_url'] = "Video file is missing."
+
+        if response_data.get('full_video_path') is None:
+            missing_fields['full_video_path'] = "No file path found on server."
 
+        if not response_data.get('patient_first_name'):
+            missing_fields['patient_first_name'] = "Patient first name is missing."
+
+        if not response_data.get('patient_last_name'):
+            missing_fields['patient_last_name'] = "Patient last name is missing."
+
+        if not response_data.get('patient_dob'):
+            missing_fields['patient_dob'] = "Patient date of birth is missing."
+
+        if not response_data.get('examination_date'):
+            missing_fields['examination_date'] = "Examination date is missing."
+
+        if response_data.get('duration') is None:
+            missing_fields['duration'] = "Unable to determine video duration. The file might be corrupted or unreadable."
+
+        if missing_fields:
+            return Response({"error": "Missing required data.", "details": missing_fields}, 
+                            status=status.HTTP_400_BAD_REQUEST)
+
+        return Response(serialized_video.data, status=status.HTTP_200_OK)
+
+    def serve_video_file(self, video_entry):
+        """
+        Streams the video file dynamically.
+        """
         try:
-            # If last_id is provided, fetch the next video where id > last_id
-            # id__gt is orm syntax which is equal to SELECT * FROM rawvideofile WHERE id > 2 ORDER BY id ASC LIMIT 1;
+            full_video_path = video_entry.file.path  #  Get file path
 
-            query_filter = {} if last_id is None else {"id__gt": int(last_id)}
-            video_entry = RawVideoFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+            if not os.path.exists(full_video_path):
+                raise Http404("Video file not found.")
 
-            if not video_entry:
-                return Response({"message": "No more videos available."}, status=status.HTTP_404_NOT_FOUND)
+            mime_type, _ = mimetypes.guess_type(full_video_path)  # Detects file type
+            response = FileResponse(open(full_video_path, "rb"), content_type=mime_type or "video/mp4")
 
-            serializer = VideoFileForMetaSerializer(video_entry)
-            return Response(serializer.data, status=status.HTTP_200_OK)
+            response["Content-Disposition"] = f'inline; filename="{os.path.basename(full_video_path)}"'  # Allows direct streaming
+
+            return response  # Sends the video file as a stream
 
         except Exception as e:
-            return Response({"error": f"Internal server error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return Response({"error": f"Internal error: {str(e)}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        
+
+    def patch(self, request, *args, **kwargs):
+        """
+        Calls the serializer to update `SensitiveMeta` data.
+        """
+
+        # Ensure all required fields are provided
+        required_fields = ["sensitive_meta_id", "patient_first_name", "patient_last_name", "patient_dob", "examination_date"]
+        missing_fields = [field for field in required_fields if field not in request.data]
+
+        if missing_fields:
+            return Response({"error": "Missing required fields", "missing_fields": missing_fields}, status=status.HTTP_400_BAD_REQUEST)
+
+        #  Call serializer for validation
+        serializer = SensitiveMetaUpdateSerializer(data=request.data, partial=True)
+
+        if serializer.is_valid():
+            #  Get the instance and update it
+            sensitive_meta = SensitiveMeta.objects.get(id=request.data["sensitive_meta_id"])
+            updated_instance = serializer.update(sensitive_meta, serializer.validated_data)
+
+            return Response({
+                "message": "Patient information updated successfully.",
+                "updated_data": SensitiveMetaUpdateSerializer(updated_instance).data
+            }, status=status.HTTP_200_OK)
+
+        #  Return validation errors
+        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+    
+
+    """
+    await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+const updatePatientInfo = async () => {
+    const updatedData = {
+        sensitive_meta_id: 2,
+        patient_first_name: "Placeholder",
+        patient_last_name: "Placeholder",
+        patient_dob: "1994-06-15",
+        examination_date: "2024-06-15"
+    };
+
+    try {
+        const response = await axios.patch("http://localhost:8000/api/video/update_sensitivemeta/", updatedData, {
+            headers: { "Content-Type": "application/json" }
+        });
+
+        console.log("Update Success:", response.data);
+        alert("Patient information updated successfully!");
+
+        return response.data;  
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+        alert("Failed to update patient information.");
+        return error.response?.data || { error: "Unknown error" };  
+    }
+};
+
+
+updatePatientInfo().then(response => console.log("Final Response:", response));
+
+    """

endoreg_db/views/video_segmentation_views.py

@@ -31,9 +31,14 @@ class VideoView(APIView):
         Returns a list of all available videos along with available labels.
         Used to populate the video selection dropdown in Vue.js.
         """
+        
         videos = RawVideoFile.objects.all()
         labels = Label.objects.all()  # Fetch all labels
 
+        if not videos.exists():
+            return Response({"error": "No videos found in the database."}, status=status.HTTP_404_NOT_FOUND)
+
+
         video_serializer = VideoListSerializer(videos, many=True)
         label_serializer = LabelSerializer(labels, many=True)  # Serialize labels
 
@@ -134,16 +139,28 @@ class UpdateLabelSegmentsView(APIView):
 
     def put(self, request, video_id, label_id):
         """
-        Handles PUT request to update or create label segments.
+        Updates segments for a given video & label.
         """
-        serializer = LabelSegmentUpdateSerializer(data=request.data)
 
-        if serializer.is_valid():
-            result = serializer.save()
-            return Response({
-                "message": "Segments updated successfully",
-                "updated_segments": result["updated_segments"],
-                "new_segments": result["new_segments"]
-            }, status=status.HTTP_200_OK)
-        
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        # Ensure required fields are provided
+        required_fields = ["video_id", "label_id", "segments"]
+        missing_fields = [field for field in required_fields if field not in request.data]
+
+        if missing_fields:
+            return Response({"error": "Missing required fields", "missing": missing_fields}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Validate input data
+        serializer = LabelSegmentUpdateSerializer(data=request.data, partial=True)
+
+        if not serializer.is_valid():
+            return Response({"error": "Invalid segment data", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Process and save segment updates
+        result = serializer.save()
+
+        return Response({
+            "message": "Segments updated successfully.",
+            "updated_segments": result["updated_segments"],
+            "new_segments": result["new_segments"],
+            "deleted_segments": result["deleted_segments"]
+        }, status=status.HTTP_200_OK)

endoreg_db/views/views.py

@@ -0,0 +1,107 @@
+#for keycloak need to make separate onne,demo
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.views import APIView
+from rest_framework.response import Response
+
+from django.shortcuts import redirect, render
+from django.conf import settings
+from urllib.parse import urlencode
+import requests
+
+"""
+    User hits /api/videos/
+    Middleware checks for token; if missing, redirects to /login/
+    /login/ redirects to Keycloak
+    User logs in → Keycloak sends them back to /login/callback/
+    /login/callback/ exchanges code for token, stores it in session
+    User is redirected to /api/videos/ again
+    Middleware now sees token, verifies it, injects user
+    DRF view (VideoView) is allowed to execute and returns data
+"""
+class VideoView(APIView):
+    permission_classes = [IsAuthenticated] #This uses DRF permissions to ensure request.user.is_authenticated == True.
+
+    def get(self, request):
+        """
+        We already inject a mock user in the middleware, so this will pass if the middleware succeeded.
+        Returns a message including the Keycloak username.
+        """
+        username = getattr(request.user, 'preferred_username', 'Unknown')
+        return Response({"message": f"🎥 Hello, {username}. You are viewing protected videos!"})
+
+
+def keycloak_login(request):
+
+    """
+    - This gets triggered when middleware redirects to /login/.
+    """
+    redirect_uri = request.build_absolute_uri('/login/callback/')
+    print("Redirect URI:", redirect_uri)
+    auth_url = f"{settings.KEYCLOAK_SERVER_URL}/realms/{settings.KEYCLOAK_REALM}/protocol/openid-connect/auth"
+
+    #OAuth2 Authorization Code Flow
+    params = {
+        "client_id": settings.KEYCLOAK_CLIENT_ID,
+        "response_type": "code",
+        "scope": "openid",
+        "redirect_uri": redirect_uri,
+    }
+    # Redirect user to Keycloak login page.
+    return redirect(f"{auth_url}?{urlencode(params)}")
+
+
+import json
+from django.http import HttpResponse
+
+from django.http import HttpResponse, HttpResponseRedirect
+import json
+
+def keycloak_callback(request):
+
+    #User lands here after login (Keycloak redirects here with code).
+    code = request.GET.get("code")
+    if not code:
+        return HttpResponse(" No authorization code provided.", status=400)
+
+    # Exchanges the code for an access_token.
+    token_url = f"{settings.KEYCLOAK_SERVER_URL}/realms/{settings.KEYCLOAK_REALM}/protocol/openid-connect/token"
+    redirect_uri = request.build_absolute_uri('/login/callback/')
+
+    data = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "client_id": settings.KEYCLOAK_CLIENT_ID,
+        "client_secret": settings.KEYCLOAK_CLIENT_SECRET,
+        "redirect_uri": redirect_uri,
+    }
+
+    try:
+        response = requests.post(token_url, data=data)
+
+        print("Token Response Status:", response.status_code)
+        print(" Token Response Body:", response.text)
+
+        if response.status_code != 200:
+            return HttpResponse(
+                f"<h2> Token exchange failed</h2><pre>{response.text}</pre>",
+                status=500
+            )
+
+        token_data = response.json()
+
+        if "access_token" not in token_data:
+            return HttpResponse(" Access token missing in response.", status=500)
+
+        #  Stores the token in Django session. Middleware will use this on the next request.
+        request.session["access_token"] = token_data["access_token"]
+        request.session["refresh_token"] = token_data["refresh_token"]
+        print("Refresh Token:", request.session.get("refresh_token"))
+
+        return redirect("/api/videos/")
+
+    except Exception as e:
+        return HttpResponse(f" Exception during token exchange: {str(e)}", status=500)
+
+
+def public_home(request):
+    return HttpResponse("just for demo - This is a public home page — no login required.")

{endoreg_db-0.6.2.dist-info → endoreg_db-0.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.6.2
+Version: 0.6.4
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db