endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/views/patient_finding/patient_finding_optimized.py

@@ -0,0 +1,259 @@
+from endoreg_db.models import Examination, Finding, FindingClassification, PatientFinding
+from endoreg_db.serializers.patient_finding import PatientFindingClassificationSerializer, PatientFindingDetailSerializer, PatientFindingListSerializer, PatientFindingWriteSerializer
+
+
+from django.db import transaction
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.cache import cache_page
+from django.views.decorators.vary import vary_on_headers
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.filters import OrderingFilter, SearchFilter
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+
+class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
+    """
+    Hochoptimiertes ViewSet für PatientFinding mit Query-Optimierung,
+    Bulk-Endpoints und intelligenter Serializer-Auswahl
+    """
+    permission_classes = [IsAuthenticated]
+    filter_backends = [DjangoFilterBackend, OrderingFilter, SearchFilter]
+    filterset_fields = ['patient_examination__patient', 'finding', 'patient_examination__examination']
+    ordering_fields = ['id', 'patient_examination__date_start']
+    search_fields = ['finding__name', 'patient_examination__patient__first_name', 'patient_examination__patient__last_name']
+
+    def get_queryset(self):
+        """Optimierte QuerySet mit Prefetching basierend auf Action"""
+        base_queryset = PatientFinding.objects.select_related(
+            'patient_examination__patient',
+            'patient_examination__examination',
+            'finding'
+        )
+
+        # Detail-Views: fetch nested relations
+        if self.action in ['retrieve', 'update', 'partial_update']:
+            return base_queryset.prefetch_related(
+                "classifications__classification",
+                "classifications__choice",
+                # 'locations__location_classification',
+                # 'locations__location_choice',
+                # 'morphologies__morphology_classification', 
+                # 'morphologies__morphology_choice',
+                'interventions__intervention'
+            )
+
+        # For List-Views: fetch only necessary relations
+        return base_queryset
+
+    def get_serializer_class(self):
+        """Intelligente Serializer-Auswahl basierend auf Action"""
+        if self.action == 'list':
+            return PatientFindingListSerializer
+        elif self.action in ['create', 'update', 'partial_update']:
+            return PatientFindingWriteSerializer
+        else:
+            return PatientFindingDetailSerializer
+
+    @method_decorator(cache_page(60 * 15))  # 15 Minuten Cache
+    @method_decorator(vary_on_headers('Accept-Language'))
+    @action(detail=False, methods=['get'])
+    def examination_manifest(self, request):
+        """
+        Bulk-Endpoint: Liefert alle Setup-Daten für eine Examination in einem Call
+        """
+        examination_id = request.query_params.get('examination_id')
+        if not examination_id:
+            return Response(
+                {'error': 'examination_id parameter erforderlich'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            examination = Examination.objects.get(id=examination_id)
+        except Examination.DoesNotExist:
+            return Response(
+                {'error': 'Examination nicht gefunden'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # Alle Daten in optimierten Queries laden
+        findings = examination.get_available_findings().prefetch_related(
+            'location_classifications__choices',
+            'morphology_classifications__choices'
+        )
+
+        manifest_data = {
+            'examination': {
+                'id': examination.id,
+                'name': examination.name,
+                # 'name_de': examination.name_de,
+                # 'name_en': examination.name_en,
+            },
+            'findings': []
+        }
+
+        for finding in findings:
+            assert isinstance(finding, Finding), "Expected Finding instance"
+            finding_data = {
+                'id': finding.id,
+                'name': finding.name,
+                # 'name_de': finding.name_de,
+                # 'name_en': finding.name_en,
+                "classifications": [],
+                'location_classifications': [],
+                'morphology_classifications': []
+            }
+
+            for classification_obj in finding.get_classifications():
+                assert isinstance(classification_obj, FindingClassification), "Expected FindingClassification instance"
+                classification_data = {
+                    'id': classification_obj.id,
+                    'name': classification_obj.name,
+                    "choices": [
+                        {
+                            'id': choice.id,
+                            'name': choice.name,
+                        }
+                        for choice in classification_obj.choices.all()
+                    ]
+                }
+
+                finding_data['classifications'].append(classification_data)
+
+    @action(detail=False, methods=['post'])
+    def bulk_create(self, request):
+        """
+        Bulk-Endpoint für gleichzeitige Erstellung mehrerer PatientFindings
+        Optimiert für Mobile Apps mit schlechter Verbindung
+        """
+        findings_data = request.data.get('findings', [])
+        if not findings_data:
+            return Response(
+                {'error': 'findings array required'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        created_findings = []
+        errors = []
+
+        with transaction.atomic():
+            for i, finding_data in enumerate(findings_data):
+                serializer = self.get_serializer(data=finding_data)
+                if serializer.is_valid():
+                    try:
+                        finding = serializer.save()
+                        created_findings.append({
+                            'index': i,
+                            'id': finding.id,
+                            'status': 'created'
+                        })
+                    except Exception as e:
+                        errors.append({
+                            'index': i,
+                            'error': str(e),
+                            'status': 'error'
+                        })
+                else:
+                    errors.append({
+                        'index': i,
+                        'errors': serializer.errors,
+                        'status': 'validation_error'
+                    })
+
+        return Response({
+            'created': created_findings,
+            'errors': errors,
+            'total_processed': len(findings_data),
+            'success_count': len(created_findings),
+            'error_count': len(errors)
+        }, status=status.HTTP_201_CREATED if created_findings else status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=['post'])
+    def add_classification(self, request, pk=None):
+        """
+        Create and link a PatientFindingClassification to the PatientFinding
+
+        Called by: POST /api/patient-findings/{id}/add-classification/ #TODO CHECK
+
+        Expected payload: {
+            "classification_id": 1,
+            "choice_id": 2
+
+        """
+        patient_finding = self.get_object()
+        assert isinstance(patient_finding, PatientFinding), "Expected PatientFinding instance"
+        classification_data = request.data
+
+        # Validierung
+        classification_id = classification_data.get('classification_id')
+        choice_id = classification_data.get('choice_id')
+
+        if not classification_id or not choice_id:
+            return Response(
+                {'error': 'classification und choice erforderlich'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        patient_finding.add_classification(classification_id, choice_id)
+        try:
+            patient_finding_classification = patient_finding.add_classification(classification_id, choice_id)
+            serializer = PatientFindingClassificationSerializer(patient_finding_classification)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        except FindingClassification.DoesNotExist:
+            return Response(
+                {'error': 'location_classification nicht gefunden'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+    @action(detail=False, methods=['get'])
+    def export_for_analysis(self, request):
+        """
+        Export-Endpoint für Datenanalyse mit flacher Struktur
+        Unterstützt CSV/JSON Export mit denormalisierten Daten
+        """
+        queryset = self.filter_queryset(self.get_queryset())
+
+        # Format-Parameter
+        export_format = request.query_params.get('format', 'json')
+
+        # Flache Datenstruktur für Analyse
+        export_data = []
+        for finding in queryset:
+            assert isinstance(finding, PatientFinding), "Expected PatientFinding instance"
+            base_data = {
+                'finding_id': finding.id,
+                'patient_id': finding.patient_examination.patient.id,
+                'patient_name': finding.patient_examination.patient.get_full_name(),
+                'examination_type': finding.patient_examination.examination.name,
+                'examination_date': finding.patient_examination.date_start,
+                'finding_name': finding.finding.name,
+            }
+
+            # Locations denormalisieren
+            for classification in finding.classifications.all():
+                classification_data = base_data.copy()
+                classification_data.update({
+                    'location_classification': classification.location_classification.name,
+                    'location_choice': classification.location_choice.name,
+                    'location_subcategories': classification.subcategories,
+                })
+                export_data.append(classification_data)
+
+            # Wenn keine Locations, trotzdem Base-Data hinzufügen
+            if not finding.locations.exists():
+                export_data.append(base_data)
+
+        if export_format == 'csv':
+            # CSV-Export implementierung würde hier hin
+            pass
+
+        return Response({
+            'data': export_data,
+            'count': len(export_data),
+            'exported_at': timezone.now()
+        })

endoreg_db/views/patient_finding_classification/__init__.py

@@ -0,0 +1,5 @@
+from .pfc_create import create_patient_finding_classification
+
+__all__ = [
+    "create_patient_finding_classification",
+]

endoreg_db/views/patient_finding_classification/pfc_create.py

@@ -0,0 +1,67 @@
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from rest_framework import status
+from endoreg_db.models import (
+    PatientFinding,
+    FindingClassificationChoice,
+    FindingClassification
+)
+
+@api_view(['POST'])
+def create_patient_finding_classification(request):
+    """
+    Create a patient finding classification relationship.
+    Expected payload: {
+        "patient_finding_id": 1,
+        "classification_id": 2,
+        "classification_choice_id": 2
+    }
+    """
+    try:
+        patient_finding_id = request.data.get('patient_finding_id')
+        choice_id = request.data.get('classification_choice_id')
+        classification_id = request.data.get('classification_id')
+        
+        if not patient_finding_id or not choice_id:
+            return Response(
+                {'detail': 'patient_finding_id and classification_choice_id are required'}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Get the objects
+        try:
+            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
+        except PatientFinding.DoesNotExist:
+            return Response(
+                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        
+        try:
+            choice = FindingClassificationChoice.objects.get(id=choice_id)
+        except FindingClassificationChoice.DoesNotExist:
+            return Response(
+                {'detail': f'ClassificationChoice with id {choice_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        try:
+            FindingClassification.objects.get(id=classification_id)
+        except FindingClassification.DoesNotExist:
+            return Response(
+                {'detail': f'Classification with id {classification_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        patient_finding_classification = patient_finding.add_classification(classification_id = classification_id, choice_id = choice_id)
+        
+        return Response({
+            'id': patient_finding_classification.id,
+            'patient_finding_id': patient_finding.id,
+            'classification_choice_id': choice.id
+        }, status=status.HTTP_201_CREATED)
+        
+    except Exception as e:
+        return Response(
+            {'detail': f'Error creating patient finding classification: {str(e)}'}, 
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )

endoreg_db/views/patient_finding_location/__init__.py

@@ -0,0 +1,5 @@
+from .pfl_create import create_patient_finding_location
+
+__all__ = [
+    "create_patient_finding_location",
+]

endoreg_db/views/patient_finding_location/pfl_create.py

@@ -0,0 +1,70 @@
+from endoreg_db.serializers.patient_finding.patient_finding import PatientFindingSerializer
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+from rest_framework import status
+from endoreg_db.models.medical.patient.patient_finding import PatientFinding
+from endoreg_db.models.medical.patient.patient_finding_location import PatientFindingLocation
+from endoreg_db.models.medical.patient.patient_finding_morphology import PatientFindingMorphology
+from endoreg_db.models import ( FindingLocationClassificationChoice, FindingMorphologyClassificationChoice )
+from rest_framework import serializers
+from utils.permissions import EnvironmentAwarePermission
+
+class PatientFindingViewSet(ModelViewSet):
+    queryset = PatientFinding.objects.all()
+    serializer_class = PatientFindingSerializer
+
+@api_view(['POST'])
+@permission_classes([EnvironmentAwarePermission])
+def create_patient_finding_location(request):
+    """
+    Create a patient finding location relationship.
+    Expected payload: {
+        "patient_finding_id": 1,
+        "location_classification_choice_id": 2
+    }
+    """
+    try:
+        patient_finding_id = request.data.get('patient_finding_id')
+        choice_id = request.data.get('location_classification_choice_id')
+        
+        if not patient_finding_id or not choice_id:
+            return Response(
+                {'detail': 'patient_finding_id and location_classification_choice_id are required'}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Get the objects
+        try:
+            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
+        except PatientFinding.DoesNotExist:
+            return Response(
+                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        
+        try:
+            choice = FindingLocationClassificationChoice.objects.get(id=choice_id)
+        except FindingLocationClassificationChoice.DoesNotExist:
+            return Response(
+                {'detail': f'LocationClassificationChoice with id {choice_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        
+        # Create the relationship
+        patient_finding_location = PatientFindingLocation.objects.create(
+            patient_finding=patient_finding,
+            location_classification_choice=choice
+        )
+        
+        return Response({
+            'id': patient_finding_location.id,
+            'patient_finding_id': patient_finding.id,
+            'location_classification_choice_id': choice.id
+        }, status=status.HTTP_201_CREATED)
+        
+    except Exception as e:
+        return Response(
+            {'detail': f'Error creating patient finding location: {str(e)}'}, 
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )

endoreg_db/views/patient_finding_morphology/__init__.py

@@ -0,0 +1,5 @@
+from .pfm_create import create_patient_finding_morphology
+
+__all__ = [
+    "create_patient_finding_morphology",
+]

endoreg_db/views/patient_finding_morphology/pfm_create.py

@@ -0,0 +1,70 @@
+from endoreg_db.serializers.patient_finding.patient_finding import PatientFindingSerializer
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+from rest_framework import status
+from endoreg_db.models.medical.patient.patient_finding import PatientFinding
+from endoreg_db.models.medical.patient.patient_finding_location import PatientFindingLocation
+from endoreg_db.models.medical.patient.patient_finding_morphology import PatientFindingMorphology
+from endoreg_db.models import ( FindingLocationClassificationChoice, FindingMorphologyClassificationChoice)
+from rest_framework import serializers
+from utils.permissions import EnvironmentAwarePermission
+
+class PatientFindingViewSet(ModelViewSet):
+    queryset = PatientFinding.objects.all()
+    serializer_class = PatientFindingSerializer
+
+@api_view(['POST'])
+@permission_classes([EnvironmentAwarePermission])
+def create_patient_finding_morphology(request):
+    """
+    Create a patient finding morphology relationship.
+    Expected payload: {
+        "patient_finding_id": 1,
+        "morphology_classification_choice_id": 2
+    }
+    """
+    try:
+        patient_finding_id = request.data.get('patient_finding_id')
+        choice_id = request.data.get('morphology_classification_choice_id')
+        
+        if not patient_finding_id or not choice_id:
+            return Response(
+                {'detail': 'patient_finding_id and morphology_classification_choice_id are required'}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Get the objects
+        try:
+            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
+        except PatientFinding.DoesNotExist:
+            return Response(
+                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        
+        try:
+            choice = FindingMorphologyClassificationChoice.objects.get(id=choice_id)
+        except FindingMorphologyClassificationChoice.DoesNotExist:
+            return Response(
+                {'detail': f'MorphologyClassificationChoice with id {choice_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        
+        # Create the relationship
+        patient_finding_morphology = PatientFindingMorphology.objects.create(
+            patient_finding=patient_finding,
+            morphology_classification_choice=choice
+        )
+        
+        return Response({
+            'id': patient_finding_morphology.id,
+            'patient_finding_id': patient_finding.id,
+            'morphology_classification_choice_id': choice.id
+        }, status=status.HTTP_201_CREATED)
+        
+    except Exception as e:
+        return Response(
+            {'detail': f'Error creating patient finding morphology: {str(e)}'}, 
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )

endoreg_db/views/pdf/__init__.py

@@ -0,0 +1,8 @@
+from .reimport import PdfReimportView
+from .pdf_stream import PdfStreamView
+
+
+__all__ = [
+    "PdfReimportView",
+    "PdfStreamView",
+]

endoreg_db/views/pdf/pdf_stream.py

@@ -0,0 +1,187 @@
+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 anonymized PDF files.
+
+    Query Parameters:
+        type: 'raw' (default) or 'anonymized' - 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
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    @xframe_options_exempt
+    def get(self, request, pdf_id: int, *args, **kwargs):
+        file_type = "raw"  # Initialize for error logging
+        try:
+            pdf_obj = RawPdfFile.objects.filter(pk=pdf_id).first()
+            if not pdf_obj:
+                logger.warning(f"PDF not found: ID {pdf_id}")
+                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"]:
+                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 {pdf_id}")
+                    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}"
+                    )
+                    raise Http404("Anonymized 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 {pdf_id}: {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"
+            )
+            if not base_filename.endswith(".pdf"):
+                base_filename += ".pdf"
+
+            # Add type indicator to filename for clarity
+            if file_type == "anonymized":
+                name_parts = base_filename.rsplit(".", 1)
+                safe_filename = f"{name_parts[0]}_anonymized.{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 {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 {file_type} 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 {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 {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 {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'} {pdf_id}: {e}",
+                exc_info=True,
+            )
+            raise Http404("Error streaming PDF")