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

endoreg_db/views/{pdf/pdf_stream.py → report/report_stream.py}

@@ -3,7 +3,10 @@ import os
 import re
 
 from django.http import FileResponse, Http404, StreamingHttpResponse
-from django.views.decorators.clickjacking import xframe_options_sameorigin
+from django.views.decorators.clickjacking import (
+    xframe_options_exempt,
+    xframe_options_sameorigin,
+)
 from rest_framework.views import APIView
 
 from endoreg_db.models import RawPdfFile
@@ -36,34 +39,34 @@ class ClosingFileWrapper:
             self.file_handle.close()
 
 
-class PdfStreamView(APIView):
+class ReportStreamView(APIView):
     """
-    Streams a PDF file with correct HTTP range support and proper file handle management.
+    Streams a report file with correct HTTP range support and proper file handle management.
 
-    Supports streaming both raw (original) and anonymized PDF files.
+    Supports streaming both raw (original) and processed report files.
 
     Query Parameters:
-        type: 'raw' (default) or 'anonymized' - Selects which PDF file to stream
+        type: 'raw' (default) or 'processed' - Selects which report 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
+        GET /api/media/pdf/1/?type=raw - Stream original raw report
+        GET /api/media/pdf/1/?type=processed - Stream processed report
     """
 
     permission_classes = [EnvironmentAwarePermission]
 
-    @xframe_options_sameorigin
-    def get(self, request, pdf_id: int, *args, **kwargs):
+    @xframe_options_exempt
+    def get(self, request, pk: int, *args, **kwargs):
         file_type = "raw"  # Initialize for error logging
         try:
-            pdf_obj = RawPdfFile.objects.filter(pk=pdf_id).first()
+            pdf_obj = RawPdfFile.objects.filter(pk=pk).first()
             if not pdf_obj:
-                logger.warning(f"PDF not found: ID {pdf_id}")
-                raise Http404("PDF not found")
+                logger.warning(f"report not found: ID {pk}")
+                raise Http404("report 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"]:
+            if file_type not in ["raw", "processed"]:
                 logger.warning(f"Invalid file_type '{file_type}', defaulting to 'raw'")
                 file_type = "raw"
 
@@ -71,43 +74,45 @@ class PdfStreamView(APIView):
             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")
+                    logger.warning(f"No raw report file available for report ID {pk}")
+                    raise Http404("Raw report file not available")
             else:  # anonymized
-                file_field = pdf_obj.anonymized_file
+                file_field = pdf_obj.processed_file
                 if not file_field:
                     logger.warning(
-                        f"No anonymized PDF file available for PDF ID {pdf_id}"
+                        f"No processed report file available for report ID {pk}"
                     )
-                    raise Http404("Anonymized PDF file not available")
+                    raise Http404("Processed report 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}")
+                    logger.error(
+                        f"report file does not exist on filesystem: {file_path}"
+                    )
                     raise Http404(
-                        f"{file_type.capitalize()} PDF file not found on filesystem"
+                        f"{file_type.capitalize()} report 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")
+                logger.error(f"Error accessing {file_type} report file {pk}: {e}")
+                raise Http404(f"{file_type.capitalize()} report file not accessible")
 
             # Generate safe filename
             base_filename = (
                 os.path.basename(file_field.name)
                 if file_field.name
-                else f"document_{pdf_id}.pdf"
+                else f"document_{pk}.pdf"
             )
             if not base_filename.endswith(".pdf"):
                 base_filename += ".pdf"
 
             # Add type indicator to filename for clarity
-            if file_type == "anonymized":
+            if file_type == "processed":
                 name_parts = base_filename.rsplit(".", 1)
-                safe_filename = f"{name_parts[0]}_anonymized.{name_parts[1]}"
+                safe_filename = f"{name_parts[0]}_processed.{name_parts[1]}"
             else:
                 safe_filename = base_filename
 
@@ -115,7 +120,7 @@ class PdfStreamView(APIView):
             range_header = request.headers.get("Range")
             if range_header:
                 logger.debug(
-                    f"Range request for {file_type} PDF {pdf_id}: {range_header}"
+                    f"Range request for {file_type} report {pk}: {range_header}"
                 )
                 match = _RANGE_RE.match(range_header)
                 if match:
