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

endoreg_db/views/pdf/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 ...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.pdf_hash} (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,
+            )
+
+        # 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 PDF file not found for hash {pdf.pdf_hash}: {raw_file_path}"
+            )
+            return Response(
+                {
+                    "error": f"Raw PDF file not found for PDF {pdf.pdf_hash}. Please upload the original file again."
+                },
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Check if PDF has required relationships
+        if not pdf.center:
+            logger.warning(f"PDF {pdf.pdf_hash} has no associated center")
+            return Response(
+                {"error": "PDF has no associated center."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        try:
+            logger.info(f"Starting re-import for PDF {pdf.pdf_hash} (ID: {pdf_id})")
+
+            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 PDF {pdf.pdf_hash}"
+                    )
+                    pdf.sensitive_meta = None  # type: ignore
+                    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 PdfImportService for reprocessing
+                try:
+                    logger.info(
+                        f"Starting reprocessing using PdfImportService 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"PdfImportService reprocessing completed for {pdf.pdf_hash}"
+                    )
+
+                    # Refresh to get updated state
+                    pdf.refresh_from_db()
+
+                    return Response(
+                        {
+                            "message": "PDF 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"PdfImportService reprocessing failed for PDF {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 PDF {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,
+                )

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
+            )

endoreg_db/views/report/start_examination.py

@@ -0,0 +1,7 @@
+from django.shortcuts import render
+from django.contrib.admin.views.decorators import staff_member_required
+
+@staff_member_required
+def start_examination(request):
+    return render(request, 'admin/start_examination.html')
+

endoreg_db/views/requirement/__init__.py

@@ -0,0 +1,10 @@
+from .evaluate import (
+    evaluate_requirements,
+)
+from .lookup import (
+    LookupViewSet,
+)
+__all__ = [
+    "evaluate_requirements",
+    "LookupViewSet",
+]

endoreg_db/views/requirement/evaluate.py

@@ -0,0 +1,279 @@
+from endoreg_db.models.requirement.requirement import Requirement
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+
+
+from rest_framework import status
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+import logging
+
+logger = logging.getLogger(__name__)
+@api_view(['POST'])
+def evaluate_requirements(request):
+    """
+    Evaluate requirements and always return 200 with structured results.
+    Payload:
+    {
+      "requirement_set_ids": [<int>, ...],  // optional; evaluates all if omitted
+      "patient_examination_id": <int>       // required
+    }
+
+    Response (HTTP 200 always):
+    {
+      "ok": <bool>,                  // false if any errors occurred
+      "errors": [<str>, ...],        // high-level problems (e.g. invalid input, missing PE)
+      "meta": {
+        "patientExaminationId": <int|null>,
+        "setsEvaluated": <int>,
+        "requirementsEvaluated": <int>,
+        "status": "ok" | "partial" | "failed"
+      },
+      "results": [
+        {
+          "requirement_set_id": <int>,
+          "requirement_set_name": <str>,
+          "requirement_name": <str>,
+          "met": <bool>,
+          "details": <str>,          // always a string for UI display
+          "error": <str|null>        // per-item error if evaluation failed
+        }
+      ]
+    }
+    """
+    payload = request.data or {}
+    req_set_ids = payload.get("requirement_set_ids")
+    pe_id = payload.get("patient_examination_id")
+
+    results = []
+    errors = []
+    sets_evaluated = 0
+    requirements_evaluated = 0
+
+    # ---- basic validation (still 200 on failure)
+    if not pe_id:
+        msg = "patient_examination_id is required"
+        errors.append(msg)
+        logger.warning("evaluate_requirements: %s; payload=%s", msg, payload)
+        return Response({
+            "ok": False,
+            "errors": errors,
+            "meta": {
+                "patientExaminationId": None,
+                "setsEvaluated": 0,
+                "requirementsEvaluated": 0,
+                "status": "failed",
+            },
+            "results": []
+        }, status=status.HTTP_200_OK)
+
+    # ---- fetch PatientExamination
+    try:
+        pe = (PatientExamination.objects
+              .select_related("patient")
+              .get(id=pe_id))
+    except PatientExamination.DoesNotExist:
+        msg = f"PatientExamination with id {pe_id} does not exist"
+        errors.append(msg)
+        logger.warning("evaluate_requirements: %s", msg)
+        return Response({
+            "ok": False,
+            "errors": errors,
+            "meta": {
+                "patientExaminationId": pe_id,
+                "setsEvaluated": 0,
+                "requirementsEvaluated": 0,
+                "status": "failed",
+            },
+            "results": []
+        }, status=status.HTTP_200_OK)
+    except Exception as e:
+        msg = f"Unexpected error retrieving PatientExamination {pe_id}: {e}"
+        errors.append(msg)
+        logger.exception("evaluate_requirements: %s", msg)
+        return Response({
+            "ok": False,
+            "errors": errors,
+            "meta": {
+                "patientExaminationId": pe_id,
+                "setsEvaluated": 0,
+                "requirementsEvaluated": 0,
+                "status": "failed",
+            },
+            "results": []
+        }, status=status.HTTP_200_OK)
+
+    # ---- determine requirement sets
+    try:
+        q = RequirementSet.objects.prefetch_related("requirements")
+        if req_set_ids:
+            q = q.filter(id__in=req_set_ids)
+
+        requirement_sets = list(q)
+        sets_evaluated = len(requirement_sets)
+
+        if req_set_ids and sets_evaluated == 0:
+            msg = f"No RequirementSets found for IDs: {req_set_ids}"
+            errors.append(msg)
+            logger.warning("evaluate_requirements: %s", msg)
+    except Exception as e:
+        msg = f"Error loading RequirementSets: {e}"
+        errors.append(msg)
+        logger.exception("evaluate_requirements: %s", msg)
+        return Response({
+            "ok": False,
+            "errors": errors,
+            "meta": {
+                "patientExaminationId": pe_id,
+                "setsEvaluated": 0,
+                "requirementsEvaluated": 0,
+                "status": "failed",
+            },
+            "results": []
+        }, status=status.HTTP_200_OK)
+
+    # ---- evaluate
+    for req_set in requirement_sets:
+        for req in req_set.requirements.all():
+            # (optionally) reload Requirement to ensure fresh instance as in your original code
+            try:
+                requirement_obj = Requirement.objects.get(name=req.name)
+            except Exception:
+                # fall back to the prefetched instance
+                requirement_obj = req
+
+            try:
+                met, details = requirement_obj.evaluate_with_details(pe.patient, mode="strict")
+                # normalize details to a string for the frontend
+                if isinstance(details, str):
+                    details_str = details
+                else:
+                    try:
+                        details_str = json.dumps(details, ensure_ascii=False, default=str)
+                    except Exception:
+                        details_str = str(details)
+
+                results.append({
+                    "requirement_set_id": getattr(req_set, "id", None),
+                    "requirement_set_name": getattr(req_set, "name", str(getattr(req_set, "id", ""))),
+                    "requirement_name": getattr(requirement_obj, "name", "unknown"),
+                    "met": bool(met),
+                    "details": details_str if details_str else ("Voraussetzung erfüllt" if met else "Voraussetzung nicht erfüllt"),
+                    "error": None
+                })
+            except (TypeError, ValueError) as e:
+                msg = f"Fehler bei der Bewertung der Voraussetzung: {e}"
+                logger.warning("evaluate_requirements: requirement '%s' error: %s",
+                               getattr(requirement_obj, "name", "unknown"), e)
+                results.append({
+                    "requirement_set_id": getattr(req_set, "id", None),
+                    "requirement_set_name": getattr(req_set, "name", str(getattr(req_set, "id", ""))),
+                    "requirement_name": getattr(requirement_obj, "name", "unknown"),
+                    "met": False,
+                    "details": msg,
+                    "error": f"{e.__class__.__name__}: {e}"
+                })
+                errors.append(msg)
+            except Exception as e:
+                msg = f"Unerwarteter Fehler bei der Bewertung: {e}"
+                logger.exception("evaluate_requirements: requirement '%s' unexpected error",
+                                 getattr(requirement_obj, "name", "unknown"))
+                results.append({
+                    "requirement_set_id": getattr(req_set, "id", None),
+                    "requirement_set_name": getattr(req_set, "name", str(getattr(req_set, "id", ""))),
+                    "requirement_name": getattr(requirement_obj, "name", "unknown"),
+                    "met": False,
+                    "details": msg,
+                    "error": f"{e.__class__.__name__}: {e}"
+                })
+                errors.append(msg)
+
+            requirements_evaluated += 1
+
+    # ---- response meta & status summary
+    any_errors = len(errors) > 0
+    if not requirement_sets:
+        status_label = "failed"
+    elif any_errors and len(results) > 0:
+        status_label = "partial"
+    else:
+        status_label = "ok"
+
+    response_payload = {
+        "ok": not any_errors,
+        "errors": errors,  # frontend can render these in a toast / banner
+        "meta": {
+            "patientExaminationId": pe_id,
+            "setsEvaluated": sets_evaluated,
+            "requirementsEvaluated": requirements_evaluated,
+            "status": status_label
+        },
+        "results": results
+    }
+
+    return Response(response_payload, status=status.HTTP_200_OK)
+
+
+def evaluate_requirement_set(request) -> Response:
+    """
+    Evaluate a specific RequirementSet based on provided RequirementLinks data.
+
+    Expects a JSON payload with the following structure:
+    {
+        "requirement_set_ids": [<requirement_set_ids>],
+        "patient_examination_id": <patient_examination_id>
+    }
+
+    Returns a JSON response with the evaluation results for the specified RequirementSet:
+    {
+        "results": [
+            {
+                "requirement_name": <requirement_name>,
+                "met": <true/false>,
+                "details": <additional_details>
+            },
+            ...
+        ]
+    }
+    """
+    try:
+        data = request.data
+        requirement_set_ids = data.get("requirement_set_ids", None)
+        patient_examination_id = data.get("patient_examination_id")
+
+        if not requirement_set_ids:
+            return Response({"error": "requirement_set_ids is required"}, status=status.HTTP_400_BAD_REQUEST)
+        
+        if not patient_examination_id:
+            return Response({"error": "patient_examination_id is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Get the patient examination
+        try:
+            patient_examination = PatientExamination.objects.get(id=patient_examination_id)
+        except PatientExamination.DoesNotExist:
+            return Response({"error": f"PatientExamination with id {patient_examination_id} does not exist"}, status=status.HTTP_404_NOT_FOUND)
+
+        results = []
+
+        # Construct RequirementLinks from the provided data
+        for requirement_set_id in requirement_set_ids:
+            # Fetch the specified RequirementSet
+            try:
+                req_set = RequirementSet.objects.get(id=requirement_set_id)
+            except RequirementSet.DoesNotExist:
+                return Response({"error": f"RequirementSet with id {requirement_set_id} does not exist"}, status=status.HTTP_404_NOT_FOUND)
+
+            for requirement in req_set.requirements.all():
+                met, details = requirement.evaluate(patient_examination.patient, mode="strict")
+                results.append({
+                    "requirement_name": requirement.name,
+                    "met": met,
+                    "details": details
+                })
+
+        return Response({
+            "results": results
+        }, status=status.HTTP_200_OK)
+
+    except Exception as e:
+        return Response({"results": str(e), details: "Fehler bei der Bewertung der Voraussetzung"}, status=status.HTTP_400_BAD_REQUEST)