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

endoreg_db/views/patient/patient.py

@@ -0,0 +1,210 @@
+from django.shortcuts import render
+from django.contrib.admin.views.decorators import staff_member_required
+from django.db import transaction
+
+from rest_framework import viewsets, status, serializers
+from rest_framework.response import Response
+from rest_framework.decorators import action
+
+
+from endoreg_db.models import Patient
+from endoreg_db.serializers.patient import PatientSerializer
+from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+
+@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
+
+
+#TODO Review this view
+class PatientViewSet(viewsets.ModelViewSet):
+    """API endpoint for managing patients."""
+    queryset = Patient.objects.all()
+    serializer_class = PatientSerializer
+    #permission_classes = [IsAuthenticatedOrReadOnly] 
+
+    def perform_create(self, serializer):
+        """Erweiterte Validierung beim Erstellen eines Patienten"""
+        try:
+            # Zusätzliche Validierung falls nötig
+            patient = serializer.save()
+            return patient
+        except Exception as 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
+            )
+
+    def destroy(self, request, *args, **kwargs):
+        """
+        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
+                finding_count = 0
+                
+                if examination_count > 0:
+                    finding_count = sum(
+                        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)
+                
+                # 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)
+                
+                # 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)
+                
+        except Exception as e:
+            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
+            )
+    
+    def check_pe_exist(self, request, pk=None):
+        """Check if a patient examination exists.
+
+        Args:
+            request (id): pk of the PatientExamination
+            pk (int, optional): _description_. Defaults to None.
+
+        Returns:
+            _type_: _description_
+        """
+        try:
+            PatientExamination.objects.get(pk=pk)
+            return Response({"exists": True}, status=status.HTTP_200_OK)
+        except PatientExamination.DoesNotExist:
+            return Response({"exists": False}, status=status.HTTP_404_NOT_FOUND)
+
+    @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 []
+        
+        finding_count = sum(
+            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
+        )
+        report_count = sum(
+            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
+        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')
+        if examination_count > 0:
+            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'])
+    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')
+    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
+        
+        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)
+            
+            # 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)
+            
+        except ValueError as e:
+            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)
+

endoreg_db/views/patient_examination/DEPRECATED_video_backup.py

@@ -0,0 +1,164 @@
+# from rest_framework import viewsets, status
+# from rest_framework.response import Response
+# from django.shortcuts import get_object_or_404
+# from endoreg_db.models import Examination, VideoFile, Finding, FindingClassification
+# from django.db import transaction
+# from django.utils import timezone
+# import logging
+
+
+# class VideoExaminationViewSet(viewsets.ModelViewSet):
+#     """
+#     ViewSet for Video Examination CRUD operations
+#     Handles POST and PATCH for video examinations at timestamps
+#     """
+#     def get_queryset(self):
+#         return []
+
+#     def create(self, request, *args, **kwargs):
+
+#         logger = logging.getLogger(__name__)
+#         try:
+#             data = request.data
+#             required_fields = ['videoId', 'timestamp', 'examinationTypeId', 'findingId']
+#             for field in required_fields:
+#                 if field not in data or data[field] is None:
+#                     return Response({'error': f'Missing or null required field: {field}'}, status=status.HTTP_400_BAD_REQUEST)
+#             try:
+#                 video_id = int(data['videoId'])
+#                 timestamp = float(data['timestamp'])
+#                 examination_type_id = int(data['examinationTypeId'])
+#                 finding_id = int(data['findingId'])
+#             except (ValueError, TypeError) as e:
+#                 return Response({'error': f'Invalid data type in request: {str(e)}'}, status=status.HTTP_400_BAD_REQUEST)
+#             if timestamp < 0:
+#                 return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
+#             with transaction.atomic():
+#                 try:
+#                     video = VideoFile.objects.get(id=video_id)
+#                 except VideoFile.DoesNotExist:
+#                     return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 try:
+#                     examination = Examination.objects.get(id=examination_type_id)
+#                 except Examination.DoesNotExist:
+#                     return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 try:
+#                     finding = Finding.objects.get(id=finding_id)
+#                 except Finding.DoesNotExist:
+#                     return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 if data.get('locationClassificationId'):
+#                     try:
+#                         FindingClassification.objects.get(id=data['locationClassificationId'], classification_types__name__iexact="location")
+#                     except FindingClassification.DoesNotExist:
+#                         return Response({'error': 'Location classification not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 if data.get('morphologyClassificationId'):
+#                     try:
+#                         FindingClassification.objects.get(id=data['morphologyClassificationId'], classification_types__name__iexact="morphology")
+#                     except FindingClassification.DoesNotExist:
+#                         return Response({'error': 'Morphology classification not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 examination_data = {
+#                     'id': f"exam_{video.id}_{timestamp}_{examination.id}",
+#                     'video_id': video_id,
+#                     'timestamp': timestamp,
+#                     'examination_type': examination.name,
+#                     'finding': finding.name,
+#                     'location_classification': data.get('locationClassificationId'),
+#                     'location_choice': data.get('locationChoiceId'),
+#                     'morphology_classification': data.get('morphologyClassificationId'),
+#                     'morphology_choice': data.get('morphologyChoiceId'),
+#                     'interventions': data.get('interventionIds', []),
+#                     'notes': data.get('notes', ''),
+#                     'created_at': timezone.now().isoformat()
+#                 }
+#                 logger.info(f"Created video examination for video {video_id} at timestamp {timestamp}")
+#                 return Response(examination_data, status=status.HTTP_201_CREATED)
+#         except Exception as e:
+#             logger.error(f"Unexpected error creating examination: {str(e)}")
+#             return Response({'error': 'Internal server error while creating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+#     def update(self, request, *args, **kwargs):
+#         logger = logging.getLogger(__name__)
+#         try:
+#             examination_id = kwargs.get('pk')
+#             if not examination_id:
+#                 return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
+#             data = request.data
+#             if 'videoId' in data:
+#                 try:
+#                     data['videoId'] = int(data['videoId'])
+#                 except (ValueError, TypeError):
+#                     return Response({'error': 'Invalid videoId format'}, status=status.HTTP_400_BAD_REQUEST)
+#             if 'timestamp' in data:
+#                 try:
+#                     timestamp = float(data['timestamp'])
+#                     if timestamp < 0:
+#                         return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
+#                     data['timestamp'] = timestamp
+#                 except (ValueError, TypeError):
+#                     return Response({'error': 'Invalid timestamp format'}, status=status.HTTP_400_BAD_REQUEST)
+#             with transaction.atomic():
+#                 if 'videoId' in data:
+#                     try:
+#                         VideoFile.objects.get(id=data['videoId'])
+#                     except VideoFile.DoesNotExist:
+#                         return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 if 'examinationTypeId' in data:
+#                     try:
+#                         examination_type_id = int(data['examinationTypeId'])
+#                         Examination.objects.get(id=examination_type_id)
+#                     except (ValueError, TypeError):
+#                         return Response({'error': 'Invalid examination type ID format'}, status=status.HTTP_400_BAD_REQUEST)
+#                     except Examination.DoesNotExist:
+#                         return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 if 'findingId' in data:
+#                     try:
+#                         finding_id = int(data['findingId'])
+#                         Finding.objects.get(id=finding_id)
+#                     except (ValueError, TypeError):
+#                         return Response({'error': 'Invalid finding ID format'}, status=status.HTTP_400_BAD_REQUEST)
+#                     except Finding.DoesNotExist:
+#                         return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
+#                 examination_data = {
+#                     'id': examination_id,
+#                     'video_id': data.get('videoId'),
+#                     'timestamp': data.get('timestamp'),
+#                     'examination_type': data.get('examinationTypeId'),
+#                     'finding': data.get('findingId'),
+#                     'location_classification': data.get('locationClassificationId'),
+#                     'location_choice': data.get('locationChoiceId'),
+#                     'morphology_classification': data.get('morphologyClassificationId'),
+#                     'morphology_choice': data.get('morphologyChoiceId'),
+#                     'interventions': data.get('interventionIds', []),
+#                     'notes': data.get('notes', ''),
+#                     'updated_at': '2024-01-01T00:00:00Z'
+#                 }
+#                 logger.info(f"Updated video examination {examination_id}")
+#                 return Response(examination_data, status=status.HTTP_200_OK)
+#         except Exception as e:
+#             logger.error(f"Unexpected error updating examination {examination_id}: {str(e)}")
+#             return Response({'error': 'Internal server error while updating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+#     def destroy(self, request, *args, **kwargs):
+#         logger = logging.getLogger(__name__)
+#         try:
+#             examination_id = kwargs.get('pk')
+#             if not examination_id:
+#                 return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
+#             try:
+#                 if not str(examination_id).strip():
+#                     return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
+#             except (ValueError, TypeError):
+#                 return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
+#             with transaction.atomic():
+#                 logger.info(f"Deleted video examination {examination_id}")
+#                 return Response({'message': f'Examination {examination_id} deleted successfully'}, status=status.HTTP_204_NO_CONTENT)
+#         except Exception as e:
+#             logger.error(f"Unexpected error deleting examination {examination_id}: {str(e)}")
+#             return Response({'error': 'Internal server error while deleting examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+# from rest_framework.decorators import api_view
+# @api_view(["GET"])
+# def get_examinations_for_video(request, video_id):
+#     _video = get_object_or_404(VideoFile, id=video_id)
+#     #TODO no functionality implemented yet
+#     return Response([])

