endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/views/media/video_media.py

@@ -8,16 +8,20 @@ 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.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.serializers.video.video_file_list import VideoFileListSerializer
 from endoreg_db.utils.permissions import EnvironmentAwarePermission
+#for keycloak
+from rest_framework.permissions import IsAuthenticated
+from endoreg_db.authz.permissions import PolicyPermission
 
 logger = logging.getLogger(__name__)
 
@@ -25,23 +29,23 @@ 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 
-    
+    - 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
@@ -49,19 +53,22 @@ class VideoMediaView(APIView):
     - Error handling with proper HTTP status codes
     - Integration with existing serializers
     """
-    permission_classes = [EnvironmentAwarePermission]
+
+    #permission_classes = [EnvironmentAwarePermission]
+        #permission_classes = [EnvironmentAwarePermission]
+    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
         """
@@ -75,13 +82,13 @@ class VideoMediaView(APIView):
     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
         """
@@ -91,137 +98,137 @@ class VideoMediaView(APIView):
                 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)
-            
+            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})
-            
+            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
+                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()
-            
+            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()
+            search = request.query_params.get("search", "").strip()
             if search:
-                queryset = queryset.filter(
-                    Q(original_file_name__icontains=search)
-                )
-            
+                queryset = queryset.filter(Q(original_file_name__icontains=search))
+
             # Order by upload date (newest first)
-            queryset = queryset.order_by('-uploaded_at')
-            
+            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))
-            
+            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]
-            
+            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
-            })
-            
+
+            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
+                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
+                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()
-        
+        status_filter = query_params.get("status", "").strip().lower()
+
         if status_filter:
-            if status_filter == 'not_started':
+            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)
+                    Q(state__isnull=True)
+                    | Q(
+                        state__frames_extracted=False,
+                        state__sensitive_meta_processed=False,
+                    )
                 )
-            elif status_filter == 'processing':
+            elif status_filter == "processing":
                 # Videos in any processing state
                 queryset = queryset.filter(
-                    state__frames_extracted=True,
-                    state__sensitive_meta_processed=False
+                    state__frames_extracted=True, state__sensitive_meta_processed=False
                 )
-            elif status_filter == 'done':
+            elif status_filter == "done_processing_anonymization":
                 # Videos with anonymization complete but not validated
                 queryset = queryset.filter(
-                    state__anonymized=True,
-                    sensitive_meta__is_verified=False
+                    state__anonymized=True, sensitive_meta__is_verified=False
                 )
-            elif status_filter == 'validated':
+            elif status_filter == "validated":
                 # Videos with human validation complete
                 queryset = queryset.filter(
-                    state__anonymized=True,
-                    sensitive_meta__is_verified=True
+                    state__anonymized=True, sensitive_meta__is_verified=True
                 )
-            elif status_filter == 'failed':
+            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
+                    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)
 
@@ -229,16 +236,16 @@ class VideoMediaView(APIView):
         """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
-        
+        params["offset"] = offset
+        params["limit"] = limit
+
         base_url = request.build_absolute_uri(request.path)
         if params:
             return f"{base_url}?{params.urlencode()}"
@@ -248,25 +255,25 @@ class VideoMediaView(APIView):
     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
+            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"
+                "error": "Video deletion not yet implemented",
+                "alternative": f"Use DELETE /api/media-management/force-remove/{pk}/ instead",
             },
-            status=status.HTTP_501_NOT_IMPLEMENTED
+            status=status.HTTP_501_NOT_IMPLEMENTED,
         )

endoreg_db/views/media/video_segments.py

@@ -288,8 +288,6 @@ def video_segment_validate(request, pk: int, segment_id: int):
         # Update state
         with transaction.atomic():
             segment.state.is_validated = is_validated
-            if notes and hasattr(segment.state, "validation_notes"):
-                segment.state.validation_notes = notes
             segment.state.save()
 
         logger.info(f"Validated segment {segment_id} in video {pk}: {is_validated}")
@@ -510,7 +508,8 @@ def video_segments_validation_status(request, pk: int):
                     failed_count += 1
 
         logger.info(f"Completed validation for {updated_count} segments in video {pk}")
