endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

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)