@@ -139,7 +144,7 @@ class PdfStreamView(APIView):
                         file_handle.seek(start)
 
                         logger.debug(
-                            f"Serving {file_type} PDF {pdf_id} range {start}-{end}/{file_size}"
+                            f"Serving {file_type} report {pk} range {start}-{end}/{file_size}"
                         )
 
                         response = StreamingHttpResponse(
@@ -157,31 +162,33 @@ class PdfStreamView(APIView):
                         return response
                     except (OSError, IOError) as e:
                         logger.error(
-                            f"Error opening {file_type} PDF file for range request: {e}"
+                            f"Error opening {file_type} report file for range request: {e}"
                         )
-                        raise Http404(f"Error accessing {file_type} PDF file")
+                        raise Http404(f"Error accessing {file_type} report 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)")
+            logger.debug(f"Serving full {file_type} report {pk} ({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}"'
+                with open(file_path, "rb") as file_handle:
+                    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")
+                logger.error(f"Error opening {file_type} report file: {e}")
+                raise Http404(f"Error accessing {file_type} report file")
 
         except Exception as e:
             logger.error(
-                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'PDF'} {pdf_id}: {e}",
+                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'report'} {pk}: {e}",
                 exc_info=True,
             )
-            raise Http404("Error streaming PDF")
+            raise Http404("Error streaming report")

endoreg_db/views/requirement/evaluate.py

@@ -1,52 +1,31 @@
 from endoreg_db.models.requirement.requirement import Requirement
+from endoreg_db.views.requirement.requirement_utils import safe_evaluate_requirement
 from endoreg_db.models.requirement.requirement_set import RequirementSet
+from endoreg_db.models.requirement.requirement_evaluation.evaluate_with_dependencies import (
+    evaluate_requirement_sets_with_dependencies,
+    RequirementStatus,   # if you export it there, otherwise re-declare in view
+)
 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 json
 import logging
 
 logger = logging.getLogger(__name__)