endoreg_db/views/patient_examination/__init__.py

@@ -0,0 +1,11 @@
+from .patient_examination_create import ExaminationCreateView
+from .patient_examination_detail import PatientExaminationDetailView
+from .patient_examination_list import PatientExaminationListView
+from .patient_examination import PatientExaminationViewSet
+
+__all__ = [
+    'ExaminationCreateView',
+    'PatientExaminationDetailView',
+    'PatientExaminationListView',
+    'PatientExaminationViewSet'
+]

endoreg_db/views/patient_examination/patient_examination.py

@@ -0,0 +1,140 @@
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from endoreg_db.models import PatientExamination, Patient, Examination
+from endoreg_db.serializers.patient.patient_dropdown import PatientDropdownSerializer
+from endoreg_db.serializers.patient_examination import (
+    PatientExaminationSerializer,
+)
+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')
+    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')
+        
+    def get_patient_examination_ids(self):
+        """Hilfsmethode zum Abrufen mehrerer PatientExamination IDs"""
+        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"""
+        if not PatientExamination.objects.filter(pk=pk).exists():
+            return None
+        else:
+            return PatientExamination.objects.select_related(
+                'patient', 'examination'
+            ).get(pk=pk)
+
+    
+    @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')
+        serializer = PatientDropdownSerializer(patients, many=True)
+        return Response(serializer.data)
+    
+    @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')
+        serializer = ExaminationDropdownSerializer(examinations, many=True)
+        return Response(serializer.data)
+    
+    @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))
+        recent_examinations = self.get_queryset()[:limit]
+        serializer = self.get_serializer(recent_examinations, many=True)
+        return Response(serializer.data)
+    
+    @action(detail=True, methods=['get'])
+    def details(self, request, pk=None):
+        """
+        Detaillierte Informationen über eine PatientExamination
+        GET /api/patient-examinations/{id}/details/
+        """
+        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,
+        }
+        return Response(data)
+    
+    def create(self, request, *args, **kwargs):
+        """
+        Überschreibt die create-Methode für bessere Fehlerbehandlung
+        """
+        serializer = self.get_serializer(data=request.data)
+        if serializer.is_valid():
+            try:
+                self.perform_create(serializer)
+                headers = self.get_success_headers(serializer.data)
+                return Response(
+                    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
+                )
+        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)
+        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
+                )
+        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
+        GET /api/patient-examinations/{pk}/findings/
+        """
+        examination = self.get_patient_examination_by_id(pk)
+        if not examination:
+            return Response(
+                {'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)

endoreg_db/views/patient_examination/patient_examination_create.py

@@ -0,0 +1,63 @@
+from endoreg_db.serializers.patient_examination import PatientExaminationSerializer
+
+from django.db import transaction
+from rest_framework import generics, status
+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.
+    POST /api/examinations/create/
+
+    Expected payload:
+    {
+        "patient": "patient_hash_string",  # or patient_id integer
+        "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}")
+
+            # Use the serializer for validation and creation
+            serializer = self.get_serializer(data=request.data)
+
+            if serializer.is_valid():
+                # The serializer handles patient lookup/creation in validate_patient
+                instance = serializer.save()
+
+                response_data = serializer.data
+                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
+                )
+
+        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
+            )

endoreg_db/views/patient_examination/patient_examination_detail.py

@@ -0,0 +1,66 @@
+from endoreg_db.models import PatientExamination
+from endoreg_db.serializers.patient_examination import PatientExaminationSerializer
+
+from django.db import transaction
+from rest_framework import generics, status
+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')
+    serializer_class = PatientExaminationSerializer
+    permission_classes = DEBUG_PERMISSIONS
+
+    def get(self, request, *args, **kwargs):
+        try:
+            instance = self.get_object()
+            serializer = self.get_serializer(instance)
+            return Response(serializer.data)
+        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
+            )
+
+    @transaction.atomic
+    def patch(self, request, *args, **kwargs):
+        try:
+            instance = self.get_object()
+            serializer = self.get_serializer(instance, data=request.data, partial=True)
+
+            if serializer.is_valid():
+                updated_instance = serializer.save()
+
+                response_data = serializer.data
+                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
+                )
+
+        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
+            )