endoreg-db 0.8.1__py3-none-any.whl → 0.8.2.1__py3-none-any.whl

endoreg_db/views/anonymization/validate.py

@@ -1,11 +1,18 @@
+import logging
+from typing import Any, Dict, cast
+
+from django.db import transaction
 from rest_framework import status
 from rest_framework.response import Response
 from rest_framework.views import APIView
-from django.db import transaction
-from endoreg_db.models import VideoFile, RawPdfFile
+
+from endoreg_db.models import RawPdfFile, VideoFile
 from endoreg_db.serializers.anonymization import SensitiveMetaValidateSerializer
 
 
+logger = logging.getLogger(__name__)
+
+
 class AnonymizationValidateView(APIView):
     """
     POST /api/anonymization/<int:file_id>/validate/
@@ -21,6 +28,7 @@ class AnonymizationValidateView(APIView):
       "casenumber":         "12345",
       "anonymized_text":    "...",             // nur für PDFs; Videos ignorieren
       "is_verified":        true               // optional; default true
+      "file_type":        "video"            // optional; "video" oder "pdf"; wenn nicht angegeben, wird zuerst Video, dann PDF versucht
     }
     
     Rückwärtskompatibilität: ISO-Format (YYYY-MM-DD) wird ebenfalls akzeptiert.
@@ -31,33 +39,69 @@ class AnonymizationValidateView(APIView):
         # Serializer-Validierung mit deutscher Datums-Priorität
         serializer = SensitiveMetaValidateSerializer(data=request.data or {})
         serializer.is_valid(raise_exception=True)
-        payload = serializer.validated_data
-        payload.setdefault("is_verified", True)
-
-        # Try Video first
-        video = VideoFile.objects.filter(pk=file_id).first()
-        if video:
-            # Ensure center_name is in payload for hash calculation
-            if video.center and not payload.get("center_name"):
-                payload["center_name"] = video.center.name
-                
-            ok = video.validate_metadata_annotation(payload)
-            #if ok:
-            #    video._cleanup_raw_assets()
-            if not ok:
-                return Response({"error": "Video validation failed."}, status=status.HTTP_400_BAD_REQUEST)
-            return Response({"message": "Video validated."}, status=status.HTTP_200_OK)
-
-        # Then PDF
-        pdf = RawPdfFile.objects.filter(pk=file_id).first()
-        if pdf:
-            # Ensure center_name is in payload for hash calculation
-            if pdf.center and not payload.get("center_name"):
-                payload["center_name"] = pdf.center.name
-                
-            ok = pdf.validate_metadata_annotation(payload)
-            if not ok:
-                return Response({"error": "PDF validation failed."}, status=status.HTTP_400_BAD_REQUEST)
-            return Response({"message": "PDF validated."}, status=status.HTTP_200_OK)
-
-        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)
+        validated_data = cast(Dict[str, Any], serializer.validated_data)
+        payload: Dict[str, Any] = dict(validated_data)
+        if "is_verified" not in payload:
+            payload["is_verified"] = True
+
+        file_type = payload.get("file_type")
+
+        # Try Video first (unless explicitly requesting PDF)
+        if file_type in (None, "video"):
+            video = VideoFile.objects.select_related("center").filter(pk=file_id).first()
+            if video is not None:
+                prepared_payload = self._prepare_payload(payload, video)
+                try:
+                    ok = video.validate_metadata_annotation(prepared_payload)
+                except Exception:  # pragma: no cover - defensive safety net
+                    logger.exception("Video validation crashed for id=%s", file_id)
+                    return Response(
+                        {"error": "Video validation encountered an unexpected error."},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+                if not ok:
+                    return Response({"error": "Video validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+
+                return Response({"message": "Video validated."}, status=status.HTTP_200_OK)
+
+            if file_type == "video":
+                return Response({"error": f"Video {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        # Then PDF (unless explicitly requesting Video)
+        if file_type in (None, "pdf"):
+            pdf = RawPdfFile.objects.select_related("center").filter(pk=file_id).first()
+            if pdf is not None:
+                prepared_payload = self._prepare_payload(payload, pdf)
+                try:
+                    ok = pdf.validate_metadata_annotation(prepared_payload)
+                except Exception:  # pragma: no cover - defensive safety net
+                    logger.exception("PDF validation crashed for id=%s", file_id)
+                    return Response(
+                        {"error": "PDF validation encountered an unexpected error."},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+                if not ok:
+                    return Response({"error": "PDF validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+
+                return Response({"message": "PDF validated."}, status=status.HTTP_200_OK)
+
+            if file_type == "pdf":
+                return Response({"error": f"PDF {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)
+
+    @staticmethod
+    def _prepare_payload(base_payload: Dict[str, Any], file_obj: Any) -> Dict[str, Any]:
+        """Return a fresh payload tailored for the given file object."""
+
+        prepared = dict(base_payload)
+        prepared.pop("file_type", None)
+
+        center = getattr(file_obj, "center", None)
+        center_name = getattr(center, "name", None)
+        if center_name and not prepared.get("center_name"):
+            prepared["center_name"] = center_name
+
+        return prepared

endoreg_db/views/media/__init__.py

@@ -1,9 +1,45 @@
 # Media Management Views (Phase 1.2)
 
 from .video_media import VideoMediaView
-from .pdf_media import PDFMediaManagementView
+from .pdf_media import PdfMediaView
+from ..video.reimport import VideoReimportView
+from ..pdf.reimport import PdfReimportView
+from .segments import video_segments_by_pk
+from .video_segments import (
+    video_segments_collection,
+    video_segments_by_video,
+    video_segment_detail,
+    video_segments_stats,
+    video_segment_validate,
+    video_segments_validate_bulk,
+    video_segments_validation_status,
+)
+from .sensitive_metadata import (
+    video_sensitive_metadata,
+    video_sensitive_metadata_verify,
+    pdf_sensitive_metadata,
+    pdf_sensitive_metadata_verify,
+    sensitive_metadata_list,
+    pdf_sensitive_metadata_list,
+)
 
 __all__ = [
     'VideoMediaView',
-    'PDFMediaManagementView',
+    'PdfMediaView',
+    'VideoReimportView',
+    'PdfReimportView',
+    'video_segments_by_pk',
+    'video_segments_collection',
+    'video_segments_by_video',
+    'video_segment_detail',
+    'video_segments_stats',
+    'video_segment_validate',
+    'video_segments_validate_bulk',
+    'video_segments_validation_status',
+    'video_sensitive_metadata',
+    'video_sensitive_metadata_verify',
+    'pdf_sensitive_metadata',
+    'pdf_sensitive_metadata_verify',
+    'sensitive_metadata_list',
+    'pdf_sensitive_metadata_list',
 ]

endoreg_db/views/media/pdf_media.py

@@ -21,7 +21,7 @@ from endoreg_db.utils.permissions import EnvironmentAwarePermission
 logger = logging.getLogger(__name__)
 
 
-class PDFMediaManagementView(APIView):
+class PdfMediaView(APIView):
     """
     PDF Media Management API for CRUD operations on PDF files.
     

endoreg_db/views/media/segments.py

@@ -0,0 +1,71 @@
+"""
+Modern Media Framework - Video Segment API Views
+October 14, 2025 - Migration to unified /api/media/videos/<pk>/segments/ pattern
+
+This module provides modern framework views for video segment management,
+wrapping legacy segment views with pk-based parameter handling.
+"""
+from endoreg_db.models import Label, LabelVideoSegment, VideoFile
+from endoreg_db.serializers.label_video_segment.label_video_segment import LabelVideoSegmentSerializer
+
+from django.db import transaction
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@api_view(['GET'])
+@permission_classes([EnvironmentAwarePermission])
+def video_segments_by_pk(request, pk):
+    """
+    Modern media framework endpoint for retrieving video segments.
+    
+    GET /api/media/videos/<int:pk>/segments/?label=<label_name>
+    
+    Returns all segments for a video, optionally filtered by label name.
+    This is the modern replacement for /api/video/<id>/segments/
+    
+    Query Parameters:
+        label (str, optional): Filter segments by label name (e.g., 'outside')
+    
+    Returns:
+        200: List of video segments
+        404: Video not found
+    """
+    try:
+        video = VideoFile.objects.get(id=pk)
+    except VideoFile.DoesNotExist:
+        logger.warning(f"Video with pk {pk} not found")
+        return Response(
+            {'error': f'Video with id {pk} not found'},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    
+    # Start with all segments for this video
+    queryset = LabelVideoSegment.objects.filter(video_file=video)
+    
+    # Optional filtering by label name
+    label_name = request.GET.get('label')
+    if label_name:
+        try:
+            label = Label.objects.get(name=label_name)
+            queryset = queryset.filter(label=label)
+            logger.info(f"Filtering segments for video {pk} by label '{label_name}'")
+        except Label.DoesNotExist:
+            logger.warning(f"Label '{label_name}' not found, returning empty result")
+            return Response(
+                {'error': f"Label '{label_name}' not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+    
+    # Order by start time for consistent results
+    segments = queryset.order_by('start_frame_number')
+    serializer = LabelVideoSegmentSerializer(segments, many=True)
+    
+    logger.info(f"Returning {len(segments)} segments for video {pk}")
+    return Response(serializer.data)

endoreg_db/views/media/sensitive_metadata.py

@@ -0,0 +1,314 @@
+# Modern Media Framework: Sensitive Metadata Management
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+from rest_framework import status
+from django.db import transaction
+from django.db.models import Q
+from django.shortcuts import get_object_or_404
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+from endoreg_db.models import VideoFile, RawPdfFile, SensitiveMeta
+from endoreg_db.serializers.meta import (
+    SensitiveMetaDetailSerializer,
+    SensitiveMetaUpdateSerializer,
+)
+
+# === VIDEO SENSITIVE METADATA ===
+
+@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 video ID to locate related sensitive metadata.
+    """
+    video = get_object_or_404(VideoFile, pk=pk)
+    
+    # Get related sensitive metadata
+    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
+    
+    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)
+
+
+# === PDF 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 PDF.
+    PDF-scoped: Uses PDF ID to locate related sensitive metadata.
+    """
+    pdf = get_object_or_404(RawPdfFile, pk=pk)
+    
+    # Get related sensitive metadata
+    if not pdf.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for PDF {pk}"},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    
+    sensitive_meta = pdf.sensitive_meta
+    
+    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,
+                "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 PDF 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 PDF {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 PDFs 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 PDFs - filter by existence of related PDFs
+        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 PDFs only.
+    Replaces legacy /api/pdf/sensitivemeta/list/
+    """
+    from endoreg_db.serializers.meta import SensitiveMetaDetailSerializer
+    
+    # Get all PDFs 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)