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

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/__init__.py

@@ -1,11 +1,8 @@
-from .pdf_media import (
-    PDFMediaView,
-    UpdateSensitiveMetaView,
-    ClosingFileWrapper
-)
+from .reimport import PdfReimportView
+from .pdf_stream import PdfStreamView
+
 
 __all__ = [
-    "PDFMediaView",
-    "UpdateSensitiveMetaView",
-    "ClosingFileWrapper",
+    "PdfReimportView",
+    "PdfStreamView",
 ]

endoreg_db/views/pdf/pdf_stream.py

@@ -0,0 +1,186 @@
+import logging
+import os
+import re
+
+from django.http import FileResponse, Http404, StreamingHttpResponse
+from django.views.decorators.clickjacking import xframe_options_exempt, xframe_options_sameorigin
+from rest_framework.views import APIView
+
+from endoreg_db.models import RawPdfFile
+
+from ...utils.permissions import EnvironmentAwarePermission
+
+logger = logging.getLogger(__name__)
+_RANGE_RE = re.compile(r"bytes=(\d+)-(\d*)")
+
+
+class ClosingFileWrapper:
+    """Custom file wrapper that ensures file is closed after streaming"""
+
+    def __init__(self, file_handle, blksize=8192):
+        self.file_handle = file_handle
+        self.blksize = blksize
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        data = self.file_handle.read(self.blksize)
+        if not data:
+            self.file_handle.close()
+            raise StopIteration
+        return data
+
+    def close(self):
+        if hasattr(self.file_handle, "close"):
+            self.file_handle.close()
+
+
+class PdfStreamView(APIView):
+    """
+    Streams a PDF file with correct HTTP range support and proper file handle management.
+
+    Supports streaming both raw (original) and processed PDF files.
+
+    Query Parameters:
+        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=processed - Stream processed PDF
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+    @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=pk).first()
+            if not pdf_obj:
+                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", "processed"]:
+                logger.warning(f"Invalid file_type '{file_type}', defaulting to 'raw'")
+                file_type = "raw"
+
+            # Determine which file field to use
+            if file_type == "raw":
+                file_field = pdf_obj.file
+                if not file_field:
+                    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 processed PDF file available for PDF ID {pk}"
+                    )
+                    raise Http404("Processed PDF file not available")
+
+            # Check if file exists on filesystem
+            try:
+                file_path = file_field.path
+                if not os.path.exists(file_path):
+                    logger.error(f"PDF file does not exist on filesystem: {file_path}")
+                    raise Http404(
+                        f"{file_type.capitalize()} PDF file not found on filesystem"
+                    )
+
+                file_size = os.path.getsize(file_path)
+            except (OSError, IOError, AttributeError) as 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_{pk}.pdf"
+            )
+            if not base_filename.endswith(".pdf"):
+                base_filename += ".pdf"
+
+            # Add type indicator to filename for clarity
+            if file_type == "processed":
+                name_parts = base_filename.rsplit(".", 1)
+                safe_filename = f"{name_parts[0]}_processed.{name_parts[1]}"
+            else:
+                safe_filename = base_filename
+
+            # Handle Range requests
+            range_header = request.headers.get("Range")
+            if range_header:
+                logger.debug(
+                    f"Range request for {file_type} PDF {pk}: {range_header}"
+                )
+                match = _RANGE_RE.match(range_header)
+                if match:
+                    start = int(match.group(1))
+                    end = int(match.group(2) or file_size - 1)
+
+                    # Validate range
+                    if start >= file_size or start < 0:
+                        logger.warning(
+                            f"Invalid range start {start} for file size {file_size}"
+                        )
+                        raise Http404("Invalid range")
+
+                    if end >= file_size:
+                        end = file_size - 1
+
+                    chunk_size = end - start + 1
+
+                    try:
+                        file_handle = open(file_path, "rb")
+                        file_handle.seek(start)
+
+                        logger.debug(
+                            f"Serving {file_type} PDF {pk} range {start}-{end}/{file_size}"
+                        )
+
+                        response = StreamingHttpResponse(
+                            ClosingFileWrapper(file_handle, blksize=8192),
+                            status=206,
+                            content_type="application/pdf",
+                        )
+                        response["Content-Length"] = str(chunk_size)
+                        response["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+                        response["Accept-Ranges"] = "bytes"
+                        response["Content-Disposition"] = (
+                            f'inline; filename="{safe_filename}"'
+                        )
+
+                        return response
+                    except (OSError, IOError) as e:
+                        logger.error(
+                            f"Error opening {file_type} PDF file for range request: {e}"
+                        )
+                        raise Http404(f"Error accessing {file_type} PDF file")
+                else:
+                    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 {pk} ({file_size} bytes)")
+
+            try:
+                file_handle = open(file_path, "rb")
+                response = FileResponse(file_handle, content_type="application/pdf")
+                response["Content-Length"] = str(file_size)
+                response["Accept-Ranges"] = "bytes"
+                response["Content-Disposition"] = f'inline; filename="{safe_filename}"'
+
+                # FileResponse will take ownership of file_handle and close it after response
+                return response
+            except (OSError, IOError) as e:
+                logger.error(f"Error opening {file_type} PDF file: {e}")
+                raise Http404(f"Error accessing {file_type} PDF file")
+
+        except Exception as e:
+            logger.error(
+                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'PDF'} {pk}: {e}",
+                exc_info=True,
+            )
+            raise Http404("Error streaming PDF")

endoreg_db/views/pdf/pdf_stream_views.py

@@ -1,127 +0,0 @@
-import re
-import logging
-from django.http import FileResponse, StreamingHttpResponse, Http404
-from rest_framework.views import APIView
-from ...utils.permissions import EnvironmentAwarePermission
-from endoreg_db.models import RawPdfFile
-import os
-from django.views.decorators.clickjacking import xframe_options_sameorigin
-
-logger = logging.getLogger(__name__)
-_RANGE_RE = re.compile(r"bytes=(\d+)-(\d*)")
-
-class ClosingFileWrapper:
-    """Custom file wrapper that ensures file is closed after streaming"""
-    def __init__(self, file_handle, blksize=8192):
-        self.file_handle = file_handle
-        self.blksize = blksize
-        
-    def __iter__(self):
-        return self
-        
-    def __next__(self):
-        data = self.file_handle.read(self.blksize)
-        if not data:
-            self.file_handle.close()
-            raise StopIteration
-        return data
-        
-    def close(self):
-        if hasattr(self.file_handle, 'close'):
-            self.file_handle.close()
-            
-class PDFStreamView(APIView):
-    """
-    Streams a PDF file with correct HTTP range support and proper file handle management.
-    """
-    permission_classes = [EnvironmentAwarePermission]
-
-    @xframe_options_sameorigin
-    def get(self, request, pdf_id: int, *args, **kwargs):
-        try:
-            pdf_obj = RawPdfFile.objects.filter(pk=pdf_id).first()
-            if not pdf_obj or not pdf_obj.file:
-                logger.warning(f"PDF not found: ID {pdf_id}")
-                raise Http404("PDF not found")
-
-            # Check if file exists on filesystem
-            try:
-                file_path = pdf_obj.file.path
-                if not os.path.exists(file_path):
-                    logger.error(f"PDF file does not exist on filesystem: {file_path}")
-                    raise Http404("PDF file not found on filesystem")
-                    
-                file_size = os.path.getsize(file_path)
-            except (OSError, IOError, AttributeError) as e:
-                logger.error(f"Error accessing PDF file {pdf_id}: {e}")
-                raise Http404("PDF file not accessible")
-
-            # Generate safe filename
-            safe_filename = os.path.basename(pdf_obj.file.name) if pdf_obj.file.name else f"document_{pdf_id}.pdf"
-            if not safe_filename.endswith('.pdf'):
-                safe_filename += '.pdf'
-
-            # Handle Range requests
-            range_header = request.headers.get("Range")
-            if range_header:
-                logger.debug(f"Range request for PDF {pdf_id}: {range_header}")
-                match = _RANGE_RE.match(range_header)
-                if match:
-                    start = int(match.group(1))
-                    end = int(match.group(2) or file_size - 1)
-                    
-                    # Validate range
-                    if start >= file_size or start < 0:
-                        logger.warning(f"Invalid range start {start} for file size {file_size}")
-                        raise Http404("Invalid range")
-                        
-                    if end >= file_size:
-                        end = file_size - 1
-                    
-                    chunk_size = end - start + 1
-                    
-                    try:
-                        file_handle = open(file_path, "rb")
-                        file_handle.seek(start)
-                        
-                        logger.debug(f"Serving PDF {pdf_id} range {start}-{end}/{file_size}")
-                        
-                        response = StreamingHttpResponse(
-                            ClosingFileWrapper(file_handle, blksize=8192),
-                            status=206,
-                            content_type="application/pdf",
-                        )
-                        response["Content-Length"] = str(chunk_size)
-                        response["Content-Range"] = f"bytes {start}-{end}/{file_size}"
-                        response["Accept-Ranges"] = "bytes"
-                        response["Content-Disposition"] = f'inline; filename="{safe_filename}"'
-                        
-                        return response
-                    except (OSError, IOError) as e:
-                        logger.error(f"Error opening PDF file for range request: {e}")
-                        raise Http404("Error accessing PDF file")
-                else:
-                    logger.warning(f"Invalid Range header format: {range_header}")
-
-            # Serve entire file using FileResponse (automatically handles file closing)
-            logger.debug(f"Serving full PDF {pdf_id} ({file_size} bytes)")
-            
-            try:
-                file_handle = open(file_path, "rb")
-                response = FileResponse(
-                    file_handle, 
-                    content_type="application/pdf"
-                )
-                response["Content-Length"] = str(file_size)
-                response["Accept-Ranges"] = "bytes"
-                response["Content-Disposition"] = f'inline; filename="{safe_filename}"'
-                
-                # FileResponse will take ownership of file_handle and close it after response
-                return response
-            except (OSError, IOError) as e:
-                logger.error(f"Error opening PDF file: {e}")
-                raise Http404("Error accessing PDF file")
-
-        except Exception as e:
-            logger.error(f"Unexpected error streaming PDF {pdf_id}: {e}", exc_info=True)
-            raise Http404("Error streaming PDF")