endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/serializers/patient_examination/patient_examination.py

@@ -0,0 +1,141 @@
+from rest_framework import serializers
+from endoreg_db.models import PatientExamination, Patient, Examination
+from datetime import date
+
+class PatientExaminationSerializer(serializers.ModelSerializer):
+    # Verwende CharField für patient, um patient_hash zu empfangen
+    patient = serializers.CharField(
+        write_only=True,  # Nur für Eingabe verwenden
+        required=True,
+        help_text="Patient Hash (z.B. 'patient_2')"
+    )
+    
+    # Für die Ausgabe verwenden wir ein schreibgeschütztes Feld
+    patient_data = serializers.SerializerMethodField(read_only=True)
+    
+    examination = serializers.SlugRelatedField(
+        slug_field='name',
+        queryset=Examination.objects.all(),
+        required=False,
+        allow_null=True
+    )
+    
+    # Zusätzliche schreibgeschützte Felder für bessere API-Antworten
+    patient_name = serializers.SerializerMethodField()
+    examination_name = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = PatientExamination
+        fields = [
+            'id', 'patient', 'patient_data', 'examination', 'date_start', 'date_end', 
+            'hash', 'patient_name', 'examination_name'
+        ]
+        read_only_fields = ['id', 'hash', 'patient_name', 'examination_name', 'patient_data']
+
+    def get_patient_data(self, obj):
+        """Gibt die Patient-Daten für die Ausgabe zurück"""
+        if obj.patient:
+            return {
+                'id': obj.patient.id,
+                'patient_hash': obj.patient.patient_hash,
+                'first_name': obj.patient.first_name,
+                'last_name': obj.patient.last_name
+            }
+        return None
+
+    def get_patient_name(self, obj):
+        """Gibt den vollständigen Namen des Patienten zurück"""
+        if obj.patient:
+            return f"{obj.patient.first_name} {obj.patient.last_name}"
+        return None
+    
+    def get_examination_name(self, obj):
+        """Gibt den Namen der Untersuchung zurück"""
+        if obj.examination:
+            return obj.examination.name
+        return None
+
+    def validate_patient(self, value):
+        """Validiert und erstellt Patient falls nötig"""
+        if not value:
+            raise serializers.ValidationError("Patient Hash ist erforderlich")
+        
+        # Versuche Patient zu finden
+        try:
+            patient = Patient.objects.get(patient_hash=value)
+            return patient
+        except Patient.DoesNotExist:
+            # Erstelle automatisch einen Pseudo-Patienten
+            patient = Patient.objects.create(
+                patient_hash=value,
+                first_name="Patient",
+                last_name=value,
+                is_real_person=False  # Markiere als Pseudo-Patient
+            )
+            return patient
+
+    def validate_date_start(self, value):
+        """Validiert das Startdatum"""
+        if value and value > date.today():
+            raise serializers.ValidationError("Startdatum kann nicht in der Zukunft liegen")
+        return value
+
+    def validate_date_end(self, value):
+        """Validiert das Enddatum"""
+        if value and value > date.today():
+            raise serializers.ValidationError("Enddatum kann nicht in der Zukunft liegen")
+        return value
+
+    def validate(self, data):
+        """Validiert die gesamten Daten"""
+        date_start = data.get('date_start')
+        date_end = data.get('date_end')
+        
+        if date_start and date_end and date_end < date_start:
+            raise serializers.ValidationError("Enddatum muss nach dem Startdatum liegen")
+        
+        return data
+
+    def create(self, validated_data):
+        """Erstellt eine neue PatientExamination mit verbesserter Fehlerbehandlung"""
+        try:
+            # Patient wurde bereits in validate_patient erstellt/gefunden
+            patient = validated_data.pop('patient')  # Entferne patient aus validated_data
+            validated_data['patient'] = patient  # Füge das Patient-Objekt hinzu
+            
+            patient_examination = PatientExamination.objects.create(**validated_data)
+            return patient_examination
+        except Exception as e:
+            raise serializers.ValidationError(f"Fehler beim Erstellen der Patientenuntersuchung: {str(e)}")
+
+    def update(self, instance, validated_data):
+        """
+        Update an existing PatientExamination instance with validated data.
+        
+        If a new patient is provided, updates the patient reference. Applies all other validated fields to the instance and saves changes.
+        
+        Returns:
+            PatientExamination: The updated PatientExamination instance.
+        
+        Raises:
+            ValidationError: If an error occurs during the update process.
+        """
+        try:
+            # Falls Patient geändert wird
+            if 'patient' in validated_data:
+                patient = validated_data.pop('patient')
+                validated_data['patient'] = patient
+            
+            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 der Patientenuntersuchung: {str(e)}")
+    
+    def get_findings(self, patient_examination_id):
+        """Gibt die zugehörigen Befunde zurück"""
+        obj = PatientExamination.get_or_create_patient_examination_by_id(PatientExamination, patient_examination_id)
+        self.instance = obj
+        response = PatientExaminationSerializer()
+        return self.instance.patient_findings.all() if self.instance else []

endoreg_db/serializers/patient_finding/__init__.py

@@ -0,0 +1,15 @@
+from .patient_finding_classification import PatientFindingClassificationSerializer
+from .patient_finding_detail import PatientFindingDetailSerializer
+from .patient_finding_intervention import PatientFindingInterventionSerializer
+from .patient_finding_list import PatientFindingListSerializer
+from .patient_finding_write import PatientFindingWriteSerializer
+from .patient_finding import PatientFindingSerializer
+
+__all__ = [
+    "PatientFindingSerializer",
+    "PatientFindingClassificationSerializer",
+    "PatientFindingDetailSerializer",
+    "PatientFindingInterventionSerializer",
+    "PatientFindingListSerializer",
+    "PatientFindingWriteSerializer",
+]

endoreg_db/serializers/patient_finding/patient_finding.py

@@ -0,0 +1,31 @@
+from endoreg_db.models import PatientFinding
+from rest_framework import serializers
+
+class PatientFindingSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = PatientFinding
+        #fields = '__all__'
+        fields = [
+            "id",
+            "patient_examination",
+            "finding",
+            # relationships (kept for backward compatibility)
+            "video_segments",
+            "interventions",
+            "classifications",
+            # timestamps are generally safe/expected by clients
+            "created_at",
+            "updated_at",
+            # expose active state, but NOT who/when deactivated
+            "is_active",
+        ]
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "is_active",
+            # relationships are usually read-only here
+            "video_segments",
+            "interventions",
+            "classifications",
+        ]

endoreg_db/serializers/patient_finding/patient_finding_classification.py

@@ -0,0 +1,39 @@
+from endoreg_db.models import PatientFindingClassification
+from endoreg_db.serializers.misc.translatable_field_mix_in import TranslatableFieldMixin
+
+
+from rest_framework import serializers
+
+
+class PatientFindingClassificationSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+    """Serializer für PatientFinding-Klassifikationen"""
+
+    classification_name = serializers.SerializerMethodField()
+    classification_choice_name = serializers.SerializerMethodField()
+    class Meta:
+        model = PatientFindingClassification
+        fields = ['id', 'classification', 'classification_name', 'classification_choice_name']
+
+    def get_classification_name(self, obj:PatientFindingClassification):
+        """
+        Return the localized name for the classification attribute of a PatientFindingClassification instance.
+        
+        Parameters:
+            obj (PatientFindingClassification): The instance whose classification name is to be localized.
+        
+        Returns:
+            str: The localized classification name.
+        """
+        return self.get_localized_name(obj.classification)
+
+    def get_classification_choice_name(self, obj:PatientFindingClassification):
+        """
+        Return the localized name for the classification choice of a patient finding classification instance.
+        
+        Parameters:
+            obj (PatientFindingClassification): The patient finding classification instance.
+        
+        Returns:
+            str: Localized name of the classification choice.
+        """
+        return self.get_localized_name(obj.classification_choice)

endoreg_db/serializers/patient_finding/patient_finding_detail.py

@@ -0,0 +1,53 @@
+from rest_framework import serializers
+from endoreg_db.models import (
+    PatientFinding,
+)
+from endoreg_db.serializers.misc.translatable_field_mix_in import TranslatableFieldMixin
+from endoreg_db.serializers.patient_finding.patient_finding_intervention import PatientFindingInterventionSerializer
+from .patient_finding_classification import PatientFindingClassificationSerializer
+
+class PatientFindingDetailSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+    """Vollständiger Serializer mit allen verschachtelten Daten - optimiert für N+1 Vermeidung"""
+    
+    
+    classifications = PatientFindingClassificationSerializer(many=True, read_only=True)
+    interventions = PatientFindingInterventionSerializer(many=True, read_only=True)
+    
+    # Meta-Informationen für das Frontend
+    patient_id = serializers.CharField(source='patient_examination.patient.id', read_only=True)
+    examination_name = serializers.SerializerMethodField()
+    finding_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = PatientFinding
+        fields = [
+            'id', 'patient_examination', 'finding', 'finding_name',
+            'patient_id', 'examination_name',
+            'classifications', 'interventions'
+        ]
+        
+    def get_finding_name(self, obj):
+        """
+        Return the localized name of the finding associated with the given PatientFinding instance.
+        
+        Parameters:
+            obj: The PatientFinding instance being serialized.
+        
+        Returns:
+            str: The localized name of the related finding.
+        """
+        return self.get_localized_name(obj.finding)
+    
+    def get_examination_name(self, obj):
+        """
+        Return the localized name of the examination associated with the given PatientFinding instance.
+        
+        Parameters:
+            obj: The PatientFinding instance being serialized.
+        
+        Returns:
+            str: The localized name of the related examination.
+        """
+        return self.get_localized_name(obj.patient_examination.examination)
+
+

endoreg_db/serializers/patient_finding/patient_finding_intervention.py

@@ -0,0 +1,26 @@
+from endoreg_db.serializers.misc.translatable_field_mix_in import TranslatableFieldMixin
+from endoreg_db.models import PatientFindingIntervention
+
+from rest_framework import serializers
+
+
+class PatientFindingInterventionSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+    """Optimierter Serializer für PatientFindingIntervention"""
+
+    intervention_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = PatientFindingIntervention
+        fields = ['id', 'intervention', 'intervention_name', 'state']
+
+    def get_intervention_name(self, obj):
+        """
+        Return the localized name of the intervention associated with the given object.
+        
+        Parameters:
+            obj: The object containing the intervention to be localized.
+        
+        Returns:
+            str: The localized name of the intervention.
+        """
+        return self.get_localized_name(obj.intervention)

endoreg_db/serializers/patient_finding/patient_finding_list.py

@@ -0,0 +1,41 @@
+from endoreg_db.models import PatientFinding
+from endoreg_db.serializers.misc.translatable_field_mix_in import TranslatableFieldMixin
+
+
+from rest_framework import serializers
+
+
+class PatientFindingListSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+    """Leichtgewichtiger Serializer für Listen-Ansichten"""
+
+    finding_name = serializers.SerializerMethodField()
+    patient_name = serializers.CharField(
+        source='patient_examination.patient.get_full_name',
+        read_only=True
+    )
+    examination_date = serializers.DateTimeField(
+        source='patient_examination.date_start',
+        read_only=True
+    )
+
+    class Meta:
+        model = PatientFinding
+        fields = [
+            'id', 'finding_name', 'patient_name', 'examination_date',
+            'patient_examination', 'finding'
+        ]
+
+    def get_finding_name(self, obj):
+        """
+        Return the localized name of the finding associated with the given PatientFinding instance.
+        
+        Parameters:
+            obj: The PatientFinding instance for which to retrieve the localized finding name.
+        
+        Returns:
+            str: The localized name of the related finding.
+        """
+        return self.get_localized_name(obj.finding)
+    
+
+ 

endoreg_db/serializers/patient_finding/patient_finding_write.py

@@ -0,0 +1,126 @@
+from endoreg_db.models import (
+    PatientFinding,
+    PatientFindingIntervention
+)
+from endoreg_db.serializers.patient_finding.patient_finding_classification import PatientFindingClassificationSerializer
+from endoreg_db.serializers.patient_finding.patient_finding_intervention import PatientFindingInterventionSerializer
+
+
+from rest_framework import serializers
+
+
+class PatientFindingWriteSerializer(serializers.ModelSerializer):
+    """Schreiboptimierter Serializer mit Nested Write Support"""
+
+    classifications = PatientFindingClassificationSerializer(many=True, required=False)
+    interventions = PatientFindingInterventionSerializer(many=True, required=False)
+
+    class Meta:
+        model = PatientFinding
+        fields = [
+            'id', 'patient_examination', 'finding',
+            'classifications', 'interventions'
+        ]
+
+    def create(self, validated_data):
+        """
+        Create a new PatientFinding instance along with any provided nested classifications and interventions.
+        
+        Parameters:
+            validated_data (dict): Data validated by the serializer, potentially including nested classifications and interventions.
+        
+        Returns:
+            PatientFinding: The newly created PatientFinding instance with related nested objects.
+        """
+        classifications_data = validated_data.pop('classifications', [])
+        interventions_data = validated_data.pop('interventions', [])
+
+        patient_finding = PatientFinding.objects.create(**validated_data)
+
+        # Erstelle verschachtelte Objekte
+        self._create_nested_objects(patient_finding, classifications_data, interventions_data)
+
+        return patient_finding
+
+    def update(self, instance, validated_data):
+        """
+        Update a PatientFinding instance and its nested classifications and interventions.
+        
+        If new classification or intervention data is provided, existing related objects are deleted and replaced with the new data. Returns the updated PatientFinding instance.
+        """
+        classifications_data = validated_data.pop('classifications', None)
+        interventions_data = validated_data.pop('interventions', None)
+
+        # Update Hauptobjekt
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)
+        instance.save()
+
+        # Update verschachtelte Objekte wenn bereitgestellt
+        if classifications_data is not None:
+            instance.classifications.all().delete()
+            self._create_classifications(instance, classifications_data)
+
+        if interventions_data is not None:
+            instance.interventions.all().delete()
+            self._create_interventions(instance, interventions_data)
+
+        return instance
+
+    def _create_nested_objects(self, patient_finding, classifications_data, interventions_data):
+        """
+        Create nested classification and intervention objects linked to a PatientFinding instance.
+        
+        This helper method delegates the creation of related classification and intervention objects using the provided data, associating them with the specified PatientFinding.
+        """
+        self._create_classifications(patient_finding, classifications_data)
+        self._create_interventions(patient_finding, interventions_data)
+
+    def _create_classifications(self, patient_finding, classifications_data):
+        """
+        Create and associate classification objects with a given PatientFinding instance using provided data.
+        
+        Each classification in `classifications_data` is validated and saved as a related object to `patient_finding`. Validation errors are printed but do not interrupt processing.
+        """
+        for classification_data in classifications_data:
+            serializer = PatientFindingClassificationSerializer(data=classification_data, context={'patient_finding': patient_finding})
+            if serializer.is_valid():
+                serializer.save(patient_finding=patient_finding)
+            else:
+                # Handle validation errors
+                print(serializer.errors)  # Or raise an exception
+
+    def _create_interventions(self, patient_finding, interventions_data):
+        """
+        Create and associate intervention objects with a given patient finding using provided intervention data.
+        
+        Parameters:
+            patient_finding: The PatientFinding instance to associate interventions with.
+            interventions_data: Iterable of dictionaries containing intervention attributes.
+        """
+        for intervention_data in interventions_data:
+            PatientFindingIntervention.objects.create(
+                finding=patient_finding,
+                **intervention_data
+            )
+
+    def validate(self, data):
+        """
+        Validate that the selected finding is permitted for the specified patient examination.
+        
+        Raises a ValidationError if the finding is not among the allowed findings for the examination.
+        
+        Returns:
+            dict: The validated data if the finding is permitted.
+        """
+        patient_examination = data.get('patient_examination')
+        finding = data.get('finding')
+
+        # Prüfe ob Finding für diese Examination erlaubt ist
+        if finding and patient_examination:
+            if finding not in patient_examination.examination.get_available_findings():
+                raise serializers.ValidationError(
+                    f"Finding '{finding.name}' ist nicht für Examination '{patient_examination.examination.name}' erlaubt."
+                )
+
+        return data

endoreg_db/serializers/pdf/__init__.py

@@ -0,0 +1,5 @@
+from .anony_text_validation import RawPdfAnonyTextSerializer
+
+__all__ = [
+    'RawPdfAnonyTextSerializer'
+]

endoreg_db/serializers/pdf/anony_text_validation.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+from ...models import RawPdfFile
+
+class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch PDF 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 PDF if `last_id` is NOT provided.
+        Otherwise, fetches the next available PDF 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 PDF 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 PDF 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/report/__init__.py

@@ -0,0 +1,9 @@
+from .report_list import ReportListSerializer
+from .report import ReportDataSerializer
+from .secure_file_url import SecureFileUrlSerializer
+
+__all__ = [
+    "ReportListSerializer",
+    "ReportDataSerializer",
+    "SecureFileUrlSerializer"
+]

endoreg_db/serializers/report/mixins.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
+from django.utils import timezone
+
+if TYPE_CHECKING:
+    from endoreg_db.models import RawPdfFile
+
+class ReportStatusMixin:
+    """
+    Mixin class for report serializers to provide status, updated_at, and file_type fields.
+    """
+
+    def get_status(self, obj:"RawPdfFile") -> Literal['approved'] | Literal['pending']:
+        """
+        Return the report status as 'approved' if the report has been processed, otherwise 'pending'.
+        
+        Parameters:
+            obj (RawPdfFile): The report file instance to check.
+        
+        Returns:
+            Literal['approved'] | Literal['pending']: The status of the report based on its processing state.
+        """
+        if obj.state_report_processed:
+            return 'approved'
+        if obj.state_report_processing_required:
+            return 'pending'
+        return 'pending'
+
+    def get_updated_at(self, obj:"RawPdfFile") -> "timezone.datetime":
+        """
+        Return the last update time for the given RawPdfFile object.
+        
+        If the object's creation date is available, it is returned; otherwise, the current time is used.
+        """
+        return obj.date_created if obj.date_created else timezone.now()
+
+    def get_file_type(self, obj:"RawPdfFile"    ) -> "str":
+        """
+        Return the file type of the associated file as a lowercase string without the leading dot.
+        
+        If the object has no file, returns 'unknown'.
+        """
+        if obj.file:
+            return Path(obj.file.name).suffix.lower().lstrip('.')
+        return 'unknown'