-
+        logger.info(f"Removing Outside Segments")
+        video_file.label_video_segments.filter(video_file=video, label="outside", state__is_validated=False).delete()
         return Response(
             {
                 "message": f"Video segment validation completed for video {pk}",

endoreg_db/views/meta/sensitive_meta_detail.py

@@ -20,69 +20,6 @@ class SensitiveMetaDetailView(APIView):
     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):
         """

endoreg_db/views/patient/patient.py

@@ -6,11 +6,11 @@ from rest_framework import viewsets, status, serializers
 from rest_framework.response import Response
 from rest_framework.decorators import action
 
-
+from endoreg_db.authz.permissions import PolicyPermission
 from endoreg_db.models import Patient
 from endoreg_db.serializers.patient import PatientSerializer
 from endoreg_db.models.medical.patient.patient_examination import PatientExamination
-
+from rest_framework.permissions import IsAuthenticated
 @staff_member_required  # Ensures only staff members can access the page
 def start_examination(request):
     return render(request, 'admin/start_examination.html')  # Loads the simple HTML page
@@ -21,8 +21,9 @@ class PatientViewSet(viewsets.ModelViewSet):
     """API endpoint for managing patients."""
     queryset = Patient.objects.all()
     serializer_class = PatientSerializer
-    #permission_classes = [IsAuthenticatedOrReadOnly] 
-
+    permission_classes = [PolicyPermission]
+    #permission_classes = [PolicyPermission]
+    
     def perform_create(self, serializer):
         """Erweiterte Validierung beim Erstellen eines Patienten"""
         try:

endoreg_db/views/pdf/pdf_stream.py

@@ -3,7 +3,7 @@ import os
 import re
 
 from django.http import FileResponse, Http404, StreamingHttpResponse
-from django.views.decorators.clickjacking import xframe_options_sameorigin
+from django.views.decorators.clickjacking import xframe_options_exempt, xframe_options_sameorigin
 from rest_framework.views import APIView
 
 from endoreg_db.models import RawPdfFile
@@ -40,30 +40,29 @@ class PdfStreamView(APIView):
     """
     Streams a PDF file with correct HTTP range support and proper file handle management.
 
-    Supports streaming both raw (original) and anonymized PDF files.
+    Supports streaming both raw (original) and processed PDF files.
 
     Query Parameters:
-        type: 'raw' (default) or 'anonymized' - Selects which PDF file to stream
+        type: 'raw' (default) or 'processed' - Selects which PDF file to stream
 
     Examples:
         GET /api/media/pdf/1/?type=raw - Stream original raw PDF
-        GET /api/media/pdf/1/?type=anonymized - Stream anonymized PDF
+        GET /api/media/pdf/1/?type=processed - Stream processed PDF
     """
 
     permission_classes = [EnvironmentAwarePermission]
-
-    @xframe_options_sameorigin
-    def get(self, request, pdf_id: int, *args, **kwargs):
+    @xframe_options_exempt
+    def get(self, request, pk: int, *args, **kwargs):
         file_type = "raw"  # Initialize for error logging
         try:
-            pdf_obj = RawPdfFile.objects.filter(pk=pdf_id).first()
+            pdf_obj = RawPdfFile.objects.filter(pk=pk).first()
             if not pdf_obj:
-                logger.warning(f"PDF not found: ID {pdf_id}")
+                logger.warning(f"PDF not found: ID {pk}")
                 raise Http404("PDF not found")
 
             # Parse query parameters to determine which file to stream
             file_type = request.query_params.get("type", "raw").lower()
-            if file_type not in ["raw", "anonymized"]:
+            if file_type not in ["raw", "processed"]:
                 logger.warning(f"Invalid file_type '{file_type}', defaulting to 'raw'")
                 file_type = "raw"
 
@@ -71,15 +70,15 @@ class PdfStreamView(APIView):
             if file_type == "raw":
                 file_field = pdf_obj.file
                 if not file_field:
-                    logger.warning(f"No raw PDF file available for PDF ID {pdf_id}")
+                    logger.warning(f"No raw PDF file available for PDF ID {pk}")
                     raise Http404("Raw PDF file not available")
             else:  # anonymized
                 file_field = pdf_obj.anonymized_file
                 if not file_field:
                     logger.warning(
-                        f"No anonymized PDF file available for PDF ID {pdf_id}"
+                        f"No processed PDF file available for PDF ID {pk}"
                     )
-                    raise Http404("Anonymized PDF file not available")
+                    raise Http404("Processed PDF file not available")
 
             # Check if file exists on filesystem
             try:
@@ -92,22 +91,22 @@ class PdfStreamView(APIView):
 
                 file_size = os.path.getsize(file_path)
             except (OSError, IOError, AttributeError) as e:
-                logger.error(f"Error accessing {file_type} PDF file {pdf_id}: {e}")
+                logger.error(f"Error accessing {file_type} PDF file {pk}: {e}")
                 raise Http404(f"{file_type.capitalize()} PDF file not accessible")
 
             # Generate safe filename
             base_filename = (
                 os.path.basename(file_field.name)
                 if file_field.name
-                else f"document_{pdf_id}.pdf"
+                else f"document_{pk}.pdf"
             )
             if not base_filename.endswith(".pdf"):
                 base_filename += ".pdf"
 
             # Add type indicator to filename for clarity
-            if file_type == "anonymized":
+            if file_type == "processed":
                 name_parts = base_filename.rsplit(".", 1)
-                safe_filename = f"{name_parts[0]}_anonymized.{name_parts[1]}"
+                safe_filename = f"{name_parts[0]}_processed.{name_parts[1]}"
             else:
                 safe_filename = base_filename
 
@@ -115,7 +114,7 @@ class PdfStreamView(APIView):
             range_header = request.headers.get("Range")
             if range_header:
                 logger.debug(
-                    f"Range request for {file_type} PDF {pdf_id}: {range_header}"
+                    f"Range request for {file_type} PDF {pk}: {range_header}"
                 )
                 match = _RANGE_RE.match(range_header)
                 if match:
@@ -139,7 +138,7 @@ class PdfStreamView(APIView):
                         file_handle.seek(start)
 
                         logger.debug(
-                            f"Serving {file_type} PDF {pdf_id} range {start}-{end}/{file_size}"
+                            f"Serving {file_type} PDF {pk} range {start}-{end}/{file_size}"
                         )
 
                         response = StreamingHttpResponse(
@@ -164,7 +163,7 @@ class PdfStreamView(APIView):
                     logger.warning(f"Invalid Range header format: {range_header}")
 
             # Serve entire file using FileResponse (automatically handles file closing)
-            logger.debug(f"Serving full {file_type} PDF {pdf_id} ({file_size} bytes)")
+            logger.debug(f"Serving full {file_type} PDF {pk} ({file_size} bytes)")
 
             try:
                 file_handle = open(file_path, "rb")
@@ -181,7 +180,7 @@ class PdfStreamView(APIView):
 
         except Exception as e:
             logger.error(
-                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'PDF'} {pdf_id}: {e}",
+                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'PDF'} {pk}: {e}",
                 exc_info=True,
             )
             raise Http404("Error streaming PDF")