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

endoreg_db/views/misc/upload_views.py

@@ -1,64 +1,66 @@
 import mimetypes
+
 from django.http import Http404
 from django.urls import reverse
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
 from rest_framework import status
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.parsers import MultiPartParser, FormParser
+from rest_framework.parsers import FormParser, MultiPartParser
 from rest_framework.permissions import AllowAny
-from django.views.decorators.csrf import csrf_exempt
-from django.utils.decorators import method_decorator
+from rest_framework.response import Response
+from rest_framework.views import APIView
 
 # Try to import python-magic, but provide fallback if not available
 try:
     import magic
+
     MAGIC_AVAILABLE = True
 except ImportError:
     MAGIC_AVAILABLE = False
 
 from endoreg_db.models.upload_job import UploadJob
-from endoreg_db.serializers.misc.upload_job import (
-    UploadJobStatusSerializer,
-)
+from endoreg_db.serializers.misc.upload_job import UploadJobStatusSerializer
 
 # Try to import celery task, but provide fallback
 try:
     from endoreg_db.tasks.upload_tasks import process_upload_job
+
     CELERY_AVAILABLE = True
 except ImportError:
     CELERY_AVAILABLE = False
+
     # Define a dummy function for development
     def process_upload_job(job_id):
         pass
 
 
-@method_decorator(csrf_exempt, name='dispatch')
+@method_decorator(csrf_exempt, name="dispatch")
 class UploadFileView(APIView):
     """
     Handle file uploads (POST /api/upload/).
-    
-    Accepts multipart/form-data with a 'file' field containing PDF or video files.
+
+    Accepts multipart/form-data with a 'file' field containing report or video files.
     Creates an UploadJob and starts asynchronous processing.
-    
+
     Returns:
         201 Created: {"upload_id": "<uuid>", "status_url": "/api/upload/<uuid>/status/"}
         400 Bad Request: File validation errors
     """
-    
+
     parser_classes = [MultiPartParser, FormParser]
     permission_classes = [AllowAny]  # Adjust based on your auth requirements
-    
+
     # Maximum file size (1 GiB)
     MAX_FILE_SIZE = 1024 * 1024 * 1024  # 1 GiB in bytes
-    
+
     # Allowed MIME types
     ALLOWED_MIME_TYPES = {
-        'application/pdf',
-        'video/mp4',
-        'video/avi', 
-        'video/quicktime',
-        'video/x-msvideo',
-        'video/x-ms-wmv'
+        "application/pdf",
+        "video/mp4",
+        "video/avi",
+        "video/quicktime",
+        "video/x-msvideo",
+        "video/x-ms-wmv",
     }
 
     def post(self, request, *args, **kwargs):
