endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/media/sensitive_metadata.py

@@ -0,0 +1,372 @@
+# Modern Media Framework: Sensitive Metadata Management
+
+from django.db import transaction
+from django.db.models import Q
+from django.shortcuts import get_object_or_404
+import json
+import logging
+
+from numpy import number
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+
+from endoreg_db.models import RawPdfFile, SensitiveMeta, VideoFile
+from endoreg_db.serializers.meta import (
+    SensitiveMetaDetailSerializer,
+    SensitiveMetaUpdateSerializer,
+)
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+logger = logging.getLogger(__name__)    
+# === VIDEO SENSITIVE METADATA ===
+
+
+@api_view(["GET"])
+@permission_classes([EnvironmentAwarePermission])
+def get_sensitive_metadata_pk(request, pk: number, mediaType: str) -> Response | None:
+    """
+    A route to get the sensitive meta pk for a media type quickly.
+
+    GET api/media/sensitive-media-id/<pk>/<str:mediaType>
+
+    Args:
+        request (_type_): _description_
+        id (_type_): _description_
+
+    Returns:
+        Response | None: _description_
+    """
+
+    if mediaType == "video":
+        video = get_object_or_404(VideoFile, pk=pk)
+        if not video.sensitive_meta:
+            return Response(
+                {"error": f"No sensitive metadata found for video {pk}"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        sm_id = video.sensitive_meta.pk
+        return Response({"sm": sm_id})
+    if mediaType == "pdf":
+        pdf = get_object_or_404(RawPdfFile, pk=pk)
+        if not pdf.sensitive_meta:
+            return Response(
+                {"error": f"No sensitive metadata found for report {pk}"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        sm_id = pdf.sensitive_meta.pk
+        return Response({"sm": sm_id})
+
+
+@api_view(["GET", "PATCH"])
+@permission_classes([EnvironmentAwarePermission])
+def video_sensitive_metadata(request, pk):
+    """
+    GET /api/media/videos/<pk>/sensitive-metadata/
+    PATCH /api/media/videos/<pk>/sensitive-metadata/
+
+    Get or update sensitive metadata for a video.
+    Video-scoped: Uses sensitive meta ID to locate related sensitive metadata.
+    """
+    sensitive_meta = get_object_or_404(SensitiveMeta, pk=pk)
+
+    # Get related sensitive metadata
+    if not sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for video {pk}"},
+            status=status.HTTP_404_NOT_FOUND,
+        )
+
+    if request.method == "GET":
+        serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    elif request.method == "PATCH":
+        serializer = SensitiveMetaUpdateSerializer(
+            sensitive_meta, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            updated_instance = serializer.save()
+            response_serializer = SensitiveMetaDetailSerializer(updated_instance)
+
+            return Response(
+                {
+                    "message": "Sensitive metadata updated successfully",
+                    "sensitive_meta": response_serializer.data,
+                    "video_id": pk,
+                },
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(["POST"])
+@permission_classes([EnvironmentAwarePermission])
+@transaction.atomic
+def video_sensitive_metadata_verify(request, pk):
+    """
+    POST /api/media/videos/<pk>/sensitive-metadata/verify/
+
+    Update verification state for video sensitive metadata.
+
+    Expected payload:
+    {
+        "dob_verified": true,
+        "names_verified": true
+    }
+    """
+    video = get_object_or_404(VideoFile, pk=pk)
+
+    if not video.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for video {pk}"},
+            status=status.HTTP_404_NOT_FOUND,
+        )
+
+    sensitive_meta = video.sensitive_meta
+
+    dob_verified = request.data.get("dob_verified")
+    names_verified = request.data.get("names_verified")
+
+    if dob_verified is None and names_verified is None:
+        return Response(
+            {
+                "error": "At least one of dob_verified or names_verified must be provided"
+            },
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    state = sensitive_meta.get_or_create_state()
+
+    if dob_verified is not None:
+        state.dob_verified = dob_verified
+    if names_verified is not None:
+        state.names_verified = names_verified
+
+    state.save()
+
+    response_serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+    return Response(
+        {
+            "message": "Verification state updated successfully",
+            "sensitive_meta": response_serializer.data,
+            "video_id": pk,
+            "state_verified": state.is_verified,
+        },
+        status=status.HTTP_200_OK,
+    )
+
+
+# === report SENSITIVE METADATA ===
+
+
+@api_view(["GET", "PATCH"])
+@permission_classes([EnvironmentAwarePermission])
+def pdf_sensitive_metadata(request, pk):
+    """
+    GET /api/media/pdfs/<pk>/sensitive-metadata/
+    PATCH /api/media/pdfs/<pk>/sensitive-metadata/
+
+    Get or update sensitive metadata for a report.
+    report-scoped: Uses report ID to locate related sensitive metadata.
+    """
+    sensitive_meta = get_object_or_404(SensitiveMeta, pk=pk)
+
+    # Get related sensitive metadata
+    if not sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for report {pk}"},
+            status=status.HTTP_404_NOT_FOUND,
+        )
+
+    if request.method == "GET":
+        serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    elif request.method == "PATCH":
+        serializer = SensitiveMetaUpdateSerializer(
+            sensitive_meta, data=request.data, partial=True
+        )
+
+        if serializer.is_valid():
+            updated_instance = serializer.save()
+            response_serializer = SensitiveMetaDetailSerializer(updated_instance)
+            sensitive_meta.update_from_dict(response_serializer.data)
+            logger.info("Updated sensitive metadata: %s", json.dumps(response_serializer.data))
+            return Response(
+                {
+                    "message": "Sensitive metadata updated successfully",
+                    "sensitive_meta": response_serializer.data,
+                    "pdf_id": pk,
+                },
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(["POST"])
+@permission_classes([EnvironmentAwarePermission])
+@transaction.atomic
+def pdf_sensitive_metadata_verify(request, pk):
+    """
+    POST /api/media/pdfs/<pk>/sensitive-metadata/verify/
+
+    Update verification state for report sensitive metadata.
+
+    Expected payload:
+    {
+        "dob_verified": true,
+        "names_verified": true
+    }
+    """
+    pdf = get_object_or_404(RawPdfFile, pk=pk)
+
+    if not pdf.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for report {pk}"},
+            status=status.HTTP_404_NOT_FOUND,
+        )
+
+    sensitive_meta = pdf.sensitive_meta
+
+    dob_verified = request.data.get("dob_verified")
+    names_verified = request.data.get("names_verified")
+
+    if dob_verified is None and names_verified is None:
+        return Response(
+            {
+                "error": "At least one of dob_verified or names_verified must be provided"
+            },
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    state = sensitive_meta.get_or_create_state()
+
+    if dob_verified is not None:
+        state.dob_verified = dob_verified
+    if names_verified is not None:
+        state.names_verified = names_verified
+
+    state.save()
+
+    response_serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+    return Response(
+        {
+            "message": "Verification state updated successfully",
+            "sensitive_meta": response_serializer.data,
+            "pdf_id": pk,
+            "state_verified": state.is_verified,
+        },
+        status=status.HTTP_200_OK,
+    )
+
+
+# === LIST ENDPOINTS (Collection-Level) ===
+
+
+@api_view(["GET"])
+@permission_classes([EnvironmentAwarePermission])
+def sensitive_metadata_list(request):
+    """
+    GET /api/media/sensitive-metadata/
+
+    List all sensitive metadata (combined reports and Videos).
+    Supports filtering by content_type, status, etc.
+
+    Query parameters:
+    - content_type: 'pdf' | 'video' (optional)
+    - verified: Filter by verification status
+    - ordering: Sort field
+    - search: Search in patient names
+    """
+    from endoreg_db.serializers.meta import SensitiveMetaDetailSerializer
+
+    # Get all sensitive metadata
+    queryset = SensitiveMeta.objects.select_related("state").all()
+
+    # Filter by content type
+    content_type = request.query_params.get("content_type")
+    if content_type == "pdf":
+        # Only reports - filter by existence of related reports
+        queryset = queryset.filter(raw_pdf_files__isnull=False).distinct()
+    elif content_type == "video":
+        # Only Videos - filter by existence of related video
+        queryset = queryset.filter(video_file__isnull=False).distinct()
+
+    # Filter by verification status
+    verified = request.query_params.get("verified")
+    if verified is not None:
+        verified_bool = verified.lower() in ("true", "1", "yes")
+        queryset = queryset.filter(state__is_verified=verified_bool)
+
+    # Search in patient names
+    search = request.query_params.get("search")
+    if search:
+        queryset = queryset.filter(
+            Q(patient_first_name__icontains=search)
+            | Q(patient_last_name__icontains=search)
+        )
+
+    # Ordering
+    ordering = request.query_params.get("ordering", "-id")
+    queryset = queryset.order_by(ordering)
+
+    # Pagination
+    from rest_framework.pagination import PageNumberPagination
+
+    paginator = PageNumberPagination()
+    paginator.page_size = 20
+    page = paginator.paginate_queryset(queryset, request)
+
+    if page is not None:
+        serializer = SensitiveMetaDetailSerializer(page, many=True)
+        return paginator.get_paginated_response(serializer.data)
+
+    serializer = SensitiveMetaDetailSerializer(queryset, many=True)
+    return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+@api_view(["GET"])
+@permission_classes([EnvironmentAwarePermission])
+def pdf_sensitive_metadata_list(request):
+    """
+    GET /api/media/pdfs/sensitive-metadata/
+
+    List sensitive metadata for reports only.
+    Replaces legacy /api/pdf/sensitivemeta/list/
+    """
+    from endoreg_db.serializers.meta import SensitiveMetaDetailSerializer
+
+    # Get all reports with sensitive metadata
+    queryset = (
+        SensitiveMeta.objects.select_related("state")
+        .filter(raw_pdf_files__isnull=False)
+        .distinct()
+    )
+
+    # Apply filters
+    search = request.query_params.get("search")
+    if search:
+        queryset = queryset.filter(
+            Q(patient_first_name__icontains=search)
+            | Q(patient_last_name__icontains=search)
+        )
+
+    ordering = request.query_params.get("ordering", "-id")
+    queryset = queryset.order_by(ordering)
+
+    # Pagination
+    from rest_framework.pagination import PageNumberPagination
+
+    paginator = PageNumberPagination()
+    paginator.page_size = 20
+    page = paginator.paginate_queryset(queryset, request)
+
+    if page is not None:
+        serializer = SensitiveMetaDetailSerializer(page, many=True)
+        return paginator.get_paginated_response(serializer.data)
+
+    serializer = SensitiveMetaDetailSerializer(queryset, many=True)
+    return Response(serializer.data, status=status.HTTP_200_OK)

endoreg_db/views/media/video_media.py

@@ -0,0 +1,275 @@
+"""
+Video Media Management View (Phase 1.2)
+
+Provides CRUD operations for video files including listing, detail retrieval,
+and metadata management for the media management system.
+
+This complements VideoStreamView which handles the actual video streaming.
+"""
+
+import logging
+
+from django.db.models import Q
+from django.http import Http404
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from endoreg_db.models import VideoFile
+from endoreg_db.serializers.video.video_file_detail import VideoDetailSerializer
+from endoreg_db.serializers.video.video_file_list import VideoFileListSerializer
+
+from endoreg_db.authz.permissions import PolicyPermission
+
+logger = logging.getLogger(__name__)
+
+
+class VideoMediaView(APIView):
+    """
+    Video Media Management API for CRUD operations on video files.
+
+    Endpoints:
+    - GET /api/media/videos/ - List all videos with filtering
+    - GET /api/media/videos/{id}/ - Get video details
+    - PATCH /api/media/videos/{id}/ - Update video metadata (future)
+    - DELETE /api/media/videos/{id}/ - Delete video
+
+    Query Parameters:
+    - status: Filter by processing status (not_started, processing, done, failed, validated)
+    - search: Search in filename
+    - limit: Limit results (default: 50)
+    - offset: Pagination offset
+
+    Examples:
+    - GET /api/media/videos/?status=done&search=exam
+    - GET /api/media/videos/123/
+
+    Phase 1.2 Implementation:
+    - List and detail views implemented
+    - Filtering and search functionality
+    - Pagination support
+    - Error handling with proper HTTP status codes
+    - Integration with existing serializers
+    """
+
+    permission_classes = [IsAuthenticated, PolicyPermission]
+    def get(self, request, pk=None):
+        """
+        Handle GET requests for video listing or detail retrieval.
+
+        Args:
+            request: HTTP request object
+            pk: Optional video ID for detail view
+
+        Returns:
+            Response: JSON response with video data or list
+
+        Raises:
+            Http404: If specific video not found
+        """
+        if pk is not None:
+            # Detail view
+            return self._get_video_detail(pk)
+        else:
+            # List view
+            return self._list_videos(request)
+
+    def _get_video_detail(self, pk):
+        """
+        Get detailed information for a specific video.
+
+        Args:
+            pk: Video primary key
+
+        Returns:
+            Response: JSON response with video details
+
+        Raises:
+            Http404: If video not found
+        """
+        try:
+            # Validate video_id is numeric
+            try:
+                video_id_int = int(pk)
+            except (ValueError, TypeError):
+                raise Http404("Invalid video ID format")
+
+            # Fetch video with related data
+            video = VideoFile.objects.select_related("state", "sensitive_meta").get(
+                pk=video_id_int
+            )
+
+            # Serialize with request context for URL generation
+            serializer = VideoDetailSerializer(video, context={"request": self.request})
+
+            return Response(serializer.data)
+
+        except VideoFile.DoesNotExist:
+            raise Http404(f"Video with ID {pk} not found")
+
+        except Exception as e:
+            logger.error(f"Unexpected error in video detail view for ID {pk}: {str(e)}")
+            return Response(
+                {"error": "Failed to retrieve video details"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    def _list_videos(self, request):
+        """
+        List videos with filtering, search, and pagination.
+
+        Args:
+            request: HTTP request with query parameters
+
+        Returns:
+            Response: JSON response with paginated video list
+        """
+        try:
+            # Start with all videos
+            queryset = VideoFile.objects.select_related("state", "sensitive_meta").all()
+
+            # Apply filters
+            queryset = self._apply_filters(queryset, request.query_params)
+
+            # Apply search
+            search = request.query_params.get("search", "").strip()
+            if search:
+                queryset = queryset.filter(Q(original_file_name__icontains=search))
+
+            # Order by upload date (newest first)
+            queryset = queryset.order_by("-uploaded_at")
+
+            # Apply pagination
+            limit = min(int(request.query_params.get("limit", 50)), 100)
+            offset = int(request.query_params.get("offset", 0))
+
+            total_count = queryset.count()
+            videos = queryset[offset : offset + limit]
+
+            # Serialize
+            serializer = VideoFileListSerializer(videos, many=True)
+
+            return Response(
+                {
+                    "count": total_count,
+                    "next": self._get_next_url(request, offset, limit, total_count),
+                    "previous": self._get_previous_url(request, offset, limit),
+                    "results": serializer.data,
+                }
+            )
+
+        except ValueError as e:
+            return Response(
+                {"error": f"Invalid query parameter: {str(e)}"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        except Exception as e:
+            logger.error(f"Unexpected error in video list view: {str(e)}")
+            return Response(
+                {"error": "Failed to retrieve video list"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    def _apply_filters(self, queryset, query_params):
+        """
+        Apply status and other filters to video queryset.
+
+        Args:
+            queryset: Base queryset to filter
+            query_params: Request query parameters
+
+        Returns:
+            QuerySet: Filtered queryset
+        """
+        status_filter = query_params.get("status", "").strip().lower()
+
+        if status_filter:
+            if status_filter == "not_started":
+                # Videos without state or with not_started status
+                queryset = queryset.filter(
+                    Q(state__isnull=True)
+                    | Q(
+                        state__frames_extracted=False,
+                        state__sensitive_meta_processed=False,
+                    )
+                )
+            elif status_filter == "processing":
+                # Videos in any processing state
+                queryset = queryset.filter(
+                    state__frames_extracted=True, state__sensitive_meta_processed=False
+                )
+            elif status_filter == "done_processing_anonymization":
+                # Videos with anonymization complete but not validated
+                queryset = queryset.filter(
+                    state__anonymized=True, sensitive_meta__is_verified=False
+                )
+            elif status_filter == "validated":
+                # Videos with human validation complete
+                queryset = queryset.filter(
+                    state__anonymized=True, sensitive_meta__is_verified=True
+                )
+            elif status_filter == "failed":
+                # Failed videos (this might need adjustment based on actual failure tracking)
+                queryset = queryset.filter(
+                    state__isnull=False,
+                    state__frames_extracted=False,
+                    state__sensitive_meta_processed=False,
+                )
+
+        return queryset
+
+    def _get_next_url(self, request, offset, limit, total_count):
+        """Generate next page URL for pagination."""
+        if offset + limit >= total_count:
+            return None
+
+        next_offset = offset + limit
+        return self._build_paginated_url(request, next_offset, limit)
+
+    def _get_previous_url(self, request, offset, limit):
+        """Generate previous page URL for pagination."""
+        if offset <= 0:
+            return None
+
+        prev_offset = max(0, offset - limit)
+        return self._build_paginated_url(request, prev_offset, limit)
+
+    def _build_paginated_url(self, request, offset, limit):
+        """Build URL with pagination parameters."""
+        params = request.query_params.copy()
+        params["offset"] = offset
+        params["limit"] = limit
+
+        base_url = request.build_absolute_uri(request.path)
+        if params:
+            return f"{base_url}?{params.urlencode()}"
+        return base_url
+
+    # Future implementation placeholders
+    def patch(self, request, pk):
+        """
+        Update video metadata (Phase 1.2+ future enhancement).
+
+        Currently returns 501 Not Implemented.
+        """
+        return Response(
+            {"error": "Video metadata updates not yet implemented"},
+            status=status.HTTP_501_NOT_IMPLEMENTED,
+        )
+
+    def delete(self, request, pk):
+        """
+        Delete video file (Phase 1.2+ future enhancement).
+
+        Currently returns 501 Not Implemented.
+        Use /api/media-management/force-remove/{id}/ instead.
+        """
+        return Response(
+            {
+                "error": "Video deletion not yet implemented",
+                "alternative": f"Use DELETE /api/media-management/force-remove/{pk}/ instead",
+            },
+            status=status.HTTP_501_NOT_IMPLEMENTED,
+        )

endoreg_db/views/meta/__init__.py

@@ -0,0 +1,7 @@
+from .sensitive_meta_list import SensitiveMetaListView
+from .sensitive_meta_verification import SensitiveMetaVerificationView
+
+__all__ = [
+    "SensitiveMetaListView",
+    "SensitiveMetaVerificationView",
+]