endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/views/label_video_segment/validate.py

@@ -0,0 +1,226 @@
+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 LabelVideoSegment, VideoFile
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+
+
+class LabelVideoSegmentValidateView(APIView):
+    """
+    POST /api/label-video-segment/<int:segment_id>/validate/
+    
+    Validiert ein einzelnes LabelVideoSegment und markiert es als verifiziert.
+    Dies wird verwendet, um vom Benutzer überprüfte Segment-Annotationen zu bestätigen.
+    
+    Body (optional):
+    {
+      "is_validated": true,  // optional, default true
+      "notes": "..."         // optional, Validierungsnotizen
+    }
+    """
+    permission_classes = DEBUG_PERMISSIONS
+
+    @transaction.atomic
+    def post(self, request, segment_id: int):
+        try:
+            # Segment abrufen
+            segment = LabelVideoSegment.objects.select_related('state', 'video_file', 'label').get(pk=segment_id)
+            
+            # Validierungsstatus aus Request (default: True)
+            is_validated = request.data.get('is_validated', True)
+            notes = request.data.get('notes', '')
+            
+            # State-Objekt abrufen oder erstellen
+            if not hasattr(segment, 'state') or segment.state is None:
+                # State muss existieren - wenn nicht, könnte ein Model-Problem vorliegen
+                return Response({
+                    "error": "Segment has no state object. Cannot validate."
+                }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            
+            # State aktualisieren
+            segment.state.is_validated = is_validated
+            if notes:
+                # Falls ein notes-Feld existiert
+                if hasattr(segment.state, 'validation_notes'):
+                    segment.state.validation_notes = notes
+            segment.state.save()
+            
+            return Response({
+                "message": f"Segment {segment_id} validation status updated.",
+                "segment_id": segment_id,
+                "is_validated": is_validated,
+                "label": segment.label.name if segment.label else None,
+                "video_id": segment.video_file.id if segment.video_file else None,
+                "start_frame": segment.start_frame_number,
+                "end_frame": segment.end_frame_number
+            }, status=status.HTTP_200_OK)
+            
+        except LabelVideoSegment.DoesNotExist:
+            return Response({
+                "error": f"Segment {segment_id} not found."
+            }, status=status.HTTP_404_NOT_FOUND)
+        except Exception as e:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error validating segment {segment_id}: {e}")
+            return Response({
+                "error": f"Validation failed: {str(e)}"
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class BulkSegmentValidateView(APIView):
+    """
+    POST /api/label-video-segments/validate-bulk/
+    
+    Validiert mehrere LabelVideoSegments gleichzeitig.
+    Nützlich für Batch-Validierung nach Review.
+    
+    Body:
+    {
+      "segment_ids": [1, 2, 3, ...],
+      "is_validated": true,  // optional, default true
+      "notes": "..."         // optional, gilt für alle Segmente
+    }
+    """
+    permission_classes = DEBUG_PERMISSIONS
+
+    @transaction.atomic
+    def post(self, request):
+        segment_ids = request.data.get('segment_ids', [])
+        is_validated = request.data.get('is_validated', True)
+        notes = request.data.get('notes', '')
+        
+        if not segment_ids:
+            return Response({
+                "error": "segment_ids is required"
+            }, status=status.HTTP_400_BAD_REQUEST)
+        
+        try:
+            # Alle Segmente abrufen
+            segments = LabelVideoSegment.objects.filter(pk__in=segment_ids).select_related('state')
+            
+            if not segments.exists():
+                return Response({
+                    "error": "No segments found with provided IDs"
+                }, status=status.HTTP_404_NOT_FOUND)
+            
+            updated_count = 0
+            failed_ids = []
+            
+            for segment in segments:
+                try:
+                    if segment.state:
+                        segment.state.is_validated = is_validated
+                        if notes and hasattr(segment.state, 'validation_notes'):
+                            segment.state.validation_notes = notes
+                        segment.state.save()
+                        updated_count += 1
+                    else:
+                        failed_ids.append(segment.id)
+                except Exception as e:
+                    import logging
+                    logger = logging.getLogger(__name__)
+                    logger.error(f"Error validating segment {segment.id}: {e}")
+                    failed_ids.append(segment.id)
+            
+            response_data = {
+                "message": f"Bulk validation completed. {updated_count} segments updated.",
+                "updated_count": updated_count,
+                "requested_count": len(segment_ids),
+                "is_validated": is_validated
+            }
+            
+            if failed_ids:
+                response_data["failed_ids"] = failed_ids
+                response_data["warning"] = f"{len(failed_ids)} segments could not be validated"
+            
+            return Response(response_data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error in bulk validation: {e}")
+            return Response({
+                "error": f"Bulk validation failed: {str(e)}"
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+class VideoSegmentValidationCompleteView(APIView):
+    """
+    POST /api/videos/<int:video_id>/segments/validate-complete/
+    
+    Markiert alle Segmente eines Videos als validiert.
+    Nützlich nach vollständiger Review eines Videos.
+    
+    Body (optional):
+    {
+      "label_name": "...",   // optional, nur Segmente mit diesem Label validieren
+      "notes": "..."         // optional
+    }
+    """
+    permission_classes = DEBUG_PERMISSIONS
+
+    @transaction.atomic
+    def post(self, request, video_id: int):
+        try:
+            # Video abrufen
+            video = VideoFile.objects.get(pk=video_id)
+            
+            label_name = request.data.get('label_name')
+            notes = request.data.get('notes', '')
+            
+            # Segmente filtern
+            segments_query = LabelVideoSegment.objects.filter(video_file=video).select_related('state', 'label')
+            
+            if label_name:
+                segments_query = segments_query.filter(label__name=label_name)
+            
+            segments = segments_query.all()
+            
+            if not segments.exists():
+                return Response({
+                    "message": "No segments found to validate",
+                    "video_id": video_id,
+                    "updated_count": 0
+                }, status=status.HTTP_200_OK)
+            
+            updated_count = 0
+            failed_count = 0
+            
+            for segment in segments:
+                try:
+                    if segment.state:
+                        segment.state.is_validated = True
+                        if notes and hasattr(segment.state, 'validation_notes'):
+                            segment.state.validation_notes = notes
+                        segment.state.save()
+                        updated_count += 1
+                    else:
+                        failed_count += 1
+                except Exception as e:
+                    import logging
+                    logger = logging.getLogger(__name__)
+                    logger.error(f"Error validating segment {segment.id}: {e}")
+                    failed_count += 1
+            
+            return Response({
+                "message": f"Video segment validation completed for video {video_id}",
+                "video_id": video_id,
+                "total_segments": len(segments),
+                "updated_count": updated_count,
+                "failed_count": failed_count,
+                "label_filter": label_name
+            }, status=status.HTTP_200_OK)
+            
+        except VideoFile.DoesNotExist:
+            return Response({
+                "error": f"Video {video_id} not found"
+            }, status=status.HTTP_404_NOT_FOUND)
+        except Exception as e:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error completing validation for video {video_id}: {e}")
+            return Response({
+                "error": f"Validation completion failed: {str(e)}"
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/media/__init__.py

@@ -0,0 +1,45 @@
+# Media Management Views (Phase 1.2)
+
+from .video_media import VideoMediaView
+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',
+    '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

@@ -0,0 +1,388 @@
+"""
+PDF Media Management View (Phase 1.2)
+
+Provides standardized REST API for PDF files including listing, detail retrieval,
+and streaming for the media management system.
+
+This is separate from the existing pdf.PDFMediaView which handles legacy workflows.
+"""
+
+import logging
+import os
+from django.http import Http404, FileResponse
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from django.views.decorators.clickjacking import xframe_options_exempt
+from django.db.models import Q
+
+from endoreg_db.models import RawPdfFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+logger = logging.getLogger(__name__)
+
+
+class PdfMediaView(APIView):
+    """
+    PDF Media Management API for CRUD operations on PDF files.
+    
+    Endpoints:
+    - GET /api/media/pdfs/ - List all PDFs with filtering
+    - GET /api/media/pdfs/{id}/ - Get PDF details
+    - GET /api/media/pdfs/{id}/stream/ - Stream PDF file (same as detail for PDFs)
+    - PATCH /api/media/pdfs/{id}/ - Update PDF metadata (future)
+    - DELETE /api/media/pdfs/{id}/ - Delete PDF (future)
+    
+    Query Parameters:
+    - status: Filter by processing status (not_started, done, validated)
+    - search: Search in filename
+    - limit: Limit results (default: 50)
+    - offset: Pagination offset
+    
+    Examples:
+    - GET /api/media/pdfs/?status=done&search=exam
+    - GET /api/media/pdfs/123/
+    - GET /api/media/pdfs/123/stream/
+    
+    Phase 1.2 Implementation:
+    - List and detail views implemented
+    - PDF streaming functionality
+    - Filtering and search functionality
+    - Pagination support
+    - Error handling with proper HTTP status codes
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk=None):
+        """
+        Handle GET requests for PDF listing, detail retrieval, or streaming.
+        
+        Args:
+            request: HTTP request object
+            pk: Optional PDF ID for detail view or streaming
+            
+        Returns:
+            Response or FileResponse: JSON response with PDF data or PDF file stream
+            
+        Raises:
+            Http404: If specific PDF not found
+        """
+        if pk is not None:
+            # Check if this is a streaming request
+            if request.path.endswith('/stream/'):
+                return self._stream_pdf(pk)
+            else:
+                # Detail view
+                return self._get_pdf_detail(pk)
+        else:
+            # List view
+            return self._list_pdfs(request)
+
+    def _get_pdf_detail(self, pk):
+        """
+        Get detailed information for a specific PDF.
+        
+        Args:
+            pk: PDF primary key
+            
+        Returns:
+            Response: JSON response with PDF details
+            
+        Raises:
+            Http404: If PDF not found
+        """
+        try:
+            # Validate pdf_id is numeric
+            try:
+                pdf_id_int = int(pk)
+            except (ValueError, TypeError):
+                raise Http404("Invalid PDF ID format")
+                
+            # Fetch PDF with related data
+            pdf = RawPdfFile.objects.select_related('sensitive_meta').get(pk=pdf_id_int)
+            
+            # Build PDF details
+            pdf_data = {
+                "id": pdf.id,
+                "filename": getattr(pdf.file, 'name', 'Unknown'),
+                "file_size": getattr(pdf.file, 'size', 0),
+                "pdf_hash": pdf.pdf_hash,
+                "uploaded_at": pdf.uploaded_at.isoformat() if hasattr(pdf, 'uploaded_at') else None,
+                "anonymized_text": pdf.anonymized_text,
+                "has_anonymized_text": bool(pdf.anonymized_text and pdf.anonymized_text.strip()),
+                "is_validated": getattr(pdf.sensitive_meta, 'is_verified', False) if pdf.sensitive_meta else False,
+                "stream_url": self.request.build_absolute_uri(f"/api/media/pdfs/{pdf.id}/stream/"),
+            }
+            
+            # Add patient metadata if available
+            if pdf.sensitive_meta:
+                pdf_data.update({
+                    "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.strftime("%d.%m.%Y") if pdf.sensitive_meta.patient_dob else None,
+                    "examination_date": pdf.sensitive_meta.examination_date.strftime("%d.%m.%Y") if pdf.sensitive_meta.examination_date else None,
+                })
+            
+            return Response(pdf_data)
+            
+        except RawPdfFile.DoesNotExist:
+            raise Http404(f"PDF with ID {pk} not found")
+            
+        except Exception as e:
+            logger.error(f"Unexpected error in PDF detail view for ID {pk}: {str(e)}")
+            return Response(
+                {"error": "Failed to retrieve PDF details"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+            
+    @xframe_options_exempt
+    def _stream_pdf(self, pk):
+        """
+        Stream PDF file content for viewing/download.
+        
+        Args:
+            pk: PDF primary key
+            
+        Returns:
+            FileResponse: PDF file stream
+            
+        Raises:
+            Http404: If PDF not found or file cannot be accessed
+        """
+        try:
+            # Validate pdf_id is numeric
+            try:
+                pdf_id_int = int(pk)
+            except (ValueError, TypeError):
+                raise Http404("Invalid PDF ID format")
+                
+            # Fetch PDF
+            pdf = RawPdfFile.objects.get(pk=pdf_id_int)
+            
+            # Check if file exists
+            if not pdf.file or not pdf.file.name:
+                raise Http404("PDF file not found")
+                
+            try:
+                # Open file for streaming
+                file_path = pdf.file.path
+                if not os.path.exists(file_path):
+                    raise Http404("PDF file does not exist on disk")
+                    
+                # Create file response
+                response = FileResponse(
+                    open(file_path, 'rb'),
+                    content_type='application/pdf',
+                    as_attachment=False  # View in browser, not download
+                )
+                
+                # Set filename for browser
+                filename = os.path.basename(pdf.file.name)
+                response['Content-Disposition'] = f'inline; filename="{filename}"'
+                
+                # CORS headers for frontend access
+                frontend_origin = os.environ.get('FRONTEND_ORIGIN', 'http://localhost:8000')
+                response['Access-Control-Allow-Origin'] = frontend_origin
+                response['Access-Control-Allow-Credentials'] = 'true'
+                
+                return response
+                
+            except (OSError, IOError) as e:
+                logger.error(f"File access error for PDF {pk}: {str(e)}")
+                raise Http404("PDF file cannot be accessed")
+                
+        except RawPdfFile.DoesNotExist:
+            raise Http404(f"PDF with ID {pk} not found")
+            
+        except Exception as e:
+            logger.error(f"Unexpected error in PDF streaming for ID {pk}: {str(e)}")
+            raise Http404("PDF file cannot be streamed")
+
+    def _list_pdfs(self, request):
+        """
+        List PDFs with filtering, search, and pagination.
+        
+        Args:
+            request: HTTP request with query parameters
+            
+        Returns:
+            Response: JSON response with paginated PDF list
+        """
+        try:
+            # Start with all PDFs
+            queryset = RawPdfFile.objects.select_related('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(file__icontains=search)
+                )
+            
+            # Order by upload date (newest first) or id if no upload date
+            if hasattr(queryset.model, 'uploaded_at'):
+                queryset = queryset.order_by('-uploaded_at')
+            else:
+                queryset = queryset.order_by('-id')
+            
+            # Apply pagination
+            limit = min(int(request.query_params.get('limit', 50)), 100)
+            offset = int(request.query_params.get('offset', 0))
+            
+            total_count = queryset.count()
+            pdfs = queryset[offset:offset + limit]
+            
+            # Serialize PDFs manually (no dedicated serializer yet)
+            results = []
+            for pdf in pdfs:
+                pdf_item = {
+                    "id": pdf.id,
+                    "filename": getattr(pdf.file, 'name', 'Unknown'),
+                    "file_size": self._safe_get_file_size(pdf.file),
+                    "pdf_hash": pdf.pdf_hash,
+                    "has_anonymized_text": bool(pdf.anonymized_text and pdf.anonymized_text.strip()),
+                    "is_validated": getattr(pdf.sensitive_meta, 'is_verified', False) if pdf.sensitive_meta else False,
+                    "stream_url": request.build_absolute_uri(f"/api/media/pdfs/{pdf.id}/stream/"),
+                }
+                
+                # Determine status based on anonymization and validation
+                if not pdf.anonymized_text or not pdf.anonymized_text.strip():
+                    pdf_item["status"] = "not_started"
+                elif pdf.sensitive_meta and pdf.sensitive_meta.is_verified:
+                    pdf_item["status"] = "validated"
+                else:
+                    pdf_item["status"] = "done"
+                    
+                results.append(pdf_item)
+            
+            return Response({
+                "count": total_count,
+                "next": self._get_next_url(request, offset, limit, total_count),
+                "previous": self._get_previous_url(request, offset, limit),
+                "results": results
+            })
+            
+        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 PDF list view: {str(e)}")
+            return Response(
+                {"error": "Failed to retrieve PDF list"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _safe_get_file_size(self, file_field):
+        """
+        Safely get file size without causing errors if file doesn't exist.
+        
+        Args:
+            file_field: Django FileField
+            
+        Returns:
+            int: File size in bytes, or 0 if file doesn't exist
+        """
+        if not file_field or not file_field.name:
+            return 0
+        
+        try:
+            return file_field.size
+        except (OSError, IOError, ValueError):
+            # File doesn't exist on disk or is corrupted
+            return 0
+
+    def _apply_filters(self, queryset, query_params):
+        """
+        Apply status and other filters to PDF 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':
+                # PDFs without anonymized text
+                queryset = queryset.filter(
+                    Q(anonymized_text__isnull=True) | Q(anonymized_text__exact='')
+                )
+            elif status_filter == 'done':
+                # PDFs with anonymized text but not validated
+                queryset = queryset.filter(
+                    ~Q(anonymized_text__isnull=True),
+                    ~Q(anonymized_text__exact=''),
+                    Q(sensitive_meta__is_verified=False) | Q(sensitive_meta__isnull=True)
+                )
+            elif status_filter == 'validated':
+                # PDFs with anonymized text and validated
+                queryset = queryset.filter(
+                    ~Q(anonymized_text__isnull=True),
+                    ~Q(anonymized_text__exact=''),
+                    sensitive_meta__is_verified=True
+                )
+                
+        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 PDF metadata (Phase 1.2+ future enhancement).
+        
+        Currently returns 501 Not Implemented.
+        """
+        return Response(
+            {"error": "PDF metadata updates not yet implemented"},
+            status=status.HTTP_501_NOT_IMPLEMENTED
+        )
+
+    def delete(self, request, pk):
+        """
+        Delete PDF file (Phase 1.2+ future enhancement).
+        
+        Currently returns 501 Not Implemented.
+        Use /api/media-management/force-remove/{id}/ instead.
+        """
+        return Response(
+            {
+                "error": "PDF deletion not yet implemented", 
+                "alternative": f"Use DELETE /api/media-management/force-remove/{pk}/ instead"
+            },
+            status=status.HTTP_501_NOT_IMPLEMENTED
+        )