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

endoreg_db/views/media/video_media.py

@@ -0,0 +1,272 @@
+"""
+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.http import Http404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from django.db.models import Q
+
+from endoreg_db.models import VideoFile
+from endoreg_db.serializers.video.video_file_list import VideoFileListSerializer
+from endoreg_db.serializers.video.video_file_detail import VideoDetailSerializer
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+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 (future)
+    
+    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 = [EnvironmentAwarePermission]
+
+    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':
+                # 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,15 @@
+from .available_files_list import AvailableFilesListView
+from .sensitive_meta_detail import SensitiveMetaDetailView
+from .sensitive_meta_list import SensitiveMetaListView
+from .sensitive_meta_verification import SensitiveMetaVerificationView
+from .report_meta import (
+    ReportFileMetadataView,
+)
+
+__all__ = [
+    "AvailableFilesListView",
+    "SensitiveMetaDetailView",
+    "SensitiveMetaListView",
+    "SensitiveMetaVerificationView",
+    "ReportFileMetadataView",
+]

endoreg_db/views/meta/available_files_list.py

@@ -0,0 +1,146 @@
+from endoreg_db.models import RawPdfFile, VideoFile
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+import logging
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+logger = logging.getLogger(__name__)
+
+class AvailableFilesListView(APIView):
+    """
+    API endpoint to list available PDFs and videos for anonymization selection.
+
+    GET: Returns lists of available PDF and video files with their metadata
+    """
+
+    permission_classes = DEBUG_PERMISSIONS
+
+    def _validate_pagination_params(self, request):
+        """Validates and returns pagination parameters, raising ValueError on failure."""
+        try:
+            limit = int(request.query_params.get('limit', 50))
+            offset = int(request.query_params.get('offset', 0))
+        except (ValueError, TypeError):
+            raise ValueError("Invalid 'limit' or 'offset' parameter. Must be integers.")
+
+        if limit < 0 or offset < 0:
+            raise ValueError("'limit' and 'offset' must be non-negative.")
+        
+        if limit > 100:
+            logger.warning(f"Client requested limit of {limit}, capping at 100.")
+            limit = 100
+
+        return limit, offset
+
+    def get(self, request):
+        """
+        List available PDF and video files for anonymization selection.
+
+        Query Parameters:
+        - type: Filter by file type ('pdf' or 'video')
+        - status: Filter by anonymization status
+        - limit: Number of results to return (default 50, max 100)
+        - offset: Offset for pagination (default 0)
+
+        Returns:
+        {
+            "pdfs": [...],
+            "videos": [...],
+            "total_pdfs": N,
+            "total_videos": N
+        }
+        """
+        try:
+            limit, offset = self._validate_pagination_params(request)
+            file_type = request.query_params.get('type', 'all').lower()
+        except ValueError as e:
+            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            response_data = {}
+
+            # Get PDFs if requested
+            if file_type in ['all', 'pdf']:
+                pdf_queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
+                total_pdfs = pdf_queryset.count()
+                paginated_pdfs = pdf_queryset[offset:offset + limit]
+
+                pdf_list = []
+                for pdf in paginated_pdfs:
+                    # Safely handle missing file attribute
+                    file_name = 'Unknown'
+                    file_path = None
+                    if hasattr(pdf, 'file') and pdf.file:
+                        file_name = pdf.file.name.split('/')[-1]
+                        file_path = pdf.file.name
+                    pdf_data = {
+                        'id': pdf.id,
+                        'filename': file_name,
+                        'file_path': file_path,
+                        'sensitive_meta_id': pdf.sensitive_meta_id,
+                        'anonymized_text': getattr(pdf, 'anonymized_text', None),
+                        'created_at': pdf.date_created if hasattr(pdf, 'created_at') else None,
+                        'patient_info': None
+                    }
+
+                    # Add patient info if available
+                    if pdf.sensitive_meta:
+                        pdf_data['patient_info'] = {
+                            'patient_first_name': pdf.sensitive_meta.patient_first_name,
+                            'patient_last_name': pdf.sensitive_meta.patient_last_name,
+                            'patient_dob': pdf.sensitive_meta.patient_dob,
+                            'examination_date': pdf.sensitive_meta.examination_date,
+                            'center_name': pdf.sensitive_meta.center.name if pdf.sensitive_meta.center else None
+                        }
+
+                    pdf_list.append(pdf_data)
+
+                response_data['pdfs'] = pdf_list
+                response_data['total_pdfs'] = total_pdfs
+
+            # Get Videos if requested
+            if file_type in ['all', 'video']:
+                video_queryset = VideoFile.objects.select_related('sensitive_meta').all()
+                total_videos = video_queryset.count()
+                paginated_videos = video_queryset[offset:offset + limit]
+
+                video_list = []
+                for video in paginated_videos:
+                    # Safely handle missing raw_file attribute
+                    file_name = 'Unknown'
+                    file_path = None
+                    if hasattr(video, 'raw_file') and video.raw_file:
+                        file_name = video.raw_file.name.split('/')[-1]
+                        file_path = video.raw_file.name
+                    video_data = {
+                        'id': video.id,
+                        'filename': file_name,
+                        'file_path': file_path,
+                        'sensitive_meta_id': video.sensitive_meta_id,
+                        'patient_info': None
+                    }
+
+                    # Add patient info if available
+                    if video.sensitive_meta:
+                        video_data['patient_info'] = {
+                            'patient_first_name': video.sensitive_meta.patient_first_name,
+                            'patient_last_name': video.sensitive_meta.patient_last_name,
+                            'patient_dob': video.sensitive_meta.patient_dob,
+                            'examination_date': video.sensitive_meta.examination_date,
+                            'center_name': video.sensitive_meta.center.name if video.sensitive_meta.center else None
+                        }
+
+                    video_list.append(video_data)
+
+                response_data['videos'] = video_list
+                response_data['total_videos'] = total_videos
+
+            return Response(response_data)
+        except Exception as e:
+            logger.error(f"Error listing available files: {e}", exc_info=True)
+            return Response(
+                {"error": "An unexpected error occurred while fetching files."},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/meta/report_meta.py

@@ -0,0 +1,53 @@
+from endoreg_db.models import RawPdfFile
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ReportFileMetadataView(APIView):
+    """
+    API-Endpunkt für Report-Datei-Metadaten
+    GET /api/reports/{report_id}/file-metadata/
+    """
+
+    def get(self, _request, report_id):
+        try:
+            report = get_object_or_404(RawPdfFile, id=report_id)
+
+            if not report.file:
+                return Response(
+                    {"error": "Keine Datei für diesen Report verfügbar"},
+                    status=status.HTTP_404_NOT_FOUND
+                )
+
+            metadata = self._get_file_metadata(report)
+            return Response(metadata)
+
+        except (ValueError, TypeError) as e:
+            logger.error("Fehler beim Laden der Datei-Metadaten: %s", str(e))
+            return Response(
+                {"error": "Metadaten konnten nicht geladen werden"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _get_file_metadata(self, report):
+        """Sammelt Datei-Metadaten"""
+        file_path = Path(report.file.name)
+
+        try:
+            file_size = report.file.size
+        except OSError:
+            file_size = 0
+
+        return {
+            'filename': file_path.name,
+            'file_type': file_path.suffix.lower().lstrip('.'),
+            'file_size': file_size,
+            'upload_date': report.created_at if hasattr(report, 'created_at') else None,
+            'last_modified': report.updated_at if hasattr(report, 'updated_at') else None
+        }

endoreg_db/views/meta/sensitive_meta_detail.py

@@ -0,0 +1,148 @@
+from endoreg_db.models import SensitiveMeta
+from endoreg_db.serializers import SensitiveMetaDetailSerializer, SensitiveMetaUpdateSerializer
+
+from django.db import transaction
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SensitiveMetaDetailView(APIView):
+    """
+    API endpoint to retrieve and update SensitiveMeta details with verification state.
+
+    GET: Returns detailed SensitiveMeta information for annotation/verification
+    PATCH: Updates SensitiveMeta fields including verification state
+    """
+
+    permission_classes = DEBUG_PERMISSIONS  # Changed from IsAuthenticated for development
+
+    def get(self, request, sensitive_meta_id=None):
+        """
+        Retrieve SensitiveMeta details for display and annotation.
+
+        Supports both URL parameter and query parameter access patterns:
+        - /api/pdf/sensitivemeta/123/ (URL parameter)
+        - /api/pdf/sensitivemeta/?id=123 (query parameter - for backward compatibility)
+        - /api/pdf/sensitivemeta/ (list all - returns empty list instead of 400)
+
+        Returns detailed information suitable for user verification.
+        """
+        # Handle both URL parameter and query parameter patterns
+        if not sensitive_meta_id:
+            sensitive_meta_id = request.query_params.get('id')
+
+        # If no ID provided, return empty list instead of error
+        if not sensitive_meta_id:
+            return Response([], status=status.HTTP_200_OK)
+
+        try:
+            # Convert to int if it's a string
+            sensitive_meta_id = int(sensitive_meta_id)
+
+            # Get the SensitiveMeta instance with related data
+            sensitive_meta = SensitiveMeta.objects.select_related(
+                'center',
+                'patient_gender',
+                'pseudo_patient',
+                'pseudo_examination'
+            ).prefetch_related(
+                'examiners',
+                'state'
+            ).get(id=sensitive_meta_id)
+
+            # Serialize for display
+            serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+
+            # Return direct data to match anonymization store expectations
+            # Instead of wrapping in "sensitive_meta" key, return data directly
+            response_data = serializer.data
+
+            logger.info(f"Retrieved SensitiveMeta {sensitive_meta_id} for user {request.user}")
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        except ValueError:
+            return Response(
+                {"error": "Invalid sensitive_meta_id format. Must be an integer."},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        except SensitiveMeta.DoesNotExist:
+            return Response(
+                {"error": f"SensitiveMeta with ID {sensitive_meta_id} not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+        except Exception as e:
+            logger.error(f"Error retrieving SensitiveMeta {sensitive_meta_id}: {e}")
+            return Response(
+                {"error": "Internal server error occurred"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    @transaction.atomic
+    def patch(self, request, sensitive_meta_id=None):
+        """
+        Update SensitiveMeta fields including verification state.
+
+        Accepts partial updates for any field in SensitiveMetaUpdateSerializer.
+        Special handling for verification state changes.
+        """
+        if not sensitive_meta_id:
+            return Response(
+                {"error": "sensitive_meta_id is required"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            # Get the SensitiveMeta instance
+            sensitive_meta = get_object_or_404(SensitiveMeta, id=sensitive_meta_id)
+
+            # Validate and update using serializer
+            serializer = SensitiveMetaUpdateSerializer(
+                sensitive_meta,
+                data=request.data,
+                partial=True
+            )
+
+            if serializer.is_valid():
+                updated_instance = serializer.save()
+
+                # Return updated data using detail serializer
+                response_serializer = SensitiveMetaDetailSerializer(updated_instance)
+
+                response_data = {
+                    "message": "SensitiveMeta updated successfully",
+                    "sensitive_meta": response_serializer.data,
+                    "updated_fields": list(request.data.keys())
+                }
+
+                logger.info(
+                    f"Updated SensitiveMeta {sensitive_meta_id} by user {request.user}. "
+                    f"Fields: {list(request.data.keys())}"
+                )
+
+                return Response(response_data, status=status.HTTP_200_OK)
+            else:
+                return Response(
+                    {
+                        "error": "Validation failed",
+                        "details": serializer.errors
+                    },
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+        except SensitiveMeta.DoesNotExist:
+            return Response(
+                {"error": f"SensitiveMeta with ID {sensitive_meta_id} not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+        except Exception as e:
+            logger.error(f"Error updating SensitiveMeta {sensitive_meta_id}: {e}")
+            return Response(
+                {"error": "Internal server error occurred"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )