endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/serializers/patient/patient.py

@@ -0,0 +1,103 @@
+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)}"
+            )

endoreg_db/serializers/patient/patient_dropdown.py

@@ -0,0 +1,35 @@
+from endoreg_db.models import Patient
+
+
+from rest_framework import serializers
+
+
+class PatientDropdownSerializer(serializers.ModelSerializer):
+    """Serializer für Patient-Dropdown"""
+
+    display_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Patient
+        fields = [
+            "id",
+            "patient_hash",
+            "first_name",
+            "last_name",
+            "display_name",
+            "dob",
+        ]
+
+    def get_display_name(self, obj):
+        """
+        Returns a user-friendly display string for a patient, combining their first and last name with a shortened patient hash or a placeholder if the hash is missing.
+
+        Parameters:
+            obj: The patient instance being serialized.
+
+        Returns:
+            str: The formatted display name for the patient.
+        """
+        patient_hash = obj.patient_hash
+        hash_display = f"({patient_hash[:8]}...)" if patient_hash else "(No Hash)"
+        return f"{obj.first_name} {obj.last_name} {hash_display}"

endoreg_db/serializers/patient_examination/__init__.py

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

endoreg_db/serializers/patient_examination/patient_examination.py

@@ -0,0 +1,168 @@
+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.objects.filter(pk=patient_examination_id).first()
+        if obj is None:
+            return []
+        self.instance = obj
+        return self.instance.get_available_findings()

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,32 @@
+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,47 @@
+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,62 @@
+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,28 @@
+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,40 @@
+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,135 @@
+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,3 @@
+from .anony_text_validation import RawPdfAnonyTextSerializer
+
+__all__ = ["RawPdfAnonyTextSerializer"]