endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/serializers/pdf/anony_text_validation.py

@@ -0,0 +1,101 @@
+from pathlib import Path
+
+from django.conf import settings
+from rest_framework import serializers
+
+from ...models import RawPdfFile
+
+
+class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch report metadata along with `anonymized_text` from `RawPdfFile`.
+    Ensures Vue.js can process JSON efficiently.
+    """
+
+    pdf_url = serializers.SerializerMethodField()
+    full_pdf_path = serializers.SerializerMethodField()
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = [
+            "id",
+            "file",
+            "pdf_url",
+            "full_pdf_path",
+            "sensitive_meta_id",
+            "anonymized_text",
+        ]
+
+    @staticmethod
+    def get_next_pdf(last_id=None):
+        """
+        Retrieves the first available report if `last_id` is NOT provided.
+        Otherwise, fetches the next available report where `id > last_id`.
+        """
+        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by("id").first()
+        return pdf_entry
+
+    def get_pdf_url(self, obj):
+        """
+        Returns the absolute URL for accessing the anonymized text report endpoint for the given object.
+
+        If the request context or file is missing, returns None.
+        """
+        request = self.context.get("request")
+        return (
+            request.build_absolute_uri(f"/pdf/anony_text/?id={obj.id}")
+            if request and obj.file
+            else None
+        )
+
+    def get_file(self, obj):
+        """
+        Retrieves the relative file path of the report from the model instance.
+
+        Returns:
+            The relative file path as a string, or None if no file is associated.
+        """
+        return str(obj.file.name).strip() if obj.file else None
+
+    def get_full_pdf_path(self, obj):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
+        """
+        if not obj.file:
+            return None
+        pdf_relative_path = str(obj.file.name)
+        full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
+        return str(full_path) if full_path.exists() else None
+
+    def validate_anonymized_text(self, value):
+        """
+        Validates that the anonymized text is non-empty and does not exceed 5000 characters.
+
+        Raises:
+            serializers.ValidationError: If the text is empty or exceeds the length limit.
+        """
+        if not value.strip():
+            raise serializers.ValidationError("Anonymized text cannot be empty.")
+        # FIXME move this to a settings variable @Hamzaukw @maxhild
+        if len(value) > 5000:  # Arbitrary limit to prevent excessively long text
+            raise serializers.ValidationError(
+                "Anonymized text exceeds the maximum length of 5000 characters."
+            )
+        return value
+
+    def update(self, instance, validated_data):
+        """
+        Update the `anonymized_text` field of a RawPdfFile instance with validated data.
+
+        Only the `anonymized_text` field is modified; all other fields remain unchanged.
+
+        Returns:
+            The updated RawPdfFile instance.
+        """
+        instance.anonymized_text = validated_data.get(
+            "anonymized_text", instance.anonymized_text
+        )
+        instance.save()
+        return instance

endoreg_db/serializers/requirements/requirement_schema.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import List
+
+
+class RequirementSchema(BaseModel):
+    id: int
+    name: str
+    description: str
+    satisfied: bool
+    message: str
+
+
+class RequirementSetSchema(BaseModel):
+    id: int
+    name: str
+    description: str
+    is_satisfied: bool
+    requirements: List[RequirementSchema]
+    linked_sets: List["RequirementSetSchema"]
+    messages: List[str]

endoreg_db/serializers/requirements/requirement_sets.py

@@ -0,0 +1,99 @@
+from rest_framework import serializers
+
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+
+
+class RequirementSetSerializer(serializers.ModelSerializer):
+    """
+    Serializer for RequirementSet model with optional tag field.
+
+    This serializer provides a flexible representation of requirement sets,
+    including role-based tags for filtering (e.g., "Gastroenterologist", "Student").
+
+    Fields:
+        id: Primary key
+        name: Display name of the requirement set
+        description: Optional description text
+        requirement_set_type: Type classification
+        tags: List of tag names (optional, read-only)
+    """
+
+    tags = serializers.SlugRelatedField(
+        many=True, read_only=True, slug_field="name", required=False
+    )
+
+    requirement_set_type = serializers.CharField(
+        source="requirement_set_type.name", read_only=True, allow_null=True
+    )
+
+    class Meta:
+        model = RequirementSet
+        fields = ["id", "name", "description", "requirement_set_type", "tags"]
+
+    def to_representation(self, instance):
+        """
+        Customize representation to exclude tags field if empty or not prefetched.
+
+        This prevents N+1 query issues and keeps the response clean when tags
+        aren't needed or weren't prefetched in the queryset.
+        """
+        representation = super().to_representation(instance)
+
+        # Only include tags if they exist and were prefetched
+        if not representation.get("tags"):
+            representation.pop("tags", None)
+
+        return representation
+
+
+def requirement_set_to_dict(requirement_set: RequirementSet) -> dict:
+    """
+    Convert a RequirementSet instance to a dictionary representation.
+
+    This function performs additional queries to fetch related data including
+    requirements and linked sets. Use RequirementSetSerializer for simpler
+    representations without the overhead of additional queries.
+
+    Args:
+        requirement_set: The RequirementSet instance to convert.
+
+    Returns:
+        Dictionary representation of the RequirementSet with full nested details:
+        - id, name, description: Basic metadata
+        - requirements: List of requirement dictionaries
+        - links: List of linked requirement set data
+        - tags: List of tag names (if any exist)
+    """
+    # Fetch the requirement set with all related data to avoid N+1 queries
+    requirement_set_full = (
+        RequirementSet.objects.select_related("requirement_set_type")
+        .prefetch_related("requirements", "links_to_sets", "tags")
+        .get(pk=requirement_set.pk)
+    )
+
+    # Get linked requirement sets
+    linked_sets = requirement_set_full.links_to_sets.all()
+
+    result = {
+        "id": requirement_set_full.pk,
+        "name": requirement_set_full.name,
+        "description": requirement_set_full.description or "",
+        "requirement_set_type": requirement_set_full.requirement_set_type.name
+        if requirement_set_full.requirement_set_type
+        else None,
+        "requirements": [
+            {"id": req.pk, "name": req.name, "description": req.description or ""}
+            for req in requirement_set_full.requirements.all()
+        ],
+        "linked_sets": [
+            {"id": link.pk, "name": link.name, "description": link.description or ""}
+            for link in linked_sets
+        ],
+    }
+
+    # Add tags if they exist
+    tags = list(requirement_set_full.tags.values_list("name", flat=True))
+    if tags:
+        result["tags"] = tags
+
+    return result

endoreg_db/serializers/sensitive_meta_serializer.py

@@ -0,0 +1,301 @@
+from rest_framework import serializers
+from django.db import transaction
+import logging
+
+from ..models import SensitiveMeta, Center, Gender
+
+logger = logging.getLogger(__name__)
+
+
+class SensitiveMetaDetailSerializer(serializers.ModelSerializer):
+    """
+    Serializer for displaying SensitiveMeta details with verification state.
+    Includes all relevant fields for annotation and verification.
+    """
+
+    # State verification fields
+    is_verified = serializers.SerializerMethodField()
+    dob_verified = serializers.SerializerMethodField()
+    names_verified = serializers.SerializerMethodField()
+
+    # Related fields for better display
+    center_name = serializers.CharField(source="center.name", read_only=True)
+    patient_gender_name = serializers.CharField(
+        source="patient_gender.name", read_only=True
+    )
+
+    # Examiner information
+    examiners_display = serializers.SerializerMethodField()
+
+    # Formatted dates for display
+    patient_dob_display = serializers.SerializerMethodField()
+    examination_date_display = serializers.SerializerMethodField()
+
+    # Hash displays (last 8 characters for security)
+    patient_hash_display = serializers.SerializerMethodField()
+    examination_hash_display = serializers.SerializerMethodField()
+
+    class Meta:
+        model = SensitiveMeta
+        fields = [
+            "id",
+            "patient_first_name",
+            "patient_last_name",
+            "patient_dob",
+            "patient_dob_display",
+            "examination_date",
+            "examination_date_display",
+            "center_name",
+            "patient_gender_name",
+            "endoscope_type",
+            "endoscope_sn",
+            "patient_hash_display",
+            "examination_hash_display",
+            "examiners_display",
+            "is_verified",
+            "dob_verified",
+            "names_verified",
+        ]
+        read_only_fields = [
+            "id",
+            "patient_hash_display",
+            "examination_hash_display",
+        ]
+
+    def get_is_verified(self, obj):
+        """Get overall verification status."""
+        try:
+            return obj.is_verified
+        except AttributeError:
+            return False
+        except Exception as e:
+            logger.exception(
+                f"Unexpected error in get_is_verified for SensitiveMeta {getattr(obj, 'pk', None)}: {e}"
+            )
+            raise
+
+    def get_dob_verified(self, obj):
+        """Get DOB verification status."""
+        try:
+            return obj.state.dob_verified
+        except Exception:
+            return False
+
+    def get_names_verified(self, obj):
+        """Get names verification status."""
+        try:
+            return obj.state.names_verified
+        except Exception:
+            return False
+
+    def get_examiners_display(self, obj):
+        """Get formatted examiner names."""
+        try:
+            if obj.pk:
+                examiners = obj.examiners.all()
+                return [f"{e.first_name} {e.last_name}" for e in examiners]
+            return []
+        except Exception as e:
+            logger.warning(f"Error getting examiners for SensitiveMeta {obj.pk}: {e}")
+            return []
+
+    def get_patient_dob_display(self, obj):
+        """Get formatted DOB for display."""
+        if obj.patient_dob:
+            return obj.patient_dob.strftime("%Y-%m-%d")
+        return None
+
+    def get_examination_date_display(self, obj):
+        """Get formatted examination date for display."""
+        if obj.examination_date:
+            return obj.examination_date.strftime("%Y-%m-%d")
+        return None
+
+    def get_patient_hash_display(self, obj):
+        """Get truncated patient hash for display."""
+        if obj.patient_hash:
+            return f"...{obj.patient_hash[-8:]}"
+        return None
+
+    def get_examination_hash_display(self, obj):
+        """Get truncated examination hash for display."""
+        if obj.examination_hash:
+            return f"...{obj.examination_hash[-8:]}"
+        return None
+
+
+class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer for updating SensitiveMeta fields including verification state.
+    Handles partial updates and state management.
+    """
+
+    # Verification state fields
+    dob_verified = serializers.BooleanField(required=False)
+    names_verified = serializers.BooleanField(required=False)
+
+    # Center can be updated by name
+    center_name = serializers.CharField(write_only=True, required=False)
+
+    # Gender can be updated by name
+    patient_gender_name = serializers.CharField(write_only=True, required=False)
+
+    class Meta:
+        model = SensitiveMeta
+        fields = [
+            "patient_first_name",
+            "patient_last_name",
+            "patient_dob",
+            "examination_date",
+            "center_name",
+            "patient_gender_name",
+            "endoscope_type",
+            "endoscope_sn",
+            "examiner_first_name",
+            "examiner_last_name",
+            "dob_verified",
+            "names_verified",
+        ]
+
+    def validate_center_name(self, value):
+        """Validate center exists and return the instance."""
+        if value:
+            try:
+                # Return the instance to avoid double query in update()
+                return Center.objects.get_by_natural_key(value)
+            except Center.DoesNotExist:
+                raise serializers.ValidationError(f"Center '{value}' does not exist.")
+        return value
+
+    def validate_patient_gender_name(self, value):
+        """Validate gender exists and return the instance."""
+        if value:
+            try:
+                # Return the instance to avoid double query in update()
+                return Gender.objects.get(name=value)
+            except Gender.DoesNotExist:
+                raise serializers.ValidationError(f"Gender '{value}' does not exist.")
+        return value
+
+    def validate(self, data):
+        """Custom validation for the entire data set."""
+        # Guard against None values before calling strip()
+        first_name = data.get("patient_first_name")
+        if first_name is not None and not first_name.strip():
+            raise serializers.ValidationError(
+                {"patient_first_name": "First name cannot be empty."}
+            )
+
+        last_name = data.get("patient_last_name")
+        if last_name is not None and not last_name.strip():
+            raise serializers.ValidationError(
+                {"patient_last_name": "Last name cannot be empty."}
+            )
+
+        return data
+
+    @transaction.atomic
+    def update(self, instance, validated_data):
+        """
+        Update SensitiveMeta instance and its related state.
+        Handles both model fields and verification state.
+        """
+        # Extract verification state data
+        dob_verified = validated_data.pop("dob_verified", None)
+        names_verified = validated_data.pop("names_verified", None)
+
+        # -- center -------------------------------------------------
+        center = validated_data.pop("center_name", None)
+        if isinstance(center, Center):  # returned by validate_center_name
+            instance.center = center
+
+        # -- gender -------------------------------------------------
+        gender = validated_data.pop("patient_gender_name", None)
+        if isinstance(gender, Gender):  # returned by validate_patient_gender_name
+            instance.patient_gender = gender
+
+        # -- ordinary fields ---------------------------------------
+        if validated_data:
+            instance.update_from_dict(validated_data)  # should NOT call save()
+
+        # -- verification state ------------------------------------
+        if dob_verified is not None or names_verified is not None:
+            state = instance.get_or_create_state()
+            if dob_verified is not None:
+                state.dob_verified = dob_verified
+                logger.info(
+                    f"Updated DOB verification for SensitiveMeta {instance.pk}: {dob_verified}"
+                )
+            if names_verified is not None:
+                state.names_verified = names_verified
+                logger.info(
+                    f"Updated names verification for SensitiveMeta {instance.pk}: {names_verified}"
+                )
+            state.save()
+
+        # -- finally persist the model itself ----------------------
+        instance.save()
+        return instance
+
+
+class SensitiveMetaVerificationSerializer(serializers.Serializer):
+    """
+    Simple serializer for bulk verification state updates.
+    Used when only updating verification flags.
+    """
+
+    sensitive_meta_id = serializers.IntegerField()
+    dob_verified = serializers.BooleanField(required=False)
+    names_verified = serializers.BooleanField(required=False)
+
+    def validate_sensitive_meta_id(self, value):
+        """Ensure SensitiveMeta exists."""
+        try:
+            SensitiveMeta.objects.get(id=value)
+            return value
+        except SensitiveMeta.DoesNotExist:
+            raise serializers.ValidationError(
+                f"SensitiveMeta with ID {value} does not exist."
+            )
+
+    @transaction.atomic
+    def save(self):
+        """Update verification state for the specified SensitiveMeta with proper locking."""
+        sensitive_meta_id = self.validated_data["sensitive_meta_id"]
+        dob_verified = self.validated_data.get("dob_verified")
+        names_verified = self.validated_data.get("names_verified")
+
+        try:
+            # Use select_for_update for strong consistency in concurrent environments
+            sensitive_meta = SensitiveMeta.objects.select_for_update().get(
+                id=sensitive_meta_id
+            )
+            state = sensitive_meta.get_or_create_state()
+
+            if dob_verified is not None:
+                state.dob_verified = dob_verified
+
+            if names_verified is not None:
+                state.names_verified = names_verified
+
+            state.save()
+
+            # Only log the ID to avoid potential PII leakage
+            logger.info(
+                f"Updated verification state for SensitiveMeta ID {sensitive_meta_id}"
+            )
+            return state
+
+        except SensitiveMeta.DoesNotExist:
+            logger.error(
+                f"SensitiveMeta ID {sensitive_meta_id} not found during verification update"
+            )
+            raise serializers.ValidationError(
+                f"SensitiveMeta with ID {sensitive_meta_id} does not exist."
+            )
+        except Exception as e:
+            # Log the exception class but not the full details to avoid PII leakage
+            logger.error(
+                f"Error updating verification state for ID {sensitive_meta_id}: {type(e).__name__}"
+            )
+            raise serializers.ValidationError("Failed to update verification state.")

endoreg_db/serializers/video/__init__.py

@@ -0,0 +1,7 @@
+from .video_file import (
+    VideoFileSerializer,
+)
+
+__all__ = [
+    "VideoFileSerializer",
+]