endoreg-db 0.6.3__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/serializers/meta/pdf_file_meta_extraction.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+from ...models import RawPdfFile, SensitiveMeta
+
+
+class PDFFileForMetaSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch PDF metadata along with linked `SensitiveMeta` details.
+    Implements validation and ensures Vue.js can process errors easily.
+    """
+
+    # Fetch patient details from `SensitiveMeta`
+    patient_first_name = serializers.CharField(source="sensitive_meta.patient_first_name", read_only=True)
+    patient_last_name = serializers.CharField(source="sensitive_meta.patient_last_name", read_only=True)
+    patient_dob = serializers.CharField(source="sensitive_meta.patient_dob", read_only=True)
+    examination_date = serializers.CharField(source="sensitive_meta.examination_date", read_only=True)
+
+    # PDF file URL where Vue.js can fetch the document
+    pdf_url = serializers.SerializerMethodField()
+
+    # Full absolute path of the PDF file
+    full_pdf_path = serializers.SerializerMethodField()
+
+    # Direct file path from the database
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
+                  'sensitive_meta_id', 'patient_first_name', 
+                  'patient_last_name', 'patient_dob', 'examination_date']
+
+    @staticmethod
+    def get_next_pdf(last_id=None):
+        """
+        Retrieves the first available PDF if `last_id` is NOT provided.
+        Otherwise, fetches the next available PDF where `id > last_id`.
+        """
+        query_filter = {}
+        if last_id is not None:
+            try:
+                query_filter = {"id__gt": int(last_id)}
+            except ValueError:
+                # If last_id is not a valid integer, treat it as if no ID was provided.
+                # This prevents a crash and safely defaults to fetching the first PDF.
+                query_filter = {}
+
+        # Get the next available PDF
+        pdf_entry = RawPdfFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+
+        return pdf_entry  # Returns a model instance or None
+
+    def get_pdf_url(self, obj):
+        """
+        Generates an absolute URL for accessing the PDF associated with the given object.
+        
+        Returns:
+            The full URL as a string if the file exists; otherwise, None.
+        """
+        request = self.context.get('request')
+        print("---------------------here :",obj.file)
+        if request and obj.file:
+            return request.build_absolute_uri(f"/pdf/sensitivemeta/?id={obj.id}")  # Constructs full API endpoint
+        return None  # Return None if file is missing
+
+    def get_file(self, obj):
+        """
+        Retrieves the relative file path of the PDF from the database.
+        
+        Returns:
+            The relative file path as a string, or None if no file is linked.
+        """
+        if not obj.file:
+            return None  # No file linked
+        return str(obj.file.name).strip()  # Ensures clean output
+
+    def get_full_pdf_path(self, obj):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
+        """
+        if not obj.file:
+            return None  # No file linked
+
+        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  # Returns path or None if file is missing
+
+    def validate(self, data):
+        """
+        Validate input data to ensure a PDF file is provided and the referenced sensitive_meta_id exists.
+        
+        Raises:
+            serializers.ValidationError: If the PDF file is missing or the sensitive_meta_id does not correspond to an existing SensitiveMeta record.
+        
+        Returns:
+            dict: The validated input data if all checks pass.
+        """
+        errors = {}
+
+        if 'file' in data and not data['file']:
+            errors['file'] = "A valid PDF file is required."
+
+        if 'sensitive_meta_id' in data and not SensitiveMeta.objects.filter(id=data['sensitive_meta_id']).exists():
+            errors['sensitive_meta_id'] = "The provided sensitive_meta_id does not exist."
+
+        if errors:
+            raise serializers.ValidationError(errors)  # Returns structured error response
+
+        return data  # Returns validated data
+
+
+

endoreg_db/serializers/meta/report_meta.py

@@ -0,0 +1,53 @@
+from endoreg_db.models import SensitiveMeta
+
+
+from django.utils import timezone
+from rest_framework import serializers
+
+
+class ReportMetaSerializer(serializers.ModelSerializer):
+    """
+    Serializer für Report-Metadaten basierend auf SensitiveMeta
+    """
+    # Füge fehlende Zeitstempel-Felder hinzu
+    created_at = serializers.SerializerMethodField()
+    updated_at = serializers.SerializerMethodField()
+    casenumber = serializers.CharField(source='case_number', allow_blank=True, allow_null=True)
+
+    class Meta:
+        model = SensitiveMeta
+        fields = [
+            'id', 'patient_first_name', 'patient_last_name',
+            'patient_gender', 'patient_dob', 'examination_date',
+            'casenumber', 'created_at', 'updated_at'
+        ]
+
+    def get_created_at(self, obj):
+        """
+        Retrieve the `created_at` timestamp from the SensitiveMeta instance, or return the current time if unavailable.
+        
+        Parameters:
+            obj: The SensitiveMeta instance being serialized.
+        
+        Returns:
+            datetime: The `created_at` timestamp, or the current time as a fallback.
+        """
+        if hasattr(obj, 'created_at') and obj.created_at:
+            return obj.created_at
+        # Fallback wenn SensitiveMeta kein created_at hat
+        return timezone.now()
+
+    def get_updated_at(self, obj):
+        """
+        Return the `updated_at` timestamp from the SensitiveMeta instance, or fall back to the `created_at` timestamp if `updated_at` is missing or null.
+        
+        Parameters:
+            obj: The SensitiveMeta instance being serialized.
+        
+        Returns:
+            A datetime representing when the instance was last updated, or created if no update timestamp is available.
+        """
+        if hasattr(obj, 'updated_at') and obj.updated_at:
+            return obj.updated_at
+        # Fallback wenn SensitiveMeta kein updated_at hat  
+        return self.get_created_at(obj)

endoreg_db/serializers/meta/sensitive_meta_detail.py

@@ -0,0 +1,162 @@
+from rest_framework import serializers
+import logging
+
+from ...models import SensitiveMeta
+
+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):
+        """
+        Return the overall verification status of the given SensitiveMeta instance.
+        
+        Returns:
+            bool: True if the instance is verified; False if the verification attribute is missing.
+        
+        Raises:
+            Exception: Propagates unexpected exceptions after logging.
+        """
+        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):
+        """
+        Return the date of birth verification status for the given object.
+        
+        Returns:
+            bool: True if the date of birth is verified; otherwise, False if unavailable or on error.
+        """
+        try:
+            return obj.state.dob_verified
+        except Exception:
+            return False
+
+    def get_names_verified(self, obj):
+        """
+        Return whether the patient's names have been verified.
+        
+        Returns:
+            bool: True if the names are verified; False if not verified or if an error occurs.
+        """
+        try:
+            return obj.state.names_verified
+        except Exception:
+            return False
+
+    def get_examiners_display(self, obj):
+        """
+        Return a list of examiner full names for the given SensitiveMeta instance.
+        
+        Returns:
+            list[str]: List of examiner names in "First Last" format, or an empty list if unavailable.
+        """
+        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):
+        """
+        Return the patient's date of birth formatted as "YYYY-MM-DD" for display.
+        
+        Returns:
+            str or None: Formatted date string if available, otherwise None.
+        """
+        if obj.patient_dob:
+            return obj.patient_dob.strftime("%Y-%m-%d")
+        return None
+
+    def get_examination_date_display(self, obj):
+        """
+        Return the examination date formatted as "YYYY-MM-DD" for display.
+        
+        Returns:
+            str or None: Formatted examination date string, or None if not set.
+        """
+        if obj.examination_date:
+            return obj.examination_date.strftime("%Y-%m-%d")
+        return None
+
+    def get_patient_hash_display(self, obj):
+        """
+        Return the last eight characters of the patient's hash, prefixed with ellipsis, or None if not available.
+        
+        Returns:
+            str or None: Truncated patient hash for display, or None if the hash is not set.
+        """
+        if obj.patient_hash:
+            return f"...{obj.patient_hash[-8:]}"
+        return None
+
+    def get_examination_hash_display(self, obj):
+        """
+        Return the last eight characters of the examination hash, prefixed with ellipsis, or None if not available.
+        
+        Returns:
+            str or None: Truncated examination hash for display, or None if the hash is not set.
+        """
+        if obj.examination_hash:
+            return f"...{obj.examination_hash[-8:]}"
+        return None
+

endoreg_db/serializers/meta/sensitive_meta_update.py

@@ -0,0 +1,148 @@
+from rest_framework import serializers
+from django.db import transaction
+import logging
+
+from ...models import SensitiveMeta, Center, Gender
+
+logger = logging.getLogger(__name__)
+
+
+
+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):
+        """
+        Validates that a center with the given natural key exists.
+        
+        Raises a validation error if the specified center does not exist.
+        """
+        if value:
+            try:
+                Center.objects.get_by_natural_key(value)
+                return value
+            except Center.DoesNotExist:
+                raise serializers.ValidationError(f"Center '{value}' does not exist.")
+        return value
+
+    def validate_patient_gender_name(self, value):
+        """
+        Validates that a gender with the given name exists.
+        
+        Raises a validation error if no matching Gender is found.
+        """
+        if value:
+            try:
+                Gender.objects.get(name=value)
+                return value
+            except Gender.DoesNotExist:
+                raise serializers.ValidationError(f"Gender '{value}' does not exist.")
+        return value
+
+    def validate(self, data):
+        """
+        Validate that patient first and last names, if provided, are not empty strings.
+        
+        Raises a validation error if either `patient_first_name` or `patient_last_name` is present but empty.
+        """
+        # Ensure names are not empty if provided
+        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):
+        """
+        Updates a SensitiveMeta instance with provided data, including related center, gender, and verification state fields.
+        
+        Handles assignment of related Center and Gender objects by name, updates model fields, and manages verification state flags (`dob_verified`, `names_verified`) in the associated state object if provided.
+        
+        Returns:
+            SensitiveMeta: The updated SensitiveMeta instance.
+        """
+        # Extract verification state data
+        dob_verified = validated_data.pop('dob_verified', None)
+        names_verified = validated_data.pop('names_verified', None)
+        
+        # Extract and handle center update
+        center_name = validated_data.pop('center_name', None)
+        if center_name:
+            try:
+                center = Center.objects.get_by_natural_key(center_name)
+                instance.center = center
+            except Center.DoesNotExist:
+                logger.error(f"Center '{center_name}' not found during update")
+                raise serializers.ValidationError(f"Center '{center_name}' does not exist.")
+        
+        # Extract and handle gender update
+        patient_gender_name = validated_data.pop('patient_gender_name', None)
+        if patient_gender_name:
+            try:
+                gender = Gender.objects.get(name=patient_gender_name)
+                instance.patient_gender = gender
+            except Gender.DoesNotExist:
+                logger.error(f"Gender '{patient_gender_name}' not found during update")
+                raise serializers.ValidationError(f"Gender '{patient_gender_name}' does not exist.")
+
+        # Update regular fields using the model's update_from_dict method
+        if validated_data:
+            instance.update_from_dict(validated_data)
+        
+        # Update verification state if provided
+        if dob_verified is not None or names_verified is not None:
+            # Ensure state exists
+            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()
+
+        return instance
+
+

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 .vop_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"
+]