endoreg-db 0.3.6__py3-none-any.whl → 0.8.6.1__py3-none-any.whl

endoreg_db/views/misc/upload_views.py

@@ -0,0 +1,240 @@
+import mimetypes
+from django.http import Http404
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.parsers import MultiPartParser, FormParser
+from rest_framework.permissions import AllowAny
+from django.views.decorators.csrf import csrf_exempt
+from django.utils.decorators import method_decorator
+
+# Try to import python-magic, but provide fallback if not available
+try:
+    import magic
+    MAGIC_AVAILABLE = True
+except ImportError:
+    MAGIC_AVAILABLE = False
+
+from endoreg_db.models.upload_job import UploadJob
+from endoreg_db.serializers.misc.upload_job import (
+    UploadJobStatusSerializer,
+)
+
+# Try to import celery task, but provide fallback
+try:
+    from endoreg_db.tasks.upload_tasks import process_upload_job
+    CELERY_AVAILABLE = True
+except ImportError:
+    CELERY_AVAILABLE = False
+    # Define a dummy function for development
+    def process_upload_job(job_id):
+        pass
+
+
+@method_decorator(csrf_exempt, name='dispatch')
+class UploadFileView(APIView):
+    """
+    Handle file uploads (POST /api/upload/).
+    
+    Accepts multipart/form-data with a 'file' field containing PDF or video files.
+    Creates an UploadJob and starts asynchronous processing.
+    
+    Returns:
+        201 Created: {"upload_id": "<uuid>", "status_url": "/api/upload/<uuid>/status/"}
+        400 Bad Request: File validation errors
+    """
+    
+    parser_classes = [MultiPartParser, FormParser]
+    permission_classes = [AllowAny]  # Adjust based on your auth requirements
+    
+    # Maximum file size (1 GiB)
+    MAX_FILE_SIZE = 1024 * 1024 * 1024  # 1 GiB in bytes
+    
+    # Allowed MIME types
+    ALLOWED_MIME_TYPES = {
+        'application/pdf',
+        'video/mp4',
+        'video/avi', 
+        'video/quicktime',
+        'video/x-msvideo',
+        'video/x-ms-wmv'
+    }
+
+    def post(self, request, *args, **kwargs):
+        """
+        Handle file upload and create processing job.
+        """
+        # Validate file presence
+        if 'file' not in request.FILES:
+            return Response(
+                {'error': 'No file provided. Please include a file in the "file" field.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        uploaded_file = request.FILES['file']
+        
+        # Validate file is not empty
+        if not uploaded_file or uploaded_file.size == 0:
+            return Response(
+                {'error': 'Uploaded file is empty. Please select a valid file.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Validate file size
+        if uploaded_file.size > self.MAX_FILE_SIZE:
+            return Response(
+                {'error': f'File too large. Maximum size is {self.MAX_FILE_SIZE // (1024**3)} GB.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Validate filename
+        if not uploaded_file.name or uploaded_file.name.strip() == '':
+            return Response(
+                {'error': 'Invalid filename. Please ensure the file has a valid name.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Detect MIME type
+        try:
+            content_type = self._detect_mime_type(uploaded_file)
+        except Exception as e:
+            return Response(
+                {'error': f'Could not determine file type: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Validate MIME type
+        if content_type not in self.ALLOWED_MIME_TYPES:
+            return Response(
+                {'error': f'Unsupported file type: {content_type}. Allowed types: PDF, MP4, AVI, MOV, WMV.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        try:
+            # Create upload job
+            upload_job = UploadJob.objects.create(
+                file=uploaded_file,
+                content_type=content_type
+            )
+            
+            # Start asynchronous processing if Celery is available
+            if CELERY_AVAILABLE:
+                try:
+                    process_upload_job.delay(str(upload_job.id))
+                except Exception as e:
+                    # If Celery task fails to start, mark job as failed
+                    upload_job.mark_failed(f'Failed to start processing: {str(e)}')
+                    return Response(
+                        {'error': f'Failed to start processing: {str(e)}'},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    )
+            else:
+                # For development without Celery, mark as processing immediately
+                upload_job.mark_processing()
+                # In production, this would be handled by Celery
+                # For now, just leave it in processing state
+            
+            # Prepare response
+            status_url = reverse('upload_status', kwargs={'id': upload_job.id})
+            response_data = {
+                'upload_id': str(upload_job.id),  # Ensure UUID is converted to string
+                'status_url': status_url,
+                'message': 'Upload job created successfully'
+            }
+            
+            # Return the response data directly since serializer fields are read-only
+            return Response(
+                response_data,
+                status=status.HTTP_201_CREATED
+            )
+            
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to create upload job: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _detect_mime_type(self, uploaded_file) -> str:
+        """
+        Detect MIME type using python-magic as primary method,
+        fallback to mimetypes module.
+        """
+        try:
+            # Reset file pointer
+            uploaded_file.seek(0)
+            
+            # Try python-magic first (more reliable) if available
+            if MAGIC_AVAILABLE:
+                try:
+                    # Read first chunk for magic detection
+                    chunk = uploaded_file.read(2048)
+                    uploaded_file.seek(0)  # Reset again
+                    
+                    mime_type = magic.from_buffer(chunk, mime=True)
+                    if mime_type and mime_type != 'application/octet-stream':
+                        return mime_type
+                except Exception:
+                    pass  # Fall back to mimetypes
+            
+            # Fallback to mimetypes module
+            mime_type, _ = mimetypes.guess_type(uploaded_file.name)
+            if mime_type:
+                return mime_type
+            
+            # Last resort - check file extension
+            if uploaded_file.name.lower().endswith('.pdf'):
+                return 'application/pdf'
+            elif uploaded_file.name.lower().endswith(('.mp4', '.m4v')):
+                return 'video/mp4'
+            elif uploaded_file.name.lower().endswith('.avi'):
+                return 'video/avi'
+            elif uploaded_file.name.lower().endswith(('.mov', '.qt')):
+                return 'video/quicktime'
+            elif uploaded_file.name.lower().endswith('.wmv'):
+                return 'video/x-ms-wmv'
+            
+            raise ValueError("Could not determine file type")
+            
+        finally:
+            # Ensure file pointer is reset
+            uploaded_file.seek(0)
+
+
+class UploadStatusView(APIView):
+    """
+    Get upload job status (GET /api/upload/<uuid>/status/).
+    
+    Returns current processing status and relevant metadata.
+    Should be polled every 2 seconds by the frontend.
+    
+    Returns:
+        200 OK: Status information
+        404 Not Found: Upload job not found
+    """
+    
+    permission_classes = [AllowAny]  # Adjust based on your auth requirements
+
+    def get(self, request, id, *args, **kwargs):
+        """
+        Return the current status of an upload job.
+        """
+        try:
+            # Look up upload job by UUID
+            upload_job = UploadJob.objects.select_related('sensitive_meta').get(id=id)
+            
+            # Serialize the response
+            serializer = UploadJobStatusSerializer(upload_job)
+            
+            return Response(
+                serializer.data,
+                status=status.HTTP_200_OK
+            )
+            
+        except UploadJob.DoesNotExist:
+            raise Http404("Upload job not found")
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to get upload status: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/patient/__init__.py

@@ -0,0 +1,5 @@
+from .patient import PatientViewSet
+
+__all__ = [
+    "PatientViewSet"
+]

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'
+]