-@api_view(['POST'])
+
+
+@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
-        }
-      ]
-    }
+    Evaluate requirements (all selected sets) and always return 200 with structured results.
     """
     payload = request.data or {}
     req_set_ids = payload.get("requirement_set_ids")
     pe_id = payload.get("patient_examination_id")
 
-    results = []
-    errors = []
+    results: list[dict] = []
+    errors: list[str] = []
     sets_evaluated = 0
     requirements_evaluated = 0
 
@@ -55,53 +34,63 @@ def evaluate_requirements(request):
         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",
+        return Response(
+            {
+                "ok": False,
+                "errors": errors,
+                "meta": {
+                    "patientExaminationId": None,
+                    "setsEvaluated": 0,
+                    "requirementsEvaluated": 0,
+                    "status": "failed",
+                },
+                "results": [],
             },
-            "results": []
-        }, status=status.HTTP_200_OK)
+            status=status.HTTP_200_OK,
+        )
 
     # ---- fetch PatientExamination
     try:
-        pe = (PatientExamination.objects
-              .select_related("patient")
-              .get(id=pe_id))
+        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",
+        return Response(
+            {
+                "ok": False,
+                "errors": errors,
+                "meta": {
+                    "patientExaminationId": pe_id,
+                    "setsEvaluated": 0,
+                    "requirementsEvaluated": 0,
+                    "status": "failed",
+                },
+                "results": [],
             },
-            "results": []
-        }, status=status.HTTP_200_OK)
+            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",
+        return Response(
+            {
+                "ok": False,
+                "errors": errors,
+                "meta": {
+                    "patientExaminationId": pe_id,
+                    "setsEvaluated": 0,
+                    "requirementsEvaluated": 0,
+                    "status": "failed",
+                },
+                "results": [],
             },
-            "results": []
-        }, status=status.HTTP_200_OK)
+            status=status.HTTP_200_OK,
+        )
 
     # ---- determine requirement sets
     try:
@@ -120,75 +109,152 @@ def evaluate_requirements(request):
         msg = f"Error loading RequirementSets: {e}"
         errors.append(msg)
         logger.exception("evaluate_requirements: %s", msg)
-        return Response({
-            "ok": False,
+        return Response(
+            {
+                "ok": False,
+                "errors": errors,
+                "meta": {
+                    "patientExaminationId": pe_id,
+                    "setsEvaluated": 0,
+                    "requirementsEvaluated": 0,
+                    "status": "failed",
+                },
+                "results": [],
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    # nothing to evaluate → still return 200
+    if not requirement_sets:
+        response_payload = {
+            "ok": len(errors) == 0,
             "errors": errors,
             "meta": {
                 "patientExaminationId": pe_id,
                 "setsEvaluated": 0,
                 "requirementsEvaluated": 0,
-                "status": "failed",
+                "status": "failed" if errors else "ok",
             },
-            "results": []
-        }, status=status.HTTP_200_OK)
+            "results": [],
+        }
+        return Response(response_payload, status=status.HTTP_200_OK)
+
+    # mapping from IDs to objects for later lookup
+    sets_by_id: dict[int, RequirementSet] = {s.id: s for s in requirement_sets}
+
+    # ---- main evaluation with set dependencies
+    try:
+        # returns: { set_id: { req_id: (status, details) } }
+        set_results = evaluate_requirement_sets_with_dependencies(
+            requirement_sets,
+            pe.patient,
+            mode="strict",
+        )
+
+        for set_id, req_dict in set_results.items():
+            req_set = sets_by_id.get(set_id)
+            set_name = getattr(
+                req_set, "name", str(set_id)
+            ) if req_set is not None else str(set_id)
 
-    # ---- 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
+            for req_id, (status_value, details) in req_dict.items():
+                try:
+                    requirement_obj = Requirement.objects.get(id=req_id)
+                    req_name = getattr(requirement_obj, "name", f"#{req_id}")
+                except Requirement.DoesNotExist:
+                    requirement_obj = None
+                    req_name = f"#{req_id}"
 
-            try:
-                met, details = requirement_obj.evaluate_with_details(pe.patient, mode="strict")
-                # normalize details to a string for the frontend
+                # map RequirementStatus → met + error
+                if status_value == "PASSED":
+                    met = True
+                    error_str = None
+                elif status_value in ("FAILED", "BLOCKED"):
+                    met = False
+                    error_str = None
+                else:  # "ERROR"
+                    met = False
+                    error_str = "Technischer Fehler bei der Auswertung"
+
+                # normalize details to string
                 if isinstance(details, str):
                     details_str = details
                 else:
                     try:
-                        details_str = json.dumps(details, ensure_ascii=False, default=str)
+                        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)
+                # default fallback text if details are empty
+                if not details_str:
+                    details_str = (
+                        "Voraussetzung erfüllt"
+                        if met
+                        else "Voraussetzung nicht erfüllt"
+                    )
+
+                if status_value == "ERROR":
+                    # add a high-level error for meta if there was an internal error
+                    msg = (
+                        f"Technischer Fehler bei der Auswertung von "
+                        f"Voraussetzung '{req_name}' in Set '{set_name}'."
+                    )
+                    errors.append(msg)
+
+                results.append(
+                    {
+                        "requirement_set_id": set_id,
+                        "requirement_set_name": set_name,
+                        "requirement_name": req_name,
+                        "met": bool(met),
+                        "details": details_str,
+                        "error": error_str,
+                        "status": status_value,
+                    }
+                )
+                requirements_evaluated += 1
+
+    except Exception as e:
+        # hard failure of the orchestrator → log and fall back to per-requirement evaluation
+        msg = f"Unerwarteter Fehler bei der gruppenbasierten Bewertung: {e}"
+        errors.append(msg)
+        logger.exception("evaluate_requirements: %s", msg)
+
+        for req_set in requirement_sets:
+            for req in req_set.requirements.all():
+                met, details, error = safe_evaluate_requirement(
+                    req, pe.patient, mode="strict"
+                )
+                # normalize details to string
+                if not isinstance(details, str):
+                    try:
+                        details = json.dumps(details, ensure_ascii=False, default=str)
+                    except Exception:
+                        details = str(details)
+
+                if not details:
+                    details = (
+                        "Voraussetzung erfüllt"
+                        if met
+                        else "Voraussetzung nicht erfüllt"
+                    )
 
-            requirements_evaluated += 1
+                results.append(
+                    {
+                        "requirement_set_id": req_set.id,
+                        "requirement_set_name": getattr(
+                            req_set, "name", str(req_set.id)
+                        ),
+                        "requirement_name": getattr(req, "name", "unknown"),
+                        "met": bool(met),
+                        "details": details,
+                        "error": error,
+                        "status": "PASSED" if met else "FAILED",
+                    }
+                )
+                requirements_evaluated += 1
 
     # ---- response meta & status summary
     any_errors = len(errors) > 0
@@ -201,79 +267,14 @@ def evaluate_requirements(request):
 
     response_payload = {
         "ok": not any_errors,
-        "errors": errors,  # frontend can render these in a toast / banner
+        "errors": errors,
         "meta": {
             "patientExaminationId": pe_id,
             "setsEvaluated": sets_evaluated,
             "requirementsEvaluated": requirements_evaluated,
-            "status": status_label
+            "status": status_label,
         },
-        "results": results
+        "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)