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

endoreg_db/views/anonymization/overview.py

@@ -11,6 +11,8 @@ from rest_framework.pagination import PageNumberPagination
 from endoreg_db.models import VideoFile, RawPdfFile
 from ...serializers import FileOverviewSerializer, VoPPatientDataSerializer
 from django.http import JsonResponse
+
+from endoreg_db.authz.permissions import PolicyPermission  #  import RBAC
 import logging
 logger = logging.getLogger(__name__)
 PERMS = DEBUG_PERMISSIONS   # shorten
@@ -27,7 +29,8 @@ class AnonymizationOverviewView(ListAPIView):
     Returns a flat list (Video + PDF) ordered by newest upload first.
     """
     serializer_class = FileOverviewSerializer
-    permission_classes = DEBUG_PERMISSIONS   
+    #permission_classes = DEBUG_PERMISSIONS   
+    permission_classes = [PolicyPermission]
     pagination_class = NoPagination
 
     def get_queryset(self):

endoreg_db/views/anonymization/validate.py

@@ -7,9 +7,9 @@ from rest_framework.response import Response
 from rest_framework.views import APIView
 
 from endoreg_db.models import RawPdfFile, VideoFile
+from endoreg_db.models.metadata import SensitiveMeta
 from endoreg_db.serializers.anonymization import SensitiveMetaValidateSerializer
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -19,16 +19,23 @@ class AnonymizationValidateView(APIView):
     
     Validiert und aktualisiert SensitiveMeta-Felder für Videos oder PDFs.
     
+    DATA HERE IS COMING FROM THE ANONYIZATION VALIDATION COMPONENT
+    
     Body (Datumsfelder bevorzugt in deutschem Format DD.MM.YYYY; ISO YYYY-MM-DD ebenfalls akzeptiert):
     {
       "patient_first_name": "Max",
       "patient_last_name":  "Mustermann",
       "patient_dob":        "21.03.1994",      // DD.MM.YYYY bevorzugt
+      "patient_gender":     "male"
       "examination_date":   "15.02.2024",      // DD.MM.YYYY bevorzugt
+
       "casenumber":         "12345",
       "anonymized_text":    "...",             // nur für PDFs; Videos ignorieren
       "is_verified":        true               // optional; default true
       "file_type":        "video"            // optional; "video" oder "pdf"; wenn nicht angegeben, wird zuerst Video, dann PDF versucht
+      "center_name":       editedPatient.value.centerName || '',
+      "external_id":       editedPatient.value.externalId || '',
+      "external_id_origin":editedPatient.value.externalIdOrigin || '', 
     }
     
     Rückwärtskompatibilität: ISO-Format (YYYY-MM-DD) wird ebenfalls akzeptiert.
@@ -41,67 +48,194 @@ class AnonymizationValidateView(APIView):
         serializer.is_valid(raise_exception=True)
         validated_data = cast(Dict[str, Any], serializer.validated_data)
         payload: Dict[str, Any] = dict(validated_data)
+
+        # Default ist_verified = True
         if "is_verified" not in payload:
             payload["is_verified"] = True
 
         file_type = payload.get("file_type")
 
-        # Try Video first (unless explicitly requesting PDF)
-        if file_type in (None, "video"):
-            video = VideoFile.objects.select_related("center").filter(pk=file_id).first()
-            if video is not None:
-                prepared_payload = self._prepare_payload(payload, video)
-                try:
-                    ok = video.validate_metadata_annotation(prepared_payload)
-                except Exception:  # pragma: no cover - defensive safety net
-                    logger.exception("Video validation crashed for id=%s", file_id)
+        with transaction.atomic():
+            # Try Video first (unless explicitly requesting PDF)
+            if file_type in (None, "video"):
+                video = (
+                    VideoFile.objects.select_related("center", "sensitive_meta", "state")
+                    .filter(pk=file_id)
+                    .first()
+                )
+                if video is not None:
+                    prepared_payload = self._prepare_payload(payload, video)
+                    try:
+                        ok = video.validate_metadata_annotation(prepared_payload)
+                    except Exception:  # pragma: no cover - defensive safety net
+                        logger.exception("Video validation crashed for id=%s", file_id)
+                        return Response(
+                            {
+                                "error": "Video validation encountered an unexpected error."
+                            },
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        )
+
+                    if not ok:
+                        return Response(
+                            {"error": "Video validation failed."},
+                            status=status.HTTP_400_BAD_REQUEST,
+                        )
+
+                    # this is here for tests!
+                    if video.sensitive_meta is None:
+                        sm = SensitiveMeta.objects.create(center=video.center)
+                        video.sensitive_meta = sm
+
+                    video.save(update_fields=["sensitive_meta"])
+                    video.sensitive_meta.get_or_create_state()
+                    if video.sensitive_meta.state is not None:
+                        video.sensitive_meta.state.refresh_from_db()
+                        video.sensitive_meta.state.mark_dob_verified()
+                        video.sensitive_meta.state.mark_names_verified()
+                        video.sensitive_meta.create_anonymized_record()
+                    else:
+                        return Response(
+                            {
+                                "message": "Video not validated, failed to create State."
+                            },
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        )
+
+                    if video.state is not None:
+                        video.state.anonymized = True
+                        video.sensitive_meta.state.save()
+
                     return Response(
-                        {"error": "Video validation encountered an unexpected error."},
-                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        {"message": "Video validated."},
+                        status=status.HTTP_200_OK,
                     )
 
-                if not ok:
-                    return Response({"error": "Video validation failed."}, status=status.HTTP_400_BAD_REQUEST)
-
-                return Response({"message": "Video validated."}, status=status.HTTP_200_OK)
-
-            if file_type == "video":
-                return Response({"error": f"Video {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
-
-        # Then PDF (unless explicitly requesting Video)
-        if file_type in (None, "pdf"):
-            pdf = RawPdfFile.objects.select_related("center").filter(pk=file_id).first()
-            if pdf is not None:
-                prepared_payload = self._prepare_payload(payload, pdf)
-                try:
-                    ok = pdf.validate_metadata_annotation(prepared_payload)
-                except Exception:  # pragma: no cover - defensive safety net
-                    logger.exception("PDF validation crashed for id=%s", file_id)
+                if file_type == "video":
                     return Response(
-                        {"error": "PDF validation encountered an unexpected error."},
-                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        {"error": f"Video {file_id} not found."},
+                        status=status.HTTP_404_NOT_FOUND,
                     )
 
-                if not ok:
-                    return Response({"error": "PDF validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+            # Then PDF (unless explicitly requesting Video)
+            if file_type in (None, "pdf"):
+                pdf = (
+                    RawPdfFile.objects.select_related("center", "sensitive_meta", "state")
+                    .filter(pk=file_id)
+                    .first()
+                )
+                if pdf is not None:
+                    prepared_payload = self._prepare_payload(payload, pdf)
+                    try:
+                        ok = pdf.validate_metadata_annotation(prepared_payload)
+                    except Exception:  # pragma: no cover - defensive safety net
+                        logger.exception("PDF validation crashed for id=%s", file_id)
+                        return Response(
+                            {
+                                "error": "PDF validation encountered an unexpected error."
+                            },
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        )
+
+                    # sanity logging – but don't break flow
+                    try:
+                        assert pdf.sensitive_meta is not None
+                        assert pdf.sensitive_meta.state is not None
+                    except AssertionError as e:
+                        logger.error("%s", e)
+
+                    if not ok:
+                        return Response(
+                            {"error": "PDF validation failed."},
+                            status=status.HTTP_400_BAD_REQUEST,
+                        )
+                    else:
+                        # this is here for tests!
+                        if pdf.sensitive_meta is None:
+                            sm = SensitiveMeta.objects.create(center=pdf.center)
+                            pdf.sensitive_meta = sm
+
+                        pdf.save(update_fields=["sensitive_meta"])
+                        pdf.sensitive_meta.get_or_create_state()
+                        if (
+                            pdf.sensitive_meta
+                            and pdf.sensitive_meta.state
+                            and pdf.state
+                        ):
+                            pdf.sensitive_meta.state.refresh_from_db()
+                            pdf.sensitive_meta.state.mark_dob_verified()
+                            pdf.sensitive_meta.state.mark_names_verified()
+                            pdf.sensitive_meta.create_anonymized_record()
+                            pdf.state.anonymized = True
+                            pdf.sensitive_meta.state.save()
+                        else:
+                            return Response(
+                                {
+                                    "message": "PDF not validated, failed to create State."
+                                },
+                                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            )
 
-                return Response({"message": "PDF validated."}, status=status.HTTP_200_OK)
+                    return Response(
+                        {"message": "PDF validated."},
+                        status=status.HTTP_200_OK,
+                    )
 
-            if file_type == "pdf":
-                return Response({"error": f"PDF {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+                if file_type == "pdf":
+                    return Response(
+                        {"error": f"PDF {file_id} not found."},
+                        status=status.HTTP_404_NOT_FOUND,
+                    )
 
-        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)
+        return Response(
+            {"error": f"Item {file_id} not found as video or pdf."},
+            status=status.HTTP_404_NOT_FOUND,
+        )
 
     @staticmethod
     def _prepare_payload(base_payload: Dict[str, Any], file_obj: Any) -> Dict[str, Any]:
-        """Return a fresh payload tailored for the given file object."""
+        """
+        Return a fresh payload tailored for the given file object.
+
+        - Strips `file_type` before forwarding to validators.
+        - Injects `center_name` from the file's center if not already present.
+        - Normalizes `patient_gender` if present, but does NOT require it.
+        """
+        prepared: Dict[str, Any] = dict(base_payload)
 
-        prepared = dict(base_payload)
+        # never send file_type to validators
         prepared.pop("file_type", None)
 
+        # center_name from file.center if not already set
         center = getattr(file_obj, "center", None)
         center_name = getattr(center, "name", None)
         if center_name and not prepared.get("center_name"):
             prepared["center_name"] = center_name
 
-        return prepared
+        # Gender normalization: optional, robust against missing or unknown values
+        raw_gender = base_payload.get("patient_gender", None)
+        if raw_gender is None:
+            # nothing provided → don't touch gender
+            return prepared
+
+        gender = str(raw_gender).strip().lower()
+
+        # empty string behaves as "not set" – don't override anything
+        if gender == "":
+            return prepared
+
+        male_values = {"m", "male", "männlich"}
+        female_values = {"w", "f", "female", "weiblich"}
+
+        if gender in male_values:
+            prepared["patient_gender"] = "male"
+        elif gender in female_values:
+            prepared["patient_gender"] = "female"
+        else:
+            # keep existing semantics: unknown values default to "male"
+            logger.warning(
+                "Unsupported patient_gender value %r; defaulting to 'male'", raw_gender
+            )
+            prepared["patient_gender"] = "male"
+
+        return prepared

endoreg_db/views/media/__init__.py

@@ -15,6 +15,7 @@ from .video_segments import (
     video_segments_validation_status,
 )
 from .sensitive_metadata import (
+    get_sensitive_metadata_pk,
     video_sensitive_metadata,
     video_sensitive_metadata_verify,
     pdf_sensitive_metadata,
@@ -28,6 +29,7 @@ __all__ = [
     'PdfMediaView',
     'VideoReimportView',
     'PdfReimportView',
+    'get_sensitive_metadata_pk',
     'video_segments_by_pk',
     'video_segments_collection',
     'video_segments_by_video',