endoreg-db 0.8.9.2__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/serializers/patient/patient.py

@@ -2,27 +2,39 @@ 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',
+        slug_field="name",
         queryset=Gender.objects.all(),
         required=False,
-        allow_null=True
+        allow_null=True,
     )
     center = serializers.SlugRelatedField(
-        slug_field='name',
+        slug_field="name",
         queryset=Center.objects.all(),
         required=False,
-        allow_null=True
+        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']
+        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"""
@@ -45,12 +57,14 @@ class PatientSerializer(serializers.ModelSerializer):
     def validate_dob(self, value):
         """Validiert das Geburtsdatum"""
         if value and value > date.today():
-            raise serializers.ValidationError("Geburtsdatum kann nicht in der Zukunft liegen")
+            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:
+        if value and "@" not in value:
             raise serializers.ValidationError("Ungültige E-Mail-Adresse")
         return value
 
@@ -60,19 +74,21 @@ class PatientSerializer(serializers.ModelSerializer):
             patient = Patient.objects.create(**validated_data)
             return patient
         except Exception as e:
-            raise serializers.ValidationError(f"Fehler beim Erstellen des Patienten: {str(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.
         """
@@ -82,5 +98,6 @@ class PatientSerializer(serializers.ModelSerializer):
             instance.save()
             return instance
         except Exception as e:
-            raise serializers.ValidationError(f"Fehler beim Aktualisieren des Patienten: {str(e)}")
-
+            raise serializers.ValidationError(
+                f"Fehler beim Aktualisieren des Patienten: {str(e)}"
+            )

endoreg_db/serializers/patient/patient_dropdown.py

@@ -6,19 +6,27 @@ 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']
+        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.
         """

endoreg_db/serializers/patient_examination/__init__.py

@@ -4,4 +4,4 @@ from .patient_examination import (
 
 __all__ = [
     "PatientExaminationSerializer",
-]
+]

endoreg_db/serializers/patient_examination/patient_examination.py

@@ -2,44 +2,58 @@ 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')"
+        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',
+        slug_field="name",
         queryset=Examination.objects.all(),
         required=False,
-        allow_null=True
+        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'
+            "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",
         ]
-        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
+                "id": obj.patient.id,
+                "patient_hash": obj.patient.patient_hash,
+                "first_name": obj.patient.first_name,
+                "last_name": obj.patient.last_name,
             }
         return None
 
@@ -48,7 +62,7 @@ class PatientExaminationSerializer(serializers.ModelSerializer):
         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:
@@ -59,7 +73,7 @@ class PatientExaminationSerializer(serializers.ModelSerializer):
         """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)
@@ -70,72 +84,85 @@ class PatientExaminationSerializer(serializers.ModelSerializer):
                 patient_hash=value,
                 first_name="Patient",
                 last_name=value,
-                is_real_person=False  # Markiere als Pseudo-Patient
+                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")
+            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")
+            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')
-        
+        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")
-        
+            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 = 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)}")
+            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
-            
+            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)}")
-    
+            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"""
-        pe = PatientExamination()
-        obj = pe.get_or_create_patient_examination_by_id(patient_examination_id)
+        obj = PatientExamination.objects.filter(pk=patient_examination_id).first()
+        if obj is None:
+            return []
         self.instance = obj
-        return self.instance.get_available_findings() if self.instance else []
+        return self.instance.get_available_findings()

endoreg_db/serializers/patient_finding/__init__.py

@@ -12,4 +12,4 @@ __all__ = [
     "PatientFindingInterventionSerializer",
     "PatientFindingListSerializer",
     "PatientFindingWriteSerializer",
-]
+]

endoreg_db/serializers/patient_finding/patient_finding.py

@@ -1,10 +1,11 @@
 from endoreg_db.models import PatientFinding
 from rest_framework import serializers
 
+
 class PatientFindingSerializer(serializers.ModelSerializer):
     class Meta:
         model = PatientFinding
-        #fields = '__all__'
+        # fields = '__all__'
         fields = [
             "id",
             "patient_examination",

endoreg_db/serializers/patient_finding/patient_finding_classification.py

@@ -5,35 +5,43 @@ from endoreg_db.serializers.misc.translatable_field_mix_in import TranslatableFi
 from rest_framework import serializers
 
 
-class PatientFindingClassificationSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+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']
+        fields = [
+            "id",
+            "classification",
+            "classification_name",
+            "classification_choice_name",
+        ]
 
-    def get_classification_name(self, obj:PatientFindingClassification):
+    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):
+    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)
+        return self.get_localized_name(obj.classification_choice)

endoreg_db/serializers/patient_finding/patient_finding_detail.py

@@ -3,51 +3,60 @@ 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 endoreg_db.serializers.patient_finding.patient_finding_intervention import (
+    PatientFindingInterventionSerializer,
+)
 from .patient_finding_classification import PatientFindingClassificationSerializer
 
-class PatientFindingDetailSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+
+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)
+    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'
+            "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

@@ -4,23 +4,25 @@ from endoreg_db.models import PatientFindingIntervention
 from rest_framework import serializers
 
 
-class PatientFindingInterventionSerializer(serializers.ModelSerializer, TranslatableFieldMixin):
+class PatientFindingInterventionSerializer(
+    serializers.ModelSerializer, TranslatableFieldMixin
+):
     """Optimierter Serializer für PatientFindingIntervention"""
 
     intervention_name = serializers.SerializerMethodField()
 
     class Meta:
         model = PatientFindingIntervention
-        fields = ['id', 'intervention', 'intervention_name', 'state']
+        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)
+        return self.get_localized_name(obj.intervention)

endoreg_db/serializers/patient_finding/patient_finding_list.py

@@ -10,32 +10,31 @@ class PatientFindingListSerializer(serializers.ModelSerializer, TranslatableFiel
 
     finding_name = serializers.SerializerMethodField()
     patient_name = serializers.CharField(
-        source='patient_examination.patient.get_full_name',
-        read_only=True
+        source="patient_examination.patient.get_full_name", read_only=True
     )
     examination_date = serializers.DateTimeField(
-        source='patient_examination.date_start',
-        read_only=True
+        source="patient_examination.date_start", read_only=True
     )
 
     class Meta:
         model = PatientFinding
         fields = [
-            'id', 'finding_name', 'patient_name', 'examination_date',
-            'patient_examination', 'finding'
+            "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)
-    
-
-