endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/serializers/report/report.py

@@ -0,0 +1,105 @@
+from endoreg_db.models import RawPdfFile
+from endoreg_db.serializers.meta.report_meta import ReportMetaSerializer
+from endoreg_db.serializers.report.secure_file_url import SecureFileUrlSerializer
+from endoreg_db.serializers.report.mixins import ReportStatusMixin
+
+from django.utils import timezone
+from rest_framework import serializers
+
+
+import uuid
+from datetime import timedelta
+from pathlib import Path
+
+
+class ReportDataSerializer(ReportStatusMixin, serializers.ModelSerializer):
+    """
+    Hauptserializer für Report-Daten mit sicherer URL
+    """
+    report_meta = ReportMetaSerializer(source='sensitive_meta', read_only=True)
+    secure_file_url = SecureFileUrlSerializer(read_only=True)
+    file_type = serializers.SerializerMethodField()
+
+    # Status und updated_at hinzufügen (da sie im RawPdfFile Model fehlen)
+    status = serializers.SerializerMethodField()
+    updated_at = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = [
+            'id', 'anonymized_text', 'status', 'report_meta',
+            'secure_file_url', 'file_type', 'created_at', 'updated_at'
+        ]
+
+    def get_updated_at(self, obj):
+        """
+        Return the updated timestamp for the object, using `created_at` if available or the current time otherwise.
+        """
+        return obj.created_at if obj.created_at else timezone.now()
+
+    def get_file_type(self, obj):
+        """
+        Return the file extension of the associated file in lowercase, or 'unknown' if no file is present.
+        
+        Parameters:
+            obj: The object instance containing the file.
+        
+        Returns:
+            str: The file extension without the leading dot, or 'unknown' if the file is missing.
+        """
+        if obj.file:
+            return Path(obj.file.name).suffix.lower().lstrip('.')
+        return 'unknown'
+
+    def to_representation(self, instance):
+        """
+        Returns the serialized representation of the instance, including a secure file URL if a file exists and a request context is available.
+        """
+        data = super().to_representation(instance)
+
+        # Sichere URL generieren wenn file vorhanden
+        if instance.file and hasattr(instance.file, 'url'):
+            request = self.context.get('request')
+            if request:
+                # Sichere URL mit Token generieren
+                secure_url_data = self._generate_secure_url(instance, request)
+                data['secure_file_url'] = secure_url_data
+
+        return data
+
+    def _generate_secure_url(self, instance, request):
+        """
+        Generate a secure URL for downloading the file associated with the given instance, including an expiration time and file metadata.
+        
+        Parameters:
+            instance: The model instance containing the file.
+            request: The HTTP request object used to build the absolute URL.
+        
+        Returns:
+            dict: A dictionary containing the secure URL, expiration timestamp, file type, original filename, and file size in bytes.
+        """
+        # Token für sichere URL generieren
+        token = str(uuid.uuid4())
+        expires_at = timezone.now() + timedelta(hours=2)  # 2 Stunden gültig
+
+        # URL zusammenbauen
+        secure_url = request.build_absolute_uri(
+            f"/api/reports/{instance.id}/secure-file/?token={token}"
+        )
+
+        # Dateigröße ermitteln
+        file_size = 0
+        try:
+            if instance.file:
+                file_size = instance.file.size
+        except OSError:
+            # Datei nicht verfügbar oder Berechtigung fehlt
+            file_size = 0
+
+        return {
+            'url': secure_url,
+            'expires_at': expires_at,
+            'file_type': self.get_file_type(instance),
+            'original_filename': Path(instance.file.name).name if instance.file else 'unknown',
+            'file_size': file_size
+        }

endoreg_db/serializers/report/report_list.py

@@ -0,0 +1,22 @@
+from endoreg_db.models import RawPdfFile
+from endoreg_db.serializers.meta import ReportMetaSerializer
+from endoreg_db.serializers.report.mixins import ReportStatusMixin
+
+from django.utils import timezone
+from rest_framework import serializers
+
+
+from pathlib import Path
+
+
+class ReportListSerializer(ReportStatusMixin, serializers.ModelSerializer):
+    """
+    Vereinfachter Serializer für Report-Listen
+    """
+    report_meta = ReportMetaSerializer(source='sensitive_meta', read_only=True)
+    file_type = serializers.SerializerMethodField()
+    updated_at = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = ['id', 'status', 'report_meta', 'file_type', 'created_at', 'updated_at']

endoreg_db/serializers/report/secure_file_url.py

@@ -0,0 +1,26 @@
+from rest_framework import serializers
+
+
+class SecureFileUrlSerializer(serializers.Serializer):
+    """
+    Serializer für sichere File-URLs mit Ablaufzeit
+    """
+    url = serializers.URLField()
+    expires_at = serializers.DateTimeField()
+    file_type = serializers.CharField(max_length=20)
+    original_filename = serializers.CharField(max_length=255)
+    file_size = serializers.IntegerField()
+
+    def create(self, validated_data):
+        # Nicht implementiert, da nur für Ausgabe verwendet
+        """
+        Raises NotImplementedError to indicate that instance creation is not supported for this serializer.
+        """
+        raise NotImplementedError("SecureFileUrlSerializer ist nur für Ausgabe gedacht")
+
+    def update(self, instance, validated_data):
+        # Nicht implementiert, da nur für Ausgabe verwendet  
+        """
+        Raises NotImplementedError to indicate that updating is not supported, as this serializer is intended for output only.
+        """
+        raise NotImplementedError("SecureFileUrlSerializer ist nur für Ausgabe gedacht")

endoreg_db/serializers/requirements/requirement_schema.py

@@ -0,0 +1,25 @@
+from email import message
+from django.contrib import messages
+from pydantic import BaseModel
+from typing import List
+
+class ExaminationSchema(BaseModel):
+
+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,29 @@
+from ...models.requirement.requirement_set import RequirementSet
+from .requirement_schema import RequirementSetSchema
+
+def requirement_set_to_dict(requirement_set: RequirementSet) -> dict:
+    """
+    Convert a RequirementSet instance to a dictionary representation.
+    
+    Args:
+        requirement_set (RequirementSet): The RequirementSet instance to convert.
+    
+    Returns:
+        dict: A dictionary representation of the RequirementSet.
+    """
+    
+    requirement_set = RequirementSet.objects.select_related(
+        "created_by", "updated_by"
+    ).prefetch_related(
+        "requirements", "links"
+    ).get(id=requirement_set.id)
+
+    links = requirement_set.links_to_sets()
+    
+    return {
+        "id": requirement_set.id,
+        "name": requirement_set.name,
+        "description": requirement_set.description,
+        "requirements": [req.to_dict() for req in requirement_set.requirements.all()],
+        "links": [link.model_dump() for link in links]
+    }

endoreg_db/serializers/sensitive_meta_serializer.py

@@ -0,0 +1,282 @@
+from rest_framework import serializers
+from django.db import transaction
+from typing import Dict, Any
+import logging
+
+from ..models import SensitiveMeta, SensitiveMetaState, 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 .segmentation import (
+    VideoFileSerializer,
+)
+
+__all__ = [
+    "VideoFileSerializer",
+]