endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/serializers/meta/sensitive_meta_verification.py

@@ -0,0 +1,59 @@
+from rest_framework import serializers
+import logging
+
+from ...models import SensitiveMeta
+
+logger = logging.getLogger(__name__)
+
+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):
+        """
+        Validates that a SensitiveMeta object with the given ID exists and caches it.
+        
+        Raises:
+            ValidationError: If no SensitiveMeta object is found with the specified ID.
+        """
+        try:
+            # Retrieve and cache the SensitiveMeta instance to avoid a second query in the save method.
+            self._cached_sensitive_meta = SensitiveMeta.objects.get(id=value)
+            return value
+        except SensitiveMeta.DoesNotExist:
+            raise serializers.ValidationError(f"SensitiveMeta with ID {value} does not exist.")
+
+    def save(self):
+        """
+        Updates the verification state for a specified SensitiveMeta instance.
+        
+        Uses the cached SensitiveMeta object from validation, obtains or creates its verification state, 
+        updates the `dob_verified` and `names_verified` fields if provided, and saves the changes.
+        
+        Returns:
+            The updated verification state object.
+        """
+        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')
+        
+        # Use the cached instance from the validation step, avoiding a redundant query.
+        sensitive_meta = self._cached_sensitive_meta
+        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()
+        
+        logger.info(f"Updated verification state for SensitiveMeta {sensitive_meta_id}")
+        return state

endoreg_db/serializers/meta/video_meta.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from rest_framework import serializers
+from endoreg_db.models import VideoMeta, VideoImportMeta
+
+
+class VideoMetaSerializer(serializers.ModelSerializer):
+    fps = serializers.FloatField(read_only=True, allow_null=True)
+    duration = serializers.FloatField(read_only=True, allow_null=True)
+    width = serializers.IntegerField(read_only=True, allow_null=True)
+    height = serializers.IntegerField(read_only=True, allow_null=True)
+    frame_count = serializers.IntegerField(read_only=True, allow_null=True)
+    created_at = serializers.SerializerMethodField()
+
+    def get_created_at(self, obj):
+        # returns created_at if your model has it, else None
+        return getattr(obj, "created_at", None)
+
+    class Meta:
+        model = VideoMeta
+        fields = (
+            "id",
+            "fps",
+            "duration",
+            "width",
+            "height",
+            "frame_count",
+            "created_at",
+        )
+
+
+class VideoImportMetaSerializer(serializers.ModelSerializer):
+    file_name = serializers.SerializerMethodField()
+
+    def get_file_name(self, obj):
+        return Path(obj.file_name).name if obj.file_name else None
+
+    class Meta:
+        model = VideoImportMeta
+        fields = ("id", "file_name", "video_anonymized")

endoreg_db/serializers/misc/__init__.py

@@ -0,0 +1,14 @@
+from .file_overview import FileOverviewSerializer
+from .sensitive_patient_data import VoPPatientDataSerializer
+from .stats import StatsSerializer
+from .upload_job import UploadJobStatusSerializer, UploadCreateResponseSerializer
+from .translatable_field_mix_in import TranslatableFieldMixin
+
+__all__ = [
+    "FileOverviewSerializer",
+    "VoPPatientDataSerializer",
+    "StatsSerializer",
+    "UploadJobStatusSerializer",
+    "UploadCreateResponseSerializer",
+    "TranslatableFieldMixin"
+]

endoreg_db/serializers/misc/file_overview.py

@@ -0,0 +1,182 @@
+from typing import TYPE_CHECKING
+
+from rest_framework import serializers
+
+from endoreg_db.models.media import RawPdfFile, VideoFile
+from endoreg_db.models.state.raw_pdf import (
+    AnonymizationStatus as PdfAnonymizationStatus,
+)
+from endoreg_db.models.state.video import (
+    AnonymizationStatus as VideoAnonymizationStatus,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+class FileOverviewSerializer(serializers.Serializer):
+    """
+    Polymorphic "union" serializer – we normalise both model types
+    (VideoFile, RawPdfFile) into the data structure the Vue store needs.
+    """
+
+    # --- fields expected by the front-end ---------------------------
+    # All fields are read_only since they're computed in to_representation
+    id = serializers.IntegerField(read_only=True)
+    filename = serializers.CharField(read_only=True)
+    mediaType = serializers.CharField(read_only=True)
+    anonymizationStatus = serializers.CharField(read_only=True)
+    annotationStatus = serializers.CharField(read_only=True)
+    createdAt = serializers.DateTimeField(read_only=True)
+    text = serializers.CharField(required=False, allow_blank=True, read_only=True)
+    anonymizedText = serializers.CharField(
+        required=False, allow_blank=True, read_only=True
+    )
+
+    # --- converting DB objects to that shape -----------------------
+    def to_representation(self, instance):
+        """
+        Return a unified dictionary representation of either a VideoFile or RawPdfFile instance for front-end use.
+
+        For VideoFile instances, extracts and structures metadata such as patient, examination, equipment, and examiner information, and generates an anonymized version of the text by replacing sensitive fields with placeholders. For RawPdfFile instances, extracts text and anonymized text directly and determines statuses based on available fields.
+
+        Parameters:
+            instance: A VideoFile or RawPdfFile object to be serialized.
+
+        Returns:
+            dict: A normalized dictionary containing id, filename, mediaType, anonymizationStatus, annotationStatus, createdAt, text, and anonymizedText fields.
+
+        Raises:
+            TypeError: If the instance is not a VideoFile or RawPdfFile.
+        """
+        text = ""
+        anonym_text = ""
+
+        if isinstance(instance, VideoFile):
+            media_type = "video"
+            created_at = instance.uploaded_at
+            filename = instance.original_file_name or (
+                instance.raw_file.name.split("/")[-1]
+                if instance.raw_file
+                else "unknown"
+            )
+
+            # ------- anonymization status using VideoState model
+            vs = instance.state
+            anonym_status = (
+                vs.anonymization_status if vs else VideoAnonymizationStatus.NOT_STARTED
+            )
+
+            # ------- annotation status (validated label segments)
+            if instance.label_video_segments.filter(state__is_validated=True).exists():
+                annot_status = "done"
+            else:
+                annot_status = "not_started"
+
+            # ------- Extract text from sensitive_meta for videos
+            if instance.sensitive_meta:
+                sm = instance.sensitive_meta
+                # Create a structured text representation from sensitive meta
+                text_parts = []
+
+                # Patient information
+                if sm.patient_first_name or sm.patient_last_name:
+                    patient_name = f"{sm.patient_first_name or ''} {sm.patient_last_name or ''}".strip()
+                    text_parts.append(f"Patient: {patient_name}")
+
+                if sm.patient_dob:
+                    text_parts.append(f"Date of Birth: {sm.patient_dob.date()}")
+
+                if sm.patient_gender:
+                    text_parts.append(f"Gender: {sm.patient_gender}")
+
+                # Examination information
+                if sm.examination_date:
+                    text_parts.append(f"Examination Date: {sm.examination_date}")
+
+                if sm.center:
+                    text_parts.append(f"Center: {sm.center.name}")
+
+                # Equipment information
+                if sm.endoscope_type:
+                    text_parts.append(f"Endoscope Type: {sm.endoscope_type}")
+
+                if sm.endoscope_sn:
+                    text_parts.append(f"Endoscope SN: {sm.endoscope_sn}")
+
+                # Examiner information
+                if sm.pk:  # Only if saved
+                    try:
+                        examiners = list(sm.examiners.all())
+                        if examiners:
+                            examiner_names = ", ".join(str(e) for e in examiners)
+                            text_parts.append(f"Examiners: {examiner_names}")
+                    except Exception:
+                        pass  # Ignore examiner lookup errors
+
+                text = "\n".join(text_parts)
+
+                # Create anonymized version by replacing sensitive data
+                anonym_text = text
+                if sm.patient_first_name:
+                    anonym_text = anonym_text.replace(
+                        sm.patient_first_name, "[FIRST_NAME]"
+                    )
+                if sm.patient_last_name:
+                    anonym_text = anonym_text.replace(
+                        sm.patient_last_name, "[LAST_NAME]"
+                    )
+                if sm.patient_dob:
+                    anonym_text = anonym_text.replace(
+                        str(sm.patient_dob.date()), "[DOB]"
+                    )
+                if sm.endoscope_sn:
+                    anonym_text = anonym_text.replace(sm.endoscope_sn, "[ENDOSCOPE_SN]")
+
+                # Replace examiner names if available
+                if sm.pk:
+                    try:
+                        examiners = list(sm.examiners.all())
+                        for examiner in examiners:
+                            anonym_text = anonym_text.replace(
+                                str(examiner), "[EXAMINER]"
+                            )
+                    except Exception:
+                        pass
+
+        elif isinstance(instance, RawPdfFile):
+            instance: RawPdfFile
+            media_type = "pdf"
+            created_at = instance.date_created
+            filename = instance.file.name.split("/")[-1] if instance.file else "unknown"
+
+            # ------- anonymization status using RawPdfState model (like VideoFile)
+            ps = instance.state
+            anonym_status = (
+                ps.anonymization_status if ps else PdfAnonymizationStatus.NOT_STARTED
+            )
+
+            # PDF annotation == "sensitive meta validated"
+            annot_status = (
+                "done"
+                if getattr(instance.sensitive_meta, "is_verified", False)
+                else "not_started"
+            )
+
+            # Extract text content from PDF
+            text = instance.text or ""
+            anonym_text = instance.anonymized_text or ""
+
+        else:  # shouldn't happen
+            raise TypeError(f"Unsupported instance for overview: {type(instance)}")
+
+        return {
+            "id": instance.pk,
+            "filename": filename,
+            "mediaType": media_type,
+            "anonymizationStatus": anonym_status,
+            "annotationStatus": annot_status,
+            "createdAt": created_at,
+            "text": text,
+            "anonymizedText": anonym_text,
+        }

endoreg_db/serializers/misc/sensitive_patient_data.py

@@ -0,0 +1,120 @@
+from endoreg_db.models.media import RawPdfFile, VideoFile
+
+
+from rest_framework import serializers
+
+#TODO add this "naming convention" to the documentation
+# VoP: Video or Pdf
+
+class VoPPatientDataSerializer(serializers.Serializer):
+    """
+    Serializer that converts a VideoFile or RawPdfFile to the structure 
+    the Pinia store needs for validation workflow.
+    """
+
+    # Mark all fields as read_only since they're computed in to_representation
+    id = serializers.IntegerField(read_only=True)
+    sensitiveMetaId = serializers.IntegerField(read_only=True)
+    text = serializers.CharField(read_only=True)
+    anonymizedText = serializers.CharField(read_only=True)
+    reportMeta = serializers.JSONField(read_only=True)
+    status = serializers.CharField(read_only=True)
+    error = serializers.BooleanField(read_only=True)
+
+    def to_representation(self, instance):
+        """
+        Serialize a VideoFile or RawPdfFile instance into a structured dictionary for validation workflows.
+        
+        Depending on the instance type, constructs a dictionary containing identifiers, sensitive metadata, text summaries, anonymized text, processing status, and error flag. For VideoFile instances, generates a text summary from associated sensitive metadata and anonymizes personal identifiers. For RawPdfFile instances, uses the instance's text fields directly. Raises a TypeError if the instance is neither type.
+        
+        Parameters:
+            instance: A VideoFile or RawPdfFile model instance to serialize.
+        
+        Returns:
+            dict: A structured representation of the instance suitable for Pinia store consumption.
+        """
+        if isinstance(instance, VideoFile):
+            # For videos, we don't have text content in the traditional sense
+            # But we can extract metadata text from sensitive_meta
+            text = ""
+            anonym_text = ""
+
+            if instance.sensitive_meta:
+                sm = instance.sensitive_meta
+                # Create a structured text representation similar to FileOverviewSerializer
+                text_parts = []
+
+                if sm.patient_first_name or sm.patient_last_name:
+                    patient_name = f"{sm.patient_first_name or ''} {sm.patient_last_name or ''}".strip()
+                    text_parts.append(f"Patient: {patient_name}")
+
+                if sm.patient_dob:
+                    text_parts.append(f"Date of Birth: {sm.patient_dob.date()}")
+
+                if sm.examination_date:
+                    text_parts.append(f"Examination Date: {sm.examination_date}")
+
+                if sm.center:
+                    text_parts.append(f"Center: {sm.center.name}")
+
+                text = "\n".join(text_parts)
+
+                # Create anonymized version
+                anonym_text = text
+                if sm.patient_first_name:
+                    anonym_text = anonym_text.replace(sm.patient_first_name, "[FIRST_NAME]")
+                if sm.patient_last_name:
+                    anonym_text = anonym_text.replace(sm.patient_last_name, "[LAST_NAME]")
+                if sm.patient_dob:
+                    anonym_text = anonym_text.replace(str(sm.patient_dob.date()), "[DOB]")
+
+            return {
+                "id": instance.pk,
+                "sensitiveMetaId": instance.sensitive_meta.pk if instance.sensitive_meta else None,
+                "text": text,
+                "anonymizedText": anonym_text,
+                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta) if instance.sensitive_meta else None,
+                "status": "processing" if instance.state and instance.state.frames_extracted else "not_started",
+                "error": False,
+            }
+
+        elif isinstance(instance, RawPdfFile):
+            # Generate PDF streaming URL using pdf_id (RawPdfFile.id)
+            pdf_stream_url = f"/api/media/pdfs/{instance.pk}/stream/"
+            
+            return {
+                "id": instance.pk,
+                "sensitiveMetaId": instance.sensitive_meta.pk if instance.sensitive_meta else None,
+                "text": instance.text or "",
+                "anonymizedText": instance.anonymized_text or "",
+                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta) if instance.sensitive_meta else None,
+                "status": "done" if instance.anonymized_text else "not_started",
+                "error": False,
+                "pdfStreamUrl": pdf_stream_url,
+            }
+
+        else:
+            raise TypeError(f"Unsupported instance for VoPPatientDataSerializer: {type(instance)}")
+
+    def _serialize_sensitive_meta(self, sensitive_meta):
+        """
+        Serialize a SensitiveMeta object into a dictionary with patient and examination details.
+        
+        Returns:
+            dict or None: A dictionary containing patient and examination metadata fields, or None if sensitive_meta is not provided.
+        """
+        if not sensitive_meta:
+            return None
+
+        return {
+            "id": sensitive_meta.pk,
+            "patientFirstName": sensitive_meta.patient_first_name or "",
+            "patientLastName": sensitive_meta.patient_last_name or "",
+            "patientDob": sensitive_meta.patient_dob.isoformat() if sensitive_meta.patient_dob else "",
+            "patientGender": str(sensitive_meta.patient_gender) if sensitive_meta.patient_gender else "",
+            "examinationDate": sensitive_meta.examination_date.isoformat() if sensitive_meta.examination_date else "",
+            "centerName": sensitive_meta.center.name if sensitive_meta.center else "",
+            "endoscopeType": sensitive_meta.endoscope_type or "",
+            "endoscopeSn": sensitive_meta.endoscope_sn or "",
+            "isVerified": getattr(sensitive_meta, "is_verified", False),
+        }

endoreg_db/serializers/misc/stats.py

@@ -0,0 +1,33 @@
+from rest_framework import serializers
+
+class StatsSerializer(serializers.Serializer):
+    """
+    Serializer for statistics data from AuditLedger.
+    
+    This serializer defines the structure of statistics data and ensures
+    consistent API responses.
+    """
+    totalCases = serializers.IntegerField()
+    totalVideos = serializers.IntegerField()
+    totalAnnotations = serializers.IntegerField()
+    totalAnonymizations = serializers.IntegerField()
+    totalImages = serializers.IntegerField()
+    videosCompleted = serializers.IntegerField()
+    videosAnonym = serializers.IntegerField()
+    
+    # You can add additional fields or methods here as needed
+    # For example, to calculate derived statistics:
+    #TODO
+    def get_completion_percentage(self, obj):
+        """
+        Calculates the percentage of completed videos out of the total videos.
+        
+        Args:
+            obj: A dictionary containing 'videosCompleted' and 'totalVideos' keys.
+        
+        Returns:
+            The completion percentage as a float rounded to two decimal places, or 0 if totalVideos is zero or less.
+        """
+        if obj['totalVideos'] > 0:
+            return round((obj['videosCompleted'] / obj['totalVideos']) * 100, 2)
+        return 0

endoreg_db/serializers/misc/translatable_field_mix_in.py

@@ -0,0 +1,44 @@
+from django.utils.translation import get_language
+
+
+class TranslatableFieldMixin:
+    """Mixin für automatische Sprachauswahl basierend auf Accept-Language"""
+
+    def get_localized_name(self, obj, field_base='name'):
+        """
+        Retrieve a localized value for a specified field from an object, using language preference fallbacks.
+        
+        Attempts to return the value of the field with the current language code suffix (e.g., `name_en`). If unavailable or empty, falls back to the German (`_de`) version, then the English (`_en`) version, and finally the base field without a language suffix. Returns an empty string if no value is found.
+        
+        Parameters:
+            obj: The object containing the translatable fields.
+            field_base (str): The base name of the field to localize (default is 'name').
+        
+        Returns:
+            str: The localized field value, or an empty string if none is available.
+        """
+        current_lang = get_language() or 'en'
+
+        # Versuche sprachspezifisches Feld
+        lang_field = f"{field_base}_{current_lang}"
+        if hasattr(obj, lang_field):
+            value = getattr(obj, lang_field)
+            if value:
+                return value
+
+        # Fallback auf Deutsch
+        de_field = f"{field_base}_de"
+        if hasattr(obj, de_field):
+            value = getattr(obj, de_field)
+            if value:
+                return value
+
+        # Fallback auf Englisch
+        en_field = f"{field_base}_en"
+        if hasattr(obj, en_field):
+            value = getattr(obj, en_field)
+            if value:
+                return value
+
+        # Letzter Fallback auf Basis-Feld
+        return getattr(obj, field_base, '')

