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

endoreg_db/views/patient/patient.py

@@ -10,20 +10,22 @@ from endoreg_db.authz.permissions import PolicyPermission
 from endoreg_db.models import Patient
 from endoreg_db.serializers.patient import PatientSerializer
 from endoreg_db.models.medical.patient.patient_examination import PatientExamination
-from rest_framework.permissions import IsAuthenticated
+
+
 @staff_member_required  # Ensures only staff members can access the page
 def start_examination(request):
-    return render(request, 'admin/start_examination.html')  # Loads the simple HTML page
+    return render(request, "admin/start_examination.html")  # Loads the simple HTML page
 
 
-#TODO Review this view
+# TODO Review this view
 class PatientViewSet(viewsets.ModelViewSet):
     """API endpoint for managing patients."""
+
     queryset = Patient.objects.all()
     serializer_class = PatientSerializer
     permission_classes = [PolicyPermission]
-    #permission_classes = [PolicyPermission]
-    
+    # permission_classes = [PolicyPermission]
+
     def perform_create(self, serializer):
         """Erweiterte Validierung beim Erstellen eines Patienten"""
         try:
@@ -31,16 +33,18 @@ class PatientViewSet(viewsets.ModelViewSet):
             patient = serializer.save()
             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, request, *args, **kwargs):
         """Erweiterte Logik für das Aktualisieren von Patienten"""
         try:
             return super().update(request, *args, **kwargs)
         except Exception as e:
             return Response(
-                {"error": f"Fehler beim Aktualisieren des Patienten: {str(e)}"}, 
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": f"Fehler beim Aktualisieren des Patienten: {str(e)}"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
     def destroy(self, request, *args, **kwargs):
@@ -48,53 +52,71 @@ class PatientViewSet(viewsets.ModelViewSet):
         Delete a patient with proper error handling and cascade protection.
         """
         patient = self.get_object()
-        
+
         try:
             with transaction.atomic():
                 # Check if patient has related examinations
-                examination_count = patient.patient_examinations.count() if hasattr(patient, 'patient_examinations') else 0
+                examination_count = (
+                    patient.patient_examinations.count()
+                    if hasattr(patient, "patient_examinations")
+                    else 0
+                )
                 finding_count = 0
-                
+
                 if examination_count > 0:
                     finding_count = sum(
-                        exam.patient_findings.count() if hasattr(exam, 'patient_findings') else 0 
+                        exam.patient_findings.count()
+                        if hasattr(exam, "patient_findings")
+                        else 0
                         for exam in patient.patient_examinations.all()
                     )
-                    
-                    return Response({
-                        'error': 'Patient cannot be deleted',
-                        'reason': f'Patient has {examination_count} examination(s) and {finding_count} finding(s).',
-                        'detail': 'Please remove all related examinations and findings before deleting the patient.'
-                    }, status=status.HTTP_409_CONFLICT)
-                
+
+                    return Response(
+                        {
+                            "error": "Patient cannot be deleted",
+                            "reason": f"Patient has {examination_count} examination(s) and {finding_count} finding(s).",
+                            "detail": "Please remove all related examinations and findings before deleting the patient.",
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
                 # Check if this is a real person (additional protection)
-                if hasattr(patient, 'is_real_person') and patient.is_real_person:
-                    return Response({
-                        'error': 'Cannot delete real patient',
-                        'reason': 'This patient is marked as a real person.',
-                        'detail': 'Real patient data cannot be deleted for data protection reasons.'
-                    }, status=status.HTTP_403_FORBIDDEN)
-                
+                if hasattr(patient, "is_real_person") and patient.is_real_person:
+                    return Response(
+                        {
+                            "error": "Cannot delete real patient",
+                            "reason": "This patient is marked as a real person.",
+                            "detail": "Real patient data cannot be deleted for data protection reasons.",
+                        },
+                        status=status.HTTP_403_FORBIDDEN,
+                    )
+
                 # Perform the deletion
                 patient_name = f"{patient.first_name} {patient.last_name}"
                 patient.delete()
-                
-                return Response({
-                    'message': f'Patient "{patient_name}" has been successfully deleted.'
-                }, status=status.HTTP_200_OK)
-                
+
+                return Response(
+                    {
+                        "message": f'Patient "{patient_name}" has been successfully deleted.'
+                    },
+                    status=status.HTTP_200_OK,
+                )
+
         except Exception as e:
-            return Response({
-                'error': 'Patient deletion failed',
-                'reason': 'Patient has protected related objects.',
-                'detail': str(e)
-            }, status=status.HTTP_409_CONFLICT)
+            return Response(
+                {
+                    "error": "Patient deletion failed",
+                    "reason": "Patient has protected related objects.",
+                    "detail": str(e),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
         except Exception as e:
             return Response(
-                {"error": f"Fehler beim Löschen des Patienten: {str(e)}"}, 
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": f"Fehler beim Löschen des Patienten: {str(e)}"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-    
+
     def check_pe_exist(self, request, pk=None):
         """Check if a patient examination exists.
 
@@ -111,101 +133,121 @@ class PatientViewSet(viewsets.ModelViewSet):
         except PatientExamination.DoesNotExist:
             return Response({"exists": False}, status=status.HTTP_404_NOT_FOUND)
 
-    @action(detail=True, methods=['get'])
+    @action(detail=True, methods=["get"])
     def check_deletion_safety(self, request, pk=None):
         """
         Check if a patient can be safely deleted.
         Returns information about related objects.
         """
         patient = self.get_object()
-        
-        examination_count = patient.patient_examinations.count() if hasattr(patient, 'patient_examinations') else 0
-        examinations = patient.patient_examinations.all() if hasattr(patient, 'patient_examinations') else []
-        
+
+        examination_count = (
+            patient.patient_examinations.count()
+            if hasattr(patient, "patient_examinations")
+            else 0
+        )
+        examinations = (
+            patient.patient_examinations.all()
+            if hasattr(patient, "patient_examinations")
+            else []
+        )
+
         finding_count = sum(
-            exam.patient_findings.count() if hasattr(exam, 'patient_findings') else 0 
+            exam.patient_findings.count() if hasattr(exam, "patient_findings") else 0
             for exam in examinations
         )
         video_count = sum(
-            1 for exam in examinations 
-            if hasattr(exam, 'video') and exam.video
+            1 for exam in examinations if hasattr(exam, "video") and exam.video
         )
         report_count = sum(
-            exam.raw_pdf_files.count() if hasattr(exam, 'raw_pdf_files') else 0 
+            exam.raw_pdf_files.count() if hasattr(exam, "raw_pdf_files") else 0
             for exam in examinations
         )
-        
-        is_real_person = hasattr(patient, 'is_real_person') and patient.is_real_person
+
+        is_real_person = hasattr(patient, "is_real_person") and patient.is_real_person
         can_delete = examination_count == 0 and not is_real_person
-        
+
         warnings = []
         if is_real_person:
-            warnings.append('This patient is marked as a real person')
+            warnings.append("This patient is marked as a real person")
         if examination_count > 0:
-            warnings.append(f'Patient has {examination_count} examination(s)')
+            warnings.append(f"Patient has {examination_count} examination(s)")
         if finding_count > 0:
-            warnings.append(f'Patient has {finding_count} finding(s)')
-        
-        return Response({
-            'can_delete': can_delete,
-            'is_real_person': is_real_person,
-            'related_objects': {
-                'examinations': examination_count,
-                'findings': finding_count,
-                'videos': video_count,
-                'reports': report_count
-            },
-            'warnings': warnings
-        })
-
-    @action(detail=False, methods=['get'])
+            warnings.append(f"Patient has {finding_count} finding(s)")
+
+        return Response(
+            {
+                "can_delete": can_delete,
+                "is_real_person": is_real_person,
+                "related_objects": {
+                    "examinations": examination_count,
+                    "findings": finding_count,
+                    "videos": video_count,
+                    "reports": report_count,
+                },
+                "warnings": warnings,
+            }
+        )
+
+    @action(detail=False, methods=["get"])
     def patient_count(self, request):
         """Gibt die Anzahl der Patienten zurück"""
         count = Patient.objects.count()
         return Response({"count": count})
-    
-    @action(detail=True, methods=['post'], url_path='pseudonym')
+
+    @action(detail=True, methods=["post"], url_path="pseudonym")
     def generate_pseudonym(self, request, pk=None):
         """
         Generate a pseudonym hash for an existing patient.
-        
+
         This endpoint generates a deterministic hash based on the patient's
         personal data (name, dob, center) using server-side logic without
         exposing any secrets to the frontend.
         """
-        from endoreg_db.services.pseudonym_service import generate_patient_pseudonym, validate_patient_for_pseudonym
-        
+        from endoreg_db.services.pseudonym_service import (
+            generate_patient_pseudonym,
+            validate_patient_for_pseudonym,
+        )
+
         patient = self.get_object()
-        
+
         try:
             # Validate that patient has required fields
             missing_fields = validate_patient_for_pseudonym(patient)
             if missing_fields:
-                return Response({
-                    'error': 'Missing required fields for pseudonym generation',
-                    'missing_fields': missing_fields,
-                    'detail': f'Please provide: {", ".join(missing_fields)}'
-                }, status=status.HTTP_400_BAD_REQUEST)
-            
+                return Response(
+                    {
+                        "error": "Missing required fields for pseudonym generation",
+                        "missing_fields": missing_fields,
+                        "detail": f"Please provide: {', '.join(missing_fields)}",
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
             # Generate the pseudonym
             patient_hash, persisted = generate_patient_pseudonym(patient)
-            
-            return Response({
-                'patient_id': patient.id,
-                'patient_hash': patient_hash,
-                'source': 'server',
-                'persisted': persisted,
-                'message': 'Pseudonym generated successfully'
-            }, status=status.HTTP_200_OK)
-            
+
+            return Response(
+                {
+                    "patient_id": patient.id,
+                    "patient_hash": patient_hash,
+                    "source": "server",
+                    "persisted": persisted,
+                    "message": "Pseudonym generated successfully",
+                },
+                status=status.HTTP_200_OK,
+            )
+
         except ValueError as e:
-            return Response({
-                'error': 'Pseudonym generation failed',
-                'detail': str(e)
-            }, status=status.HTTP_400_BAD_REQUEST)
+            return Response(
+                {"error": "Pseudonym generation failed", "detail": str(e)},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
         except Exception as e:
-            return Response({
-                'error': 'Internal server error during pseudonym generation',
-                'detail': str(e)
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
+            return Response(
+                {
+                    "error": "Internal server error during pseudonym generation",
+                    "detail": str(e),
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/patient_examination/__init__.py

@@ -4,8 +4,8 @@ from .patient_examination_list import PatientExaminationListView
 from .patient_examination import PatientExaminationViewSet
 
 __all__ = [
-    'ExaminationCreateView',
-    'PatientExaminationDetailView',
-    'PatientExaminationListView',
-    'PatientExaminationViewSet'
-]
+    "ExaminationCreateView",
+    "PatientExaminationDetailView",
+    "PatientExaminationListView",
+    "PatientExaminationViewSet",
+]

endoreg_db/views/patient_examination/patient_examination.py

@@ -8,24 +8,26 @@ from endoreg_db.serializers.patient_examination import (
 )
 from endoreg_db.serializers.examination import ExaminationDropdownSerializer
 
+
 class PatientExaminationViewSet(viewsets.ModelViewSet):
     """
     ViewSet für PatientExamination mit vollständiger CRUD-Unterstützung
     """
-    queryset = PatientExamination.objects.all().select_related('patient', 'examination')
+
+    queryset = PatientExamination.objects.all().select_related("patient", "examination")
     serializer_class = PatientExaminationSerializer
-    
+
     def get_queryset(self):
         """Optimierte Abfrage mit besserer Performance"""
-        return PatientExamination.objects.select_related(
-            'patient', 'examination'
-        ).prefetch_related(
-            'patient_findings', 'indications'
-        ).order_by('-date_start', '-id')
-        
+        return (
+            PatientExamination.objects.select_related("patient", "examination")
+            .prefetch_related("patient_findings", "indications")
+            .order_by("-date_start", "-id")
+        )
+
     def get_patient_examination_ids(self):
         """Hilfsmethode zum Abrufen mehrerer PatientExamination IDs"""
-        return PatientExamination.objects.filter(all=True).values_list('id', flat=True)
+        return PatientExamination.objects.filter(all=True).values_list("id", flat=True)
 
     def get_patient_examination_by_id(self, pk):
         """Hilfsmethode zum Abrufen einer PatientExamination nach ID"""
@@ -33,42 +35,41 @@ class PatientExaminationViewSet(viewsets.ModelViewSet):
             return None
         else:
             return PatientExamination.objects.select_related(
-                'patient', 'examination'
+                "patient", "examination"
             ).get(pk=pk)
 
-    
-    @action(detail=False, methods=['get'])
+    @action(detail=False, methods=["get"])
     def patients_dropdown(self, request):
         """
         Endpoint für Patient-Dropdown-Daten
         GET /api/patient-examinations/patients_dropdown/
         """
-        patients = Patient.objects.all().order_by('first_name', 'last_name')
+        patients = Patient.objects.all().order_by("first_name", "last_name")
         serializer = PatientDropdownSerializer(patients, many=True)
         return Response(serializer.data)
-    
-    @action(detail=False, methods=['get'])
+
+    @action(detail=False, methods=["get"])
     def examinations_dropdown(self, request):
         """
         Endpoint für Examination-Dropdown-Daten
         GET /api/patient-examinations/examinations_dropdown/
         """
-        examinations = Examination.objects.all().order_by('name')
+        examinations = Examination.objects.all().order_by("name")
         serializer = ExaminationDropdownSerializer(examinations, many=True)
         return Response(serializer.data)
-    
-    @action(detail=False, methods=['get'])
+
+    @action(detail=False, methods=["get"])
     def recent(self, request):
         """
         Endpoint für die letzten PatientExaminations
         GET /api/patient-examinations/recent/
         """
-        limit = int(request.query_params.get('limit', 10))
+        limit = int(request.query_params.get("limit", 10))
         recent_examinations = self.get_queryset()[:limit]
         serializer = self.get_serializer(recent_examinations, many=True)
         return Response(serializer.data)
-    
-    @action(detail=True, methods=['get'])
+
+    @action(detail=True, methods=["get"])
     def details(self, request, pk=None):
         """
         Detaillierte Informationen über eine PatientExamination
@@ -76,13 +77,15 @@ class PatientExaminationViewSet(viewsets.ModelViewSet):
         """
         examination = self.get_object()
         data = {
-            'examination': PatientExaminationSerializer(examination).data,
-            'findings': examination.get_findings().count(),
-            'indications': examination.get_indications().count(),
-            'patient_age_at_examination': examination.get_patient_age_at_examination() if examination.date_start else None,
+            "examination": PatientExaminationSerializer(examination).data,
+            "findings": examination.get_findings().count(),
+            "indications": examination.get_indications().count(),
+            "patient_age_at_examination": examination.get_patient_age_at_examination()
+            if examination.date_start
+            else None,
         }
         return Response(data)
-    
+
     def create(self, request, *args, **kwargs):
         """
         Überschreibt die create-Methode für bessere Fehlerbehandlung
@@ -93,36 +96,34 @@ class PatientExaminationViewSet(viewsets.ModelViewSet):
                 self.perform_create(serializer)
                 headers = self.get_success_headers(serializer.data)
                 return Response(
-                    serializer.data, 
-                    status=status.HTTP_201_CREATED, 
-                    headers=headers
+                    serializer.data, status=status.HTTP_201_CREATED, headers=headers
                 )
             except Exception as e:
                 return Response(
-                    {'error': f'Fehler beim Erstellen der Untersuchung: {str(e)}'}, 
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": f"Fehler beim Erstellen der Untersuchung: {str(e)}"},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
+
     def update(self, request, *args, **kwargs):
         """
         Überschreibt die update-Methode für bessere Fehlerbehandlung
         """
-        partial = kwargs.pop('partial', False)
+        partial = kwargs.pop("partial", False)
         instance = self.get_object()
         serializer = self.get_serializer(instance, data=request.data, partial=partial)
-        
+
         if serializer.is_valid():
             try:
                 self.perform_update(serializer)
                 return Response(serializer.data)
             except Exception as e:
                 return Response(
-                    {'error': f'Fehler beim Aktualisieren der Untersuchung: {str(e)}'}, 
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": f"Fehler beim Aktualisieren der Untersuchung: {str(e)}"},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-    
+
     def get_findings_for_examination(self, request, pk=None):
         """
         Endpoint to retrieve findings for a specific PatientExamination
@@ -131,10 +132,10 @@ class PatientExaminationViewSet(viewsets.ModelViewSet):
         examination = self.get_patient_examination_by_id(pk)
         if not examination:
             return Response(
-                {'error': 'PatientExamination nicht gefunden'}, 
-                status=status.HTTP_404_NOT_FOUND
+                {"error": "PatientExamination nicht gefunden"},
+                status=status.HTTP_404_NOT_FOUND,
             )
-        
+
         findings = PatientExaminationSerializer.get_
-        finding_data = [{'id': f.id, 'name': str(f)} for f in findings]
-        return Response(finding_data)
+        finding_data = [{"id": f.id, "name": str(f)} for f in findings]
+        return Response(finding_data)

endoreg_db/views/patient_examination/patient_examination_create.py

@@ -6,8 +6,10 @@ from rest_framework.response import Response
 from endoreg_db.utils.permissions import EnvironmentAwarePermission
 
 import logging
+
 logger = logging.getLogger(__name__)
 
+
 class ExaminationCreateView(generics.CreateAPIView):
     """
     Create new PatientExamination instances.
@@ -16,17 +18,16 @@ class ExaminationCreateView(generics.CreateAPIView):
     Expected payload:
     {
         "patient": "patient_hash_string",  # or patient_id integer
-        "examination": "examination_name", # examination name string 
+        "examination": "examination_name", # examination name string
         "date_start": "2024-01-15",
     }
     """
+
     serializer_class = PatientExaminationSerializer
     permission_classes = [EnvironmentAwarePermission]
 
-
     @transaction.atomic
     def create(self, request, *args, **kwargs):
-        
         try:
             logger.info(f"Creating examination with data: {request.data}")
 
@@ -38,26 +39,20 @@ class ExaminationCreateView(generics.CreateAPIView):
                 instance = serializer.save()
 
                 response_data = serializer.data
-                response_data['message'] = 'Examination created successfully'
+                response_data["message"] = "Examination created successfully"
 
                 logger.info(f"Examination created successfully with ID: {instance.id}")
                 return Response(response_data, status=status.HTTP_201_CREATED)
             else:
                 logger.warning(f"Validation errors: {serializer.errors}")
                 return Response(
-                    {
-                        'error': 'Validation failed',
-                        'details': serializer.errors
-                    },
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": "Validation failed", "details": serializer.errors},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
 
         except Exception as e:
             logger.error(f"Error creating examination: {str(e)}")
             return Response(
-                {
-                    'error': 'Failed to create examination',
-                    'message': str(e)
-                },
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
+                {"error": "Failed to create examination", "message": str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/patient_examination/patient_examination_detail.py

@@ -8,15 +8,18 @@ from rest_framework.response import Response
 from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
 
 import logging
+
 logger = logging.getLogger(__name__)
 
+
 class PatientExaminationDetailView(generics.RetrieveUpdateAPIView):
     """
     Retrieve and update PatientExamination instances.
     GET /api/examinations/{id}/
     PATCH /api/examinations/{id}/
     """
-    queryset = PatientExamination.objects.select_related('patient', 'examination')
+
+    queryset = PatientExamination.objects.select_related("patient", "examination")
     serializer_class = PatientExaminationSerializer
     permission_classes = DEBUG_PERMISSIONS
 
@@ -28,8 +31,8 @@ class PatientExaminationDetailView(generics.RetrieveUpdateAPIView):
         except Exception as e:
             logger.error(f"Error retrieving examination: {str(e)}")
             return Response(
-                {'error': 'Failed to retrieve examination'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": "Failed to retrieve examination"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
     @transaction.atomic
@@ -42,25 +45,19 @@ class PatientExaminationDetailView(generics.RetrieveUpdateAPIView):
                 updated_instance = serializer.save()
 
                 response_data = serializer.data
-                response_data['message'] = 'Examination updated successfully'
+                response_data["message"] = "Examination updated successfully"
 
                 logger.info(f"Examination {instance.id} updated successfully")
                 return Response(response_data, status=status.HTTP_200_OK)
             else:
                 return Response(
-                    {
-                        'error': 'Validation failed',
-                        'details': serializer.errors
-                    },
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": "Validation failed", "details": serializer.errors},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
 
         except Exception as e:
             logger.error(f"Error updating examination: {str(e)}")
             return Response(
-                {
-                    'error': 'Failed to update examination',
-                    'message': str(e)
-                },
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
+                {"error": "Failed to update examination", "message": str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )