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

endoreg_db/views/media/pdf_media.py

@@ -1,7 +1,7 @@
 """
-PDF Media Management View (Phase 1.2)
+report Media Management View (Phase 1.2)
 
-Provides standardized REST API for PDF files including listing, detail retrieval,
+Provides standardized REST API for report files including listing, detail retrieval,
 and streaming for the media management system.
 
 This is separate from the existing pdf.PDFMediaView which handles legacy workflows.
@@ -9,67 +9,71 @@ This is separate from the existing pdf.PDFMediaView which handles legacy workflo
 
 import logging
 import os
-from django.http import Http404, FileResponse
+from pathlib import Path
+
+from django.db.models import Q
+from django.http import FileResponse, Http404
+from django.views.decorators.clickjacking import xframe_options_exempt
 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
+from endoreg_db.utils.storage import file_exists
 
 logger = logging.getLogger(__name__)
 
 
 class PdfMediaView(APIView):
     """
-    PDF Media Management API for CRUD operations on PDF files.
-    
+    report Media Management API for CRUD operations on report 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)
-    
+    - GET /api/media/pdfs/{id}/ - Get report details
+    - GET /api/media/pdfs/{id}/stream/ - Stream report file (same as detail for PDFs)
+    - PATCH /api/media/pdfs/{id}/ - Update report metadata (future)
+    - DELETE /api/media/pdfs/{id}/ - Delete report (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
+    - report 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.
-        
+        Handle GET requests for report listing, detail retrieval, or streaming.
+
         Args:
             request: HTTP request object
-            pk: Optional PDF ID for detail view or streaming
-            
+            pk: Optional report ID for detail view or streaming
+
         Returns:
-            Response or FileResponse: JSON response with PDF data or PDF file stream
-            
+            Response or FileResponse: JSON response with report data or report file stream
+
         Raises:
-            Http404: If specific PDF not found
+            Http404: If specific report not found
         """
         if pk is not None:
             # Check if this is a streaming request
-            if request.path.endswith('/stream/'):
+            if request.path.endswith("/stream/"):
                 return self._stream_pdf(pk)
             else:
                 # Detail view
@@ -80,174 +84,190 @@ class PdfMediaView(APIView):
 
     def _get_pdf_detail(self, pk):
         """
-        Get detailed information for a specific PDF.
-        
+        Get detailed information for a specific report.
+
         Args:
-            pk: PDF primary key
-            
+            pk: report primary key
+
         Returns:
-            Response: JSON response with PDF details
-            
+            Response: JSON response with report details
+
         Raises:
-            Http404: If PDF not found
+            Http404: If report 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
+                raise Http404("Invalid report ID format")
+
+            # Fetch report with related data
+            pdf = RawPdfFile.objects.select_related("sensitive_meta").get(pk=pdf_id_int)
+
+            # Build report details
             pdf_data = {
-                "id": pdf.id,
-                "filename": getattr(pdf.file, 'name', 'Unknown'),
-                "file_size": getattr(pdf.file, 'size', 0),
+                "id": pdf.pk,
+                "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,
+                "uploaded_at": pdf.date_created.isoformat()
+                if getattr(pdf, "date_created", None)
+                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/"),
+                "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.pk}/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,
-                })
-            
+                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")
-            
+            raise Http404(f"report with ID {pk} not found")
+
         except Exception as e:
-            logger.error(f"Unexpected error in PDF detail view for ID {pk}: {str(e)}")
+            logger.error(
+                f"Unexpected error in report detail view for ID {pk}: {str(e)}"
+            )
             return Response(
-                {"error": "Failed to retrieve PDF details"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": "Failed to retrieve report details"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
-            
+
     @xframe_options_exempt
     def _stream_pdf(self, pk):
         """
-        Stream PDF file content for viewing/download.
-        
+        Stream report file content for viewing/download.
+
         Args:
-            pk: PDF primary key
-            
+            pk: report primary key
+
         Returns:
-            FileResponse: PDF file stream
-            
+            FileResponse: report file stream
+
         Raises:
-            Http404: If PDF not found or file cannot be accessed
+            Http404: If report 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
+                raise Http404("Invalid report ID format")
+
+            # Fetch report
             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
+
+            file_field = pdf.file
+            file_path = file_field.path
+
+            if not file_field or not file_field.name:
+                raise Http404("report file not found")
+            if not file_exists(file_field):
+                raise Http404("report file does not exist in storage")
+
+            with open(file_path, "rb") as file_handle:
                 response = FileResponse(
-                    open(file_path, 'rb'),
-                    content_type='application/pdf',
-                    as_attachment=False  # View in browser, not download
+                    file_handle,
+                    content_type="application/pdf",
+                    as_attachment=False,
                 )
-                
-                # 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")
-                
+
+            filename = Path(file_field.name).name
+            response["Content-Disposition"] = f'inline; filename="{filename}"'
+
+            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 RawPdfFile.DoesNotExist:
-            raise Http404(f"PDF with ID {pk} not found")
-            
+            raise Http404(f"report 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")
+            logger.error(f"Unexpected error in report streaming for ID {pk}: {str(e)}")
+            raise Http404("report 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
+            Response: JSON response with paginated report list
         """
         try:
             # Start with all PDFs
-            queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
-            
+            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()
+            search = request.query_params.get("search", "").strip()
             if search:
-                queryset = queryset.filter(
-                    Q(file__icontains=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')
+            if hasattr(queryset.model, "date_created"):
+                queryset = queryset.order_by("-date_created")
             else:
-                queryset = queryset.order_by('-id')
-            
+                queryset = queryset.order_by("-pk")
+
             # 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()
-            pdfs = queryset[offset:offset + limit]
-            
+            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'),
+                    "id": pdf.pk,
+                    "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/"),
+                    "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.pk}/stream/"
+                    ),
                 }
-                
+
                 # Determine status based on anonymization and validation
                 if not pdf.anonymized_text or not pdf.anonymized_text.strip():
                     pdf_item["status"] = "not_started"
@@ -255,42 +275,44 @@ class PdfMediaView(APIView):
                     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
-            })
-            
+
+            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
+                status=status.HTTP_400_BAD_REQUEST,
             )
-            
+
         except Exception as e:
-            logger.error(f"Unexpected error in PDF list view: {str(e)}")
+            logger.error(f"Unexpected error in report list view: {str(e)}")
             return Response(
-                {"error": "Failed to retrieve PDF list"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": "Failed to retrieve report 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):
@@ -299,45 +321,46 @@ class PdfMediaView(APIView):
 
     def _apply_filters(self, queryset, query_params):
         """
-        Apply status and other filters to PDF queryset.
-        
+        Apply status and other filters to report 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":
                 # PDFs without anonymized text
                 queryset = queryset.filter(
-                    Q(anonymized_text__isnull=True) | Q(anonymized_text__exact='')
+                    Q(anonymized_text__isnull=True) | Q(anonymized_text__exact="")
                 )
-            elif status_filter == 'done':
+            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)
+                    ~Q(anonymized_text__exact=""),
+                    Q(sensitive_meta__is_verified=False)
+                    | Q(sensitive_meta__isnull=True),
                 )
-            elif status_filter == 'validated':
+            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
+                    ~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)
 
@@ -345,16 +368,16 @@ class PdfMediaView(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()}"
@@ -363,26 +386,26 @@ class PdfMediaView(APIView):
     # Future implementation placeholders
     def patch(self, request, pk):
         """
-        Update PDF metadata (Phase 1.2+ future enhancement).
-        
+        Update report 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
+            {"error": "report metadata updates not yet implemented"},
+            status=status.HTTP_501_NOT_IMPLEMENTED,
         )
 
     def delete(self, request, pk):
         """
-        Delete PDF file (Phase 1.2+ future enhancement).
-        
+        Delete report 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"
+                "error": "report 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,
         )