endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/views/pdf/pdf_media.py

@@ -0,0 +1,239 @@
+from django.http import FileResponse, Http404, StreamingHttpResponse
+import mimetypes
+import os
+import logging
+import re
+from ...models import RawPdfFile
+from ...serializers._old.raw_pdf_meta_validation import PDFFileForMetaSerializer, SensitiveMetaUpdateSerializer
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from ...models import SensitiveMeta
+from django.views.decorators.clickjacking import xframe_options_sameorigin
+from django.utils.decorators import method_decorator
+from django.db import transaction
+from django.urls import reverse
+from django.utils.encoding import iri_to_uri
+from endoreg_db.utils.paths import PDF_DIR, STORAGE_DIR
+from .pdf_stream_views import ClosingFileWrapper
+
+logger = logging.getLogger(__name__)
+_RANGE_RE = re.compile(r"bytes=(\d+)-(\d*)")
+
+class PDFMediaView(APIView):
+    """
+    Unified API for PDFs to support frontend flows:
+    - Without `id`: returns next PDF metadata (including anonymized_text) and stream URLs
+    - With `id`: streams the PDF (original by default; `?variant=anonymized` for anonymized)
+    - Integrates with Media Management expectations (clean deletion after validation is handled elsewhere)
+    """
+
+    def get(self, request):
+        """
+        Handles both:
+        - Fetching PDF metadata (if `id` is NOT provided)
+        - Streaming the actual PDF file (if `id` is provided)
+        """
+        pdf_id = request.GET.get("id")
+        last_id = request.GET.get("last_id")
+
+        if pdf_id:
+            return self.serve_pdf_file(pdf_id)
+        else:
+            return self.fetch_pdf_metadata(last_id)
+
+    def fetch_pdf_metadata(self, last_id):
+        """
+        Fetches the first or next available PDF metadata and provides stream URLs.
+        """
+        pdf_entry = PDFFileForMetaSerializer.get_next_pdf(last_id)
+        if pdf_entry is None:
+            return Response({"error": "No more PDFs available."}, status=status.HTTP_404_NOT_FOUND)
+
+        serialized_pdf = PDFFileForMetaSerializer(pdf_entry, context={'request': self.request})
+
+        # Build stream URLs pointing to this unified endpoint
+        try:
+            media_url = reverse('pdf_media')
+        except Exception:
+            media_url = "/api/pdf/media/"
+        stream_url = f"{media_url}?id={pdf_entry.id}"
+        anon_stream_url = f"{media_url}?id={pdf_entry.id}&variant=anonymized"
+
+        data = dict(serialized_pdf.data)
+        data.update({
+            'stream_url': iri_to_uri(self.request.build_absolute_uri(stream_url)),
+            'anonymized_stream_url': iri_to_uri(self.request.build_absolute_uri(anon_stream_url)),
+            'pdf_id': pdf_entry.id,
+            'has_anonymized': bool(getattr(pdf_entry, 'anonymized_file', None) and getattr(pdf_entry.anonymized_file, 'name', None)),
+        })
+        return Response(data, status=status.HTTP_200_OK)
+
+    @method_decorator(xframe_options_sameorigin)
+    def serve_pdf_file(self, pdf_id):
+        """
+        Streams the actual PDF file (original or anonymized) with Range support.
+        Query param `variant=anonymized` selects anonymized file; default is original.
+        """
+        variant = (self.request.GET.get('variant') or 'original').lower()
+        range_header = self.request.headers.get("Range")
+
+        try:
+            pdf_entry = RawPdfFile.objects.get(id=pdf_id)
+        except RawPdfFile.DoesNotExist:
+            return Response({"error": "Invalid PDF ID."}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Choose file according to variant
+        file_field = None
+        if variant == 'anonymized' and getattr(pdf_entry, 'anonymized_file', None):
+            file_field = pdf_entry.anonymized_file
+        else:
+            file_field = pdf_entry.file
+
+        if not file_field:
+            return Response({"error": "PDF file not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        # Resolve path and attempt self-heal for originals
+        try:
+            file_path = file_field.path
+        except Exception:
+            file_path = None
+
+        if not file_path or not os.path.exists(file_path):
+            if variant != 'anonymized':
+                # Try to self-heal original reference to sensitive storage
+                sensitive_path = os.path.join(str(PDF_DIR), "sensitive", f"{pdf_entry.pdf_hash}.pdf")
+                if os.path.exists(sensitive_path):
+                    try:
+                        relative_name = os.path.relpath(sensitive_path, str(STORAGE_DIR))
+                        if getattr(pdf_entry.file, 'name', None) != relative_name:
+                            pdf_entry.file.name = relative_name
+                            pdf_entry.save(update_fields=['file'])
+                            logger.info("Self-healed PDF file reference for ID %s -> %s", pdf_entry.id, pdf_entry.file.path)
+                        file_path = sensitive_path
+                    except Exception as e:
+                        logger.error("Failed to self-heal file path for PDF %s: %s", pdf_entry.id, e)
+                        file_path = sensitive_path
+            # If still missing (or anonymized missing), fail
+        if not file_path or not os.path.exists(file_path):
+            raise Http404("PDF file not found on server.")
+
+        # Prepare headers
+        safe_filename = os.path.basename(getattr(file_field, 'name', None) or f"document_{pdf_id}.pdf")
+        if not safe_filename.endswith('.pdf'):
+            safe_filename += '.pdf'
+
+        file_size = os.path.getsize(file_path)
+
+        # Range support
+        if range_header:
+            match = _RANGE_RE.match(range_header)
+            if match:
+                start = int(match.group(1))
+                end = int(match.group(2) or file_size - 1)
+
+                if start < 0 or start >= file_size:
+                    raise Http404("Invalid range")
+                if end >= file_size:
+                    end = file_size - 1
+
+                chunk_size = end - start + 1
+                try:
+                    fh = open(file_path, 'rb')
+                    fh.seek(start)
+                    resp = StreamingHttpResponse(
+                        ClosingFileWrapper(fh, blksize=8192),
+                        status=206,
+                        content_type="application/pdf",
+                    )
+                    resp["Content-Length"] = str(chunk_size)
+                    resp["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+                    resp["Accept-Ranges"] = "bytes"
+                    resp["Content-Disposition"] = f'inline; filename="{safe_filename}"'
+                    return resp
+                except (OSError, IOError) as e:
+                    logger.error(f"Error opening PDF file for range request: {e}")
+                    raise Http404("Error accessing PDF file")
+
+        # Fallback: serve full file
+        mime_type, _ = mimetypes.guess_type(file_path)
+        try:
+            fh = open(file_path, 'rb')
+            response = FileResponse(fh, content_type=mime_type or "application/pdf")
+            response["Content-Length"] = str(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: {e}")
+            raise Http404("Error accessing PDF file")
+
+class UpdateSensitiveMetaView(APIView):
+    """
+    API endpoint to update patient details in the SensitiveMeta table.
+    Handles partial updates (only edited fields) and raw file deletion after validation acceptance.
+    """
+
+    @transaction.atomic
+    def patch(self, request, *args, **kwargs):
+        """
+        Updates the provided fields for a specific patient record.
+        Only updates fields that are sent in the request.
+        Automatically deletes raw PDF files when validation is accepted.
+        """
+        sensitive_meta_id = request.data.get("sensitive_meta_id")
+
+        if not sensitive_meta_id:
+            return Response({"error": "sensitive_meta_id is required."}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            sensitive_meta = SensitiveMeta.objects.get(id=sensitive_meta_id)
+        except SensitiveMeta.DoesNotExist:
+            return Response({"error": "Patient record not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        is_accepting_validation = request.data.get("is_verified", False)
+        delete_raw_files = request.data.get("delete_raw_files", False)
+        if is_accepting_validation:
+            delete_raw_files = True
+            logger.info(f"Validation accepted for PDF SensitiveMeta {sensitive_meta_id}, marking raw files for deletion")
+
+        serializer = SensitiveMetaUpdateSerializer(sensitive_meta, data=request.data, partial=True)
+
+        if serializer.is_valid():
+            updated_sm = serializer.save()
+            if delete_raw_files and updated_sm.is_verified:
+                try:
+                    pdf_file = RawPdfFile.objects.filter(sensitive_meta=updated_sm).first()
+                    if pdf_file:
+                        self._schedule_raw_file_deletion(pdf_file)
+                        logger.info(f"Scheduled raw file deletion for PDF {pdf_file.id}")
+                    else:
+                        logger.warning(f"No PDF file found for SensitiveMeta {sensitive_meta_id}")
+                except Exception as e:
+                    logger.error(f"Error scheduling raw file deletion for PDF SensitiveMeta {sensitive_meta_id}: {e}")
+            return Response({"message": "Patient information updated successfully.", "updated_data": serializer.data}, status=status.HTTP_200_OK)
+
+        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+
+    def _schedule_raw_file_deletion(self, pdf_file):
+        """
+        Schedule deletion of raw PDF file after validation acceptance.
+        Deletes the original (sensitive) file but keeps anonymized_file for frontend.
+        """
+        try:
+            def cleanup_raw_files():
+                try:
+                    if pdf_file.file and getattr(pdf_file.file, 'path', None) and os.path.exists(pdf_file.file.path):
+                        logger.info(f"Deleting original (sensitive) PDF file: {pdf_file.file.path}")
+                        os.remove(pdf_file.file.path)
+                        pdf_file.file = None
+                        pdf_file.save(update_fields=['file'])
+                        logger.info(f"Successfully deleted original file for PDF {pdf_file.id}")
+                    else:
+                        logger.info(f"Original file already deleted or not found for PDF {pdf_file.id}")
+                except Exception as e:
+                    logger.error(f"Error during raw file cleanup for PDF {pdf_file.id}: {e}")
+            transaction.on_commit(cleanup_raw_files)
+        except Exception as e:
+            logger.error(f"Error scheduling raw file deletion for PDF {pdf_file.id}: {e}")
+            raise

endoreg_db/views/pdf/pdf_stream_views.py

@@ -0,0 +1,127 @@
+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")

endoreg_db/views/pdf/reimport.py

@@ -0,0 +1,161 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+import logging
+from pathlib import Path
+from django.db import transaction
+from ...models import RawPdfFile, SensitiveMeta
+from ...services.pdf_import import PdfImportService
+logger = logging.getLogger(__name__)
+
+class PdfReimportView(APIView):
+    """
+    API endpoint to re-import a pdf file and regenerate metadata.
+    This is useful when OCR failed or metadata is incomplete.
+    """
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.pdf_service = PdfImportService()
+
+    def post(self, request, pk):
+        """
+        Re-import a pdf file to regenerate SensitiveMeta and other metadata.
+        Instead of creating a new pdf, this updates the existing one.
+        
+        Args:
+            request: HTTP request object
+            pk: PDF 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."}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            pdf = RawPdfFile.objects.get(id=pdf_id)
+            logger.info(f"Found PDF {pdf.uuid} (ID: {pdf_id}) for re-import")
+        except RawPdfFile.DoesNotExist:
+            logger.warning(f"PDF with ID {pdf_id} not found")
+            return Response(
+                {"error": f"PDF with ID {pdf_id} not found."}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+
+
+        # Check if the raw file actually exists on disk
+        raw_file_path = Path(pdf.file.path)
+        if not raw_file_path.exists():
+            logger.error(f"Raw file not found on disk: {raw_file_path}")
+            return Response(
+                {"error": f"PDF file not found on server: {raw_file_path.name}"}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Check if PDF has required relationships
+        if not pdf.center:
+            logger.warning(f"PDF {pdf.uuid} has no associated center")
+            return Response(
+                {"error": "Video has no associated center."}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            logger.info(f"Starting in-place re-import for pdf {pdf.uuid} (ID: {pdf_id})")
+            
+            with transaction.atomic():
+                # Clear existing metadata to force regeneration
+                old_meta_id = None
+                if pdf.sensitive_meta:
+                    old_meta_id = pdf.sensitive_meta.id
+                    logger.info(f"Clearing existing SensitiveMeta {old_meta_id} for pdf {pdf.uuid}")
+                    pdf.sensitive_meta = None
+                    pdf.save(update_fields=['sensitive_meta'])
+                    
+                    # Delete the old SensitiveMeta record
+                    try:
+                        SensitiveMeta.objects.filter(id=old_meta_id).delete()
+                        logger.info(f"Deleted old SensitiveMeta {old_meta_id}")
+                    except Exception as e:
+                        logger.warning(f"Could not delete old SensitiveMeta {old_meta_id}: {e}")
+      
+                
+        
+                
+                
+                # Ensure minimum patient data is available
+                logger.info(f"Ensuring minimum patient data for {pdf.uuid}")
+                self.pdf_service._ensure_default_patient_data(pdf)
+                
+                # Refresh from database to get updated data
+                pdf.refresh_from_db()
+                
+                # Use VideoImportService for anonymization
+                try:
+                    
+                    logger.info(f"Starting anonymization using VideoImportService for {pdf.uuid}")
+                    self.pdf_service.import_and_anonymize(
+                        file_path=raw_file_path,
+                        center_name=pdf.center.name,
+                        processor_name=pdf.processor.name if pdf.processor else "Unknown",
+                        save_video=True,
+                        delete_source=False
+                    )
+                    
+                    logger.info(f"VideoImportService anonymization completed for {pdf.uuid}")
+                    
+                    
+                    return Response({
+                        "message": "Video re-import with VideoImportService completed successfully.",
+                        "pdf_id": pdf_id,
+                        "uuid": str(pdf.uuid),
+                        "frame_cleaning_applied": True,
+                        "sensitive_meta_created": pdf.sensitive_meta is not None,
+                        "sensitive_meta_id": pdf.sensitive_meta.id if pdf.sensitive_meta else None,
+                        "updated_in_place": True,
+                        "status": "done"
+                    }, status=status.HTTP_200_OK)
+                    
+                except Exception as e:
+                    logger.exception(f"VideoImportService anonymization failed for pdf {pdf.uuid}: {e}")
+                    logger.warning("Continuing without anonymization due to error")
+                
+            # Refresh from database to get final state
+            pdf.refresh_from_db()
+            
+            return Response({
+                "message": "PDF re-import completed successfully.",
+                "pdf_id": pdf_id,
+                "uuid": str(pdf.uuid),
+                "sensitive_meta_created": pdf.sensitive_meta is not None,
+                "sensitive_meta_id": pdf.sensitive_meta.id if pdf.sensitive_meta else None,
+                "updated_in_place": True,
+                "status": "done"
+            }, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            logger.error(f"Failed to re-import pdf {pdf.uuid}: {str(e)}", exc_info=True)
+            
+            # Handle specific error types
+            error_msg = str(e)
+            if any(phrase in error_msg.lower() for phrase in ["insufficient storage", "no space left", "disk full"]):
+                # Storage error - return specific error message
+                return Response({
+                    "error": f"Storage error during re-import: {error_msg}",
+                    "error_type": "storage_error",
+                    "pdf_id": pdf_id,
+                    "uuid": str(pdf.uuid)
+                }, status=status.HTTP_507_INSUFFICIENT_STORAGE)
+            else:
+                # Other errors
+                return Response({
+                    "error": f"Re-import failed: {error_msg}",
+                    "error_type": "processing_error", 
+                    "pdf_id": pdf_id,
+                    "uuid": str(pdf.uuid)
+                }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/report/__init__.py

@@ -0,0 +1,9 @@
+from .report_list import ReportListView
+from .report_with_secure_url import ReportWithSecureUrlView
+from .start_examination import start_examination
+
+__all__ = [
+    "ReportListView",
+    "ReportWithSecureUrlView",
+    "start_examination",
+]

endoreg_db/views/report/report_list.py

@@ -0,0 +1,112 @@
+from endoreg_db.models import RawPdfFile
+from endoreg_db.serializers.report.report_list import ReportListSerializer
+
+from django.core.paginator import Paginator
+from django.db.models import Q
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+import logging
+logger = logging.getLogger(__name__)
+
+class ReportListView(APIView):
+    """
+    API-Endpunkt für paginierte Report-Listen mit optionaler Filterung
+    GET /api/reports/
+    """
+
+    def get(self, request):
+        try:
+            # Query-Parameter abrufen
+            page = int(request.GET.get('page', 1))
+            page_size = min(int(request.GET.get('page_size', 20)), 100)  # Max 100 pro Seite
+
+            # Filter-Parameter
+            file_type_filter = request.GET.get('file_type')
+            patient_name_filter = request.GET.get('patient_name')
+            casenumber_filter = request.GET.get('casenumber')
+            date_from = request.GET.get('date_from')
+            date_to = request.GET.get('date_to')
+
+            # Base QuerySet mit related data
+            queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
+
+            # Filter anwenden
+            if patient_name_filter:
+                queryset = queryset.filter(
+                    Q(sensitive_meta__patient_first_name__icontains=patient_name_filter) |
+                    Q(sensitive_meta__patient_last_name__icontains=patient_name_filter)
+                )
+
+            if casenumber_filter:
+                queryset = queryset.filter(
+                    sensitive_meta__case_number__icontains=casenumber_filter
+                )
+
+            if file_type_filter:
+                # Filter basierend auf Dateiendung
+                queryset = queryset.filter(file__endswith=f'.{file_type_filter}')
+
+            if date_from:
+                queryset = queryset.filter(created_at__gte=date_from)
+
+            if date_to:
+                queryset = queryset.filter(created_at__lte=date_to)
+
+            # Sortierung (neueste zuerst)
+            queryset = queryset.order_by('-created_at')
+
+            # Paginierung
+            paginator = Paginator(queryset, page_size)
+
+            if page > paginator.num_pages:
+                return Response({
+                    'count': paginator.count,
+                    'next': None,
+                    'previous': None,
+                    'results': []
+                })
+
+            page_obj = paginator.get_page(page)
+
+            # Serialisierung
+            serializer = ReportListSerializer(
+                page_obj.object_list,
+                many=True,
+                context={'request': request}
+            )
+
+            # URLs für Paginierung
+            next_url = None
+            previous_url = None
+
+            if page_obj.has_next():
+                next_url = request.build_absolute_uri(
+                    f"?page={page_obj.next_page_number()}&page_size={page_size}"
+                )
+
+            if page_obj.has_previous():
+                previous_url = request.build_absolute_uri(
+                    f"?page={page_obj.previous_page_number()}&page_size={page_size}"
+                )
+
+            return Response({
+                'count': paginator.count,
+                'next': next_url,
+                'previous': previous_url,
+                'results': serializer.data
+            })
+
+        except ValueError as e:
+            logger.error("Ungültige Parameter in ReportListView: %s", str(e))
+            return Response(
+                {"error": "Ungültige Parameter"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        except (AttributeError, TypeError, OSError) as e:
+            logger.error("Fehler in ReportListView: %s", str(e))
+            return Response(
+                {"error": "Fehler beim Laden der Reports"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/report/report_with_secure_url.py

@@ -0,0 +1,28 @@
+from endoreg_db.models import RawPdfFile
+from endoreg_db.serializers.report.report import ReportDataSerializer
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+import logging
+logger = logging.getLogger(__name__)
+
+class ReportWithSecureUrlView(APIView):
+    """
+    API-Endpunkt für Reports mit sicherer URL-Generierung
+    GET /api/reports/{report_id}/with-secure-url/
+    """
+
+    def get(self, request, report_id):
+        try:
+            report = get_object_or_404(RawPdfFile, id=report_id)
+            serializer = ReportDataSerializer(report, context={'request': request})
+            return Response(serializer.data)
+        except (ValueError, TypeError) as e:
+            logger.error("Fehler beim Laden des Reports %s: %s", report_id, str(e))
+            return Response(
+                {"error": "Report konnte nicht geladen werden"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )