endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/patient_finding/patient_finding_optimized.py

@@ -0,0 +1,291 @@
+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,75 @@
+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/report/__init__.py

@@ -0,0 +1,7 @@
+from .reimport import ReportReimportView
+from .report_stream import ReportStreamView
+
+__all__ = [
+    "ReportReimportView",
+    "ReportStreamView",
+]

endoreg_db/views/report/reimport.py

@@ -0,0 +1,177 @@
+import logging
+
+from django.db import transaction
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from ...models import RawPdfFile, SensitiveMeta
+from endoreg_db.services.report_import import ReportImportService
+
+logger = logging.getLogger(__name__)
+
+
+class ReportReimportView(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 = ReportImportService()
+
+    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: 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 report ID provided."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            pdf = RawPdfFile.objects.get(id=pdf_id)
+            logger.info(f"Found report {pdf.pdf_hash} (ID: {pdf_id}) for re-import")
+        except RawPdfFile.DoesNotExist:
+            logger.warning(f"report with ID {pdf_id} not found")
+            return Response(
+                {"error": f"report with ID {pdf_id} not found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get raw file path using the model method
+        raw_file_path = pdf.get_raw_file_path()
+
+        if not raw_file_path or not raw_file_path.exists():
+            logger.error(
+                f"Raw report file not found for hash {pdf.pdf_hash}: {raw_file_path}"
+            )
+            return Response(
+                {
+                    "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 report has required relationships
+        if not pdf.center:
+            logger.warning(f"report {pdf.pdf_hash} has no associated center")
+            return Response(
+                {"error": "report has no associated center."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            logger.info(f"Starting re-import for report {pdf.pdf_hash} (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.pk
+                    logger.info(
+                        f"Clearing existing SensitiveMeta {old_meta_id} for report {pdf.pdf_hash}"
+                    )
+                    pdf.sensitive_meta = None
+                    pdf.save(update_fields=["sensitive_meta"])
+
+                    # Delete the old SensitiveMeta record
+                    try:
+                        SensitiveMeta.objects.filter(pk=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}"
+                        )
+
+                # Use ReportImportService for reprocessing
+                try:
+                    logger.info(
+                        f"Starting reprocessing using ReportImportService for {pdf.pdf_hash}"
+                    )
+                    self.pdf_service.import_and_anonymize(
+                        file_path=raw_file_path,
+                        center_name=pdf.center.name,
+                        delete_source=False,  # Don't delete during reimport
+                        retry=True,  # Mark as retry attempt
+                    )
+
+                    logger.info(
+                        f"ReportImportService reprocessing completed for {pdf.pdf_hash}"
+                    )
+
+                    # Refresh to get updated state
+                    pdf.refresh_from_db()
+
+                    return Response(
+                        {
+                            "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,
+                            "sensitive_meta_id": pdf.sensitive_meta.pk
+                            if pdf.sensitive_meta
+                            else None,
+                            "text_extracted": bool(pdf.text),
+                            "anonymized": pdf.anonymized,
+                            "status": "done",
+                        },
+                        status=status.HTTP_200_OK,
+                    )
+
+                except Exception as e:
+                    logger.exception(
+                        f"ReportImportService reprocessing failed for report {pdf.pdf_hash}: {e}"
+                    )
+                    return Response(
+                        {
+                            "error": f"Reprocessing failed: {str(e)}",
+                            "error_type": "processing_error",
+                            "pdf_id": pdf_id,
+                            "pdf_hash": str(pdf.pdf_hash),
+                        },
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+        except Exception as e:
+            logger.error(
+                f"Failed to re-import report {pdf.pdf_hash}: {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,
+                        "pdf_hash": str(pdf.pdf_hash),
+                    },
+                    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,
+                        "pdf_hash": str(pdf.pdf_hash),
+                    },
+                    status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                )