endoreg_db/serializers/misc/upload_job.py

@@ -0,0 +1,71 @@
+from rest_framework import serializers
+from endoreg_db.models.upload_job import UploadJob
+
+
+class UploadJobStatusSerializer(serializers.ModelSerializer):
+    """
+    Read-only serializer for upload job status responses.
+    Returns status information for polling endpoints.
+    """
+    
+    sensitive_meta_id = serializers.IntegerField(
+        source='sensitive_meta.id',
+        read_only=True,
+        allow_null=True,
+        help_text="ID of the created SensitiveMeta record (only when anonymized)"
+    )
+    
+    # Optional helper fields for preview (can be populated by view if needed)
+    text = serializers.CharField(read_only=True, required=False, allow_blank=True)
+    anonymized_text = serializers.CharField(read_only=True, required=False, allow_blank=True)
+
+    class Meta:
+        model = UploadJob
+        fields = [
+            'status',
+            'error_detail', 
+            'sensitive_meta_id',
+            'id',
+            'text',
+            'anonymized_text'
+        ]
+        read_only_fields = fields
+
+    def to_representation(self, instance):
+        """
+        Customize the representation to only include relevant fields based on status.
+        """
+        data = super().to_representation(instance)
+        
+        # Only include error_detail if status is error
+        if instance.status != UploadJob.Status.ERROR:
+            data.pop('error_detail', None)
+        
+        # Only include sensitive_meta_id if status is anonymized and we have a meta record
+        if instance.status != UploadJob.Status.ANONYMIZED or not instance.sensitive_meta:
+            data.pop('sensitive_meta_id', None)
+        
+        # Remove empty optional fields
+        if not data.get('text'):
+            data.pop('text', None)
+        if not data.get('anonymized_text'):
+            data.pop('anonymized_text', None)
+            
+        return data
+
+
+class UploadCreateResponseSerializer(serializers.Serializer):
+    """
+    Serializer for the initial upload response.
+    Returns upload_id and status_url for polling.
+    """
+    
+    upload_id = serializers.UUIDField(
+        read_only=True,
+        help_text="UUID of the created upload job"
+    )
+    
+    status_url = serializers.CharField(
+        read_only=True,
+        help_text="URL to poll for upload status updates"
+    )

endoreg_db/serializers/patient/__init__.py

@@ -0,0 +1,11 @@
+from .patient import (
+    PatientSerializer,
+)
+
+from .patient_dropdown import (
+    PatientDropdownSerializer,
+)
+__all__ = [
+    "PatientSerializer",
+    "PatientDropdownSerializer",
+]

endoreg_db/serializers/patient/patient.py

@@ -0,0 +1,86 @@
+from rest_framework import serializers
+from endoreg_db.models import Patient, Gender, Center
+from datetime import date
+
+class PatientSerializer(serializers.ModelSerializer):
+    # Use the slug field "name" so that the gender is represented by its string value
+    gender = serializers.SlugRelatedField(
+        slug_field='name',
+        queryset=Gender.objects.all(),
+        required=False,
+        allow_null=True
+    )
+    center = serializers.SlugRelatedField(
+        slug_field='name',
+        queryset=Center.objects.all(),
+        required=False,
+        allow_null=True
+    )
+    age = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Patient
+        fields = ['id', 'first_name', 'last_name', 'dob', 'gender', 'center', 
+                 'email', 'phone', 'patient_hash', 'is_real_person', 'age']
+        read_only_fields = ['id', 'age']
+
+    def get_age(self, obj):
+        """Berechnet das Alter des Patienten"""
+        if obj.dob:
+            return obj.age()
+        return None
+
+    def validate_first_name(self, value):
+        """Validiert den Vornamen"""
+        if not value or not value.strip():
+            raise serializers.ValidationError("Vorname ist erforderlich")
+        return value.strip()
+
+    def validate_last_name(self, value):
+        """Validiert den Nachnamen"""
+        if not value or not value.strip():
+            raise serializers.ValidationError("Nachname ist erforderlich")
+        return value.strip()
+
+    def validate_dob(self, value):
+        """Validiert das Geburtsdatum"""
+        if value and value > date.today():
+            raise serializers.ValidationError("Geburtsdatum kann nicht in der Zukunft liegen")
+        return value
+
+    def validate_email(self, value):
+        """Validiert die E-Mail-Adresse"""
+        if value and '@' not in value:
+            raise serializers.ValidationError("Ungültige E-Mail-Adresse")
+        return value
+
+    def create(self, validated_data):
+        """Erstellt einen neuen Patienten mit verbesserter Fehlerbehandlung"""
+        try:
+            patient = Patient.objects.create(**validated_data)
+            return patient
+        except Exception as e:
+            raise serializers.ValidationError(f"Fehler beim Erstellen des Patienten: {str(e)}")
+
+    def update(self, instance, validated_data):
+        """
+        Update an existing Patient instance with validated data.
+        
+        Parameters:
+            instance (Patient): The Patient instance to update.
+            validated_data (dict): Dictionary of validated data to update the instance with.
+        
+        Returns:
+            Patient: The updated Patient instance.
+        
+        Raises:
+            ValidationError: If an error occurs during the update process.
+        """
+        try:
+            for attr, value in validated_data.items():
+                setattr(instance, attr, value)
+            instance.save()
+            return instance
+        except Exception as e:
+            raise serializers.ValidationError(f"Fehler beim Aktualisieren des Patienten: {str(e)}")
+