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

endoreg_db/views/pdf/reimport.py

@@ -53,13 +53,9 @@ class PdfReimportView(APIView):
         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}"
-            )
+            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."
-                },
+                {"error": f"Raw PDF file not found for PDF {pdf.pdf_hash}. Please upload the original file again."},
                 status=status.HTTP_404_NOT_FOUND,
             )
 
@@ -79,10 +75,8 @@ class PdfReimportView(APIView):
                 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
+                    logger.info(f"Clearing existing SensitiveMeta {old_meta_id} for PDF {pdf.pdf_hash}")
+                    pdf.sensitive_meta = None
                     pdf.save(update_fields=["sensitive_meta"])
 
                     # Delete the old SensitiveMeta record
@@ -90,15 +84,11 @@ class PdfReimportView(APIView):
                         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}"
-                        )
+                        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}"
-                    )
+                    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,
@@ -106,9 +96,7 @@ class PdfReimportView(APIView):
                         retry=True,  # Mark as retry attempt
                     )
 
-                    logger.info(
-                        f"PdfImportService reprocessing completed for {pdf.pdf_hash}"
-                    )
+                    logger.info(f"PdfImportService reprocessing completed for {pdf.pdf_hash}")
 
                     # Refresh to get updated state
                     pdf.refresh_from_db()
@@ -119,9 +107,7 @@ class PdfReimportView(APIView):
                             "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,
+                            "sensitive_meta_id": pdf.sensitive_meta.pk if pdf.sensitive_meta else None,
                             "text_extracted": bool(pdf.text),
                             "anonymized": pdf.anonymized,
                             "status": "done",
@@ -130,9 +116,7 @@ class PdfReimportView(APIView):
                     )
 
                 except Exception as e:
-                    logger.exception(
-                        f"PdfImportService reprocessing failed for PDF {pdf.pdf_hash}: {e}"
-                    )
+                    logger.exception(f"PdfImportService reprocessing failed for PDF {pdf.pdf_hash}: {e}")
                     return Response(
                         {
                             "error": f"Reprocessing failed: {str(e)}",
@@ -144,16 +128,11 @@ class PdfReimportView(APIView):
                     )
 
         except Exception as e:
-            logger.error(
-                f"Failed to re-import PDF {pdf.pdf_hash}: {str(e)}", exc_info=True
-            )
+            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"]
-            ):
+            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(
                     {

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)

endoreg_db/views/requirement/lookup.py

@@ -13,6 +13,7 @@ from rest_framework.response import Response
 from endoreg_db.services import lookup_service as ls
 from endoreg_db.services.lookup_store import DEFAULT_TTL_SECONDS, LookupStore
 from endoreg_db.utils.permissions import EnvironmentAwarePermission
+from endoreg_db.models.other.tag import Tag
 
 ORIGIN_MAP_PREFIX = "lookup:origin:"
 ISSUED_MAP_PREFIX = "lookup:issued_for_internal:"
@@ -53,6 +54,8 @@ class LookupViewSet(viewsets.ViewSet):
         "selectedRequirementSetIds",
         "selectedChoices",
     }
+    
+    user_tags = Tag
 
     @action(detail=False, methods=["post"])
     def init(self, request):
@@ -131,7 +134,10 @@ class LookupViewSet(viewsets.ViewSet):
 
                 except Exception:
                     pass
-
+        
+        user_tags = request.data.get("user_tags", None)
+        if user_tags and not isinstance(user_tags, list):
+            user_tags = [user_tags]
         # Fallback to query params
         if raw_pe is None:
             raw_pe = request.query_params.get("patient_examination_id")
@@ -167,7 +173,11 @@ class LookupViewSet(viewsets.ViewSet):
 
         try:
             # Create internal session via service (may seed its own token/cache)
-            internal_token = ls.create_lookup_token_for_pe(pe_id)
+            service_kwargs = {}
+            if user_tags:
+                service_kwargs["user_tags"] = user_tags
+
+            internal_token = ls.create_lookup_token_for_pe(pe_id, **service_kwargs)
             internal_data = LookupStore(token=internal_token).get_all()
 
             issued_key = f"{ISSUED_MAP_PREFIX}{internal_token}"
@@ -254,7 +264,11 @@ class LookupViewSet(viewsets.ViewSet):
                             status=status.HTTP_404_NOT_FOUND,
                         )
 
-                    return Response(new_data, status=status.HTTP_200_OK)
+                    # Hydrate the original token with recovered data and refresh origin TTL
+                    store.set_many(new_data)
+                    cache.set(f"{ORIGIN_MAP_PREFIX}{pk}", pe_id, DEFAULT_TTL_SECONDS)
+                    return Response(store.get_all(), status=status.HTTP_200_OK)
+
 
                 except Exception:
                     pass