@@ -66,93 +68,95 @@ class UploadFileView(APIView):
         Handle file upload and create processing job.
         """
         # Validate file presence
-        if 'file' not in request.FILES:
+        if "file" not in request.FILES:
             return Response(
-                {'error': 'No file provided. Please include a file in the "file" field.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": 'No file provided. Please include a file in the "file" field.'
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
-        uploaded_file = request.FILES['file']
-        
+
+        uploaded_file = request.FILES["file"]
+
         # Validate file is not empty
         if not uploaded_file or uploaded_file.size == 0:
             return Response(
-                {'error': 'Uploaded file is empty. Please select a valid file.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Uploaded file is empty. Please select a valid file."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Validate file size
         if uploaded_file.size > self.MAX_FILE_SIZE:
             return Response(
-                {'error': f'File too large. Maximum size is {self.MAX_FILE_SIZE // (1024**3)} GB.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": f"File too large. Maximum size is {self.MAX_FILE_SIZE // (1024**3)} GB."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Validate filename
-        if not uploaded_file.name or uploaded_file.name.strip() == '':
+        if not uploaded_file.name or uploaded_file.name.strip() == "":
             return Response(
-                {'error': 'Invalid filename. Please ensure the file has a valid name.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Invalid filename. Please ensure the file has a valid name."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Detect MIME type
         try:
             content_type = self._detect_mime_type(uploaded_file)
         except Exception as e:
             return Response(
-                {'error': f'Could not determine file type: {str(e)}'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": f"Could not determine file type: {str(e)}"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Validate MIME type
         if content_type not in self.ALLOWED_MIME_TYPES:
             return Response(
-                {'error': f'Unsupported file type: {content_type}. Allowed types: PDF, MP4, AVI, MOV, WMV.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": f"Unsupported file type: {content_type}. Allowed types: report, MP4, AVI, MOV, WMV."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         try:
             # Create upload job
             upload_job = UploadJob.objects.create(
-                file=uploaded_file,
-                content_type=content_type
+                file=uploaded_file, content_type=content_type
             )
-            
+
             # Start asynchronous processing if Celery is available
             if CELERY_AVAILABLE:
                 try:
                     process_upload_job.delay(str(upload_job.id))
                 except Exception as e:
                     # If Celery task fails to start, mark job as failed
-                    upload_job.mark_failed(f'Failed to start processing: {str(e)}')
+                    upload_job.mark_failed(f"Failed to start processing: {str(e)}")
                     return Response(
-                        {'error': f'Failed to start processing: {str(e)}'},
-                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                        {"error": f"Failed to start processing: {str(e)}"},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                     )
             else:
                 # For development without Celery, mark as processing immediately
                 upload_job.mark_processing()
                 # In production, this would be handled by Celery
                 # For now, just leave it in processing state
-            
+
             # Prepare response
-            status_url = reverse('upload_status', kwargs={'id': upload_job.id})
+            status_url = reverse("upload_status", kwargs={"id": upload_job.id})
             response_data = {
-                'upload_id': str(upload_job.id),  # Ensure UUID is converted to string
-                'status_url': status_url,
-                'message': 'Upload job created successfully'
+                "upload_id": str(upload_job.id),  # Ensure UUID is converted to string
+                "status_url": status_url,
+                "message": "Upload job created successfully",
             }
-            
+
             # Return the response data directly since serializer fields are read-only
-            return Response(
-                response_data,
-                status=status.HTTP_201_CREATED
-            )
-            
+            return Response(response_data, status=status.HTTP_201_CREATED)
+
         except Exception as e:
             return Response(
-                {'error': f'Failed to create upload job: {str(e)}'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": f"Failed to create upload job: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
     def _detect_mime_type(self, uploaded_file) -> str:
@@ -163,39 +167,39 @@ class UploadFileView(APIView):
         try:
             # Reset file pointer
             uploaded_file.seek(0)
-            
+
             # Try python-magic first (more reliable) if available
             if MAGIC_AVAILABLE:
                 try:
                     # Read first chunk for magic detection
                     chunk = uploaded_file.read(2048)
                     uploaded_file.seek(0)  # Reset again
-                    
+
                     mime_type = magic.from_buffer(chunk, mime=True)
-                    if mime_type and mime_type != 'application/octet-stream':
+                    if mime_type and mime_type != "application/octet-stream":
                         return mime_type
                 except Exception:
                     pass  # Fall back to mimetypes
-            
+
             # Fallback to mimetypes module
             mime_type, _ = mimetypes.guess_type(uploaded_file.name)
             if mime_type:
                 return mime_type
-            
+
             # Last resort - check file extension
-            if uploaded_file.name.lower().endswith('.pdf'):
-                return 'application/pdf'
-            elif uploaded_file.name.lower().endswith(('.mp4', '.m4v')):
-                return 'video/mp4'
-            elif uploaded_file.name.lower().endswith('.avi'):
-                return 'video/avi'
-            elif uploaded_file.name.lower().endswith(('.mov', '.qt')):
-                return 'video/quicktime'
-            elif uploaded_file.name.lower().endswith('.wmv'):
-                return 'video/x-ms-wmv'
-            
+            if uploaded_file.name.lower().endswith(".pdf"):
+                return "application/pdf"
+            elif uploaded_file.name.lower().endswith((".mp4", ".m4v")):
+                return "video/mp4"
+            elif uploaded_file.name.lower().endswith(".avi"):
+                return "video/avi"
+            elif uploaded_file.name.lower().endswith((".mov", ".qt")):
+                return "video/quicktime"
+            elif uploaded_file.name.lower().endswith(".wmv"):
+                return "video/x-ms-wmv"
+
             raise ValueError("Could not determine file type")
-            
+
         finally:
             # Ensure file pointer is reset
             uploaded_file.seek(0)
@@ -204,15 +208,15 @@ class UploadFileView(APIView):
 class UploadStatusView(APIView):
     """
     Get upload job status (GET /api/upload/<uuid>/status/).
-    
+
     Returns current processing status and relevant metadata.
     Should be polled every 2 seconds by the frontend.
-    
+
     Returns:
         200 OK: Status information
         404 Not Found: Upload job not found
     """
-    
+
     permission_classes = [AllowAny]  # Adjust based on your auth requirements
 
     def get(self, request, id, *args, **kwargs):
@@ -221,20 +225,17 @@ class UploadStatusView(APIView):
         """
         try:
             # Look up upload job by UUID
-            upload_job = UploadJob.objects.select_related('sensitive_meta').get(id=id)
-            
+            upload_job = UploadJob.objects.select_related("sensitive_meta").get(id=id)
+
             # Serialize the response
             serializer = UploadJobStatusSerializer(upload_job)
-            
-            return Response(
-                serializer.data,
-                status=status.HTTP_200_OK
-            )
-            
+
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
         except UploadJob.DoesNotExist:
             raise Http404("Upload job not found")
         except Exception as e:
             return Response(
-                {'error': f'Failed to get upload status: {str(e)}'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
+                {"error": f"Failed to get upload status: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

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

@@ -1,9 +1,7 @@
-from .report_list import ReportListView
-from .report_with_secure_url import ReportWithSecureUrlView
-from .start_examination import start_examination
+from .reimport import ReportReimportView
+from .report_stream import ReportStreamView
 
 __all__ = [
-    "ReportListView",
-    "ReportWithSecureUrlView",
-    "start_examination",
-]
+    "ReportReimportView",
+    "ReportStreamView",
+]

endoreg_db/views/{pdf → report}/reimport.py

@@ -6,12 +6,12 @@ from rest_framework.response import Response
 from rest_framework.views import APIView
 
 from ...models import RawPdfFile, SensitiveMeta
-from ...services.pdf_import import PdfImportService
+from endoreg_db.services.report_import import ReportImportService
 
 logger = logging.getLogger(__name__)
 
 
-class PdfReimportView(APIView):
+class  ReportReimportView(APIView):
     """
     API endpoint to re-import a pdf file and regenerate metadata.
     This is useful when OCR failed or metadata is incomplete.
@@ -19,7 +19,7 @@ class PdfReimportView(APIView):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.pdf_service = PdfImportService()
+        self.pdf_service = ReportImportService()
 
     def post(self, request, pk):
         """
@@ -28,24 +28,24 @@ class PdfReimportView(APIView):
 
         Args:
             request: HTTP request object
-            pk: PDF primary key (ID)
+            pk: report primary key (ID)
         """
         pdf_id = pk  # Align with media framework naming convention
 
         # Validate pdf_id parameter
         if not pdf_id or not isinstance(pdf_id, int):
             return Response(
-                {"error": "Invalid PDF ID provided."},
+                {"error": "Invalid report ID provided."},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
             pdf = RawPdfFile.objects.get(id=pdf_id)
-            logger.info(f"Found PDF {pdf.pdf_hash} (ID: {pdf_id}) for re-import")
+            logger.info(f"Found report {pdf.pdf_hash} (ID: {pdf_id}) for re-import")
         except RawPdfFile.DoesNotExist:
-            logger.warning(f"PDF with ID {pdf_id} not found")
+            logger.warning(f"report with ID {pdf_id} not found")
             return Response(
-                {"error": f"PDF with ID {pdf_id} not found."},
+                {"error": f"report with ID {pdf_id} not found."},
                 status=status.HTTP_404_NOT_FOUND,
             )
 
@@ -54,25 +54,25 @@ class PdfReimportView(APIView):
 
         if not raw_file_path or not raw_file_path.exists():
             logger.error(
-                f"Raw PDF file not found for hash {pdf.pdf_hash}: {raw_file_path}"
+                f"Raw report file not found for hash {pdf.pdf_hash}: {raw_file_path}"
             )
             return Response(
                 {
-                    "error": f"Raw PDF file not found for PDF {pdf.pdf_hash}. Please upload the original file again."
+                    "error": f"Raw report file not found for report {pdf.pdf_hash}. Please upload the original file again."
                 },
                 status=status.HTTP_404_NOT_FOUND,
             )
 
-        # Check if PDF has required relationships
+        # Check if report has required relationships
         if not pdf.center:
-            logger.warning(f"PDF {pdf.pdf_hash} has no associated center")
+            logger.warning(f"report {pdf.pdf_hash} has no associated center")
             return Response(
-                {"error": "PDF has no associated center."},
+                {"error": "report has no associated center."},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
-            logger.info(f"Starting re-import for PDF {pdf.pdf_hash} (ID: {pdf_id})")
+            logger.info(f"Starting re-import for report {pdf.pdf_hash} (ID: {pdf_id})")
 
             with transaction.atomic():
                 # Clear existing metadata to force regeneration
@@ -80,9 +80,9 @@ class PdfReimportView(APIView):
                 if pdf.sensitive_meta:
                     old_meta_id = pdf.sensitive_meta.pk
                     logger.info(
-                        f"Clearing existing SensitiveMeta {old_meta_id} for PDF {pdf.pdf_hash}"
+                        f"Clearing existing SensitiveMeta {old_meta_id} for report {pdf.pdf_hash}"
                     )
-                    pdf.sensitive_meta = None  # type: ignore
+                    pdf.sensitive_meta = None
                     pdf.save(update_fields=["sensitive_meta"])
 
                     # Delete the old SensitiveMeta record
@@ -94,10 +94,10 @@ class PdfReimportView(APIView):
                             f"Could not delete old SensitiveMeta {old_meta_id}: {e}"
                         )
 
-                # Use PdfImportService for reprocessing
+                # Use ReportImportService for reprocessing
                 try:
                     logger.info(
-                        f"Starting reprocessing using PdfImportService for {pdf.pdf_hash}"
+                        f"Starting reprocessing using ReportImportService for {pdf.pdf_hash}"
                     )
                     self.pdf_service.import_and_anonymize(
                         file_path=raw_file_path,
@@ -107,7 +107,7 @@ class PdfReimportView(APIView):
                     )
 
                     logger.info(
-                        f"PdfImportService reprocessing completed for {pdf.pdf_hash}"
+                        f"ReportImportService reprocessing completed for {pdf.pdf_hash}"
                     )
 
                     # Refresh to get updated state
@@ -115,7 +115,7 @@ class PdfReimportView(APIView):
 
                     return Response(
                         {
-                            "message": "PDF re-import completed successfully.",
+                            "message": "report re-import completed successfully.",
                             "pdf_id": pdf_id,
                             "pdf_hash": str(pdf.pdf_hash),
                             "sensitive_meta_created": pdf.sensitive_meta is not None,
@@ -131,7 +131,7 @@ class PdfReimportView(APIView):
 
                 except Exception as e:
                     logger.exception(
-                        f"PdfImportService reprocessing failed for PDF {pdf.pdf_hash}: {e}"
+                        f"ReportImportService reprocessing failed for report {pdf.pdf_hash}: {e}"
                     )
                     return Response(
                         {
@@ -145,7 +145,7 @@ class PdfReimportView(APIView):
 
         except Exception as e:
             logger.error(
-                f"Failed to re-import PDF {pdf.pdf_hash}: {str(e)}", exc_info=True
+                f"Failed to re-import report {pdf.pdf_hash}: {str(e)}", exc_info=True
             )
 
             # Handle specific error types