endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

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
+            )

endoreg_db/views/patient_examination/patient_examination_list.py

@@ -0,0 +1,68 @@
+from endoreg_db.models import PatientExamination
+from endoreg_db.serializers.patient_examination import PatientExaminationSerializer
+
+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 PatientExaminationListView(generics.ListAPIView):
+    """
+    List PatientExamination instances with filtering.
+    GET /api/examinations/list/
+
+    Query parameters:
+    - patient_id: Filter by patient ID
+    - examination_name: Filter by examination name
+    - limit: Number of results (default 20)
+    - offset: Pagination offset (default 0)
+    """
+    serializer_class = PatientExaminationSerializer
+    permission_classes = DEBUG_PERMISSIONS
+
+    def get_queryset(self):
+        queryset = PatientExamination.objects.select_related(
+            'patient', 'examination'
+        ).order_by('-date_start', '-id')
+
+        # Apply filters
+        patient_id = self.request.query_params.get('patient_id')
+        if patient_id:
+            queryset = queryset.filter(patient_id=patient_id)
+
+        examination_name = self.request.query_params.get('examination_name')
+        if examination_name:
+            queryset = queryset.filter(examination__name__icontains=examination_name)
+
+        return queryset
+
+    def list(self, request, *args, **kwargs):
+        try:
+            queryset = self.get_queryset()
+
+            # Pagination
+            limit = int(request.query_params.get('limit', 20))
+            offset = int(request.query_params.get('offset', 0))
+
+            total_count = queryset.count()
+            paginated_queryset = queryset[offset:offset + limit]
+
+            serializer = self.get_serializer(paginated_queryset, many=True)
+
+            return Response({
+                'results': serializer.data,
+                'total_count': total_count,
+                'limit': limit,
+                'offset': offset,
+                'has_more': (offset + limit) < total_count
+            })
+
+        except Exception as e:
+            logger.error(f"Error listing examinations: {str(e)}")
+            return Response(
+                {'error': 'Failed to list examinations'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/patient_examination/video.py

@@ -0,0 +1,194 @@
+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,
+    PatientExamination, PatientFinding, PatientFindingClassification,
+    PatientFindingIntervention,
+)
+from django.db import DatabaseError, transaction
+from django.utils import timezone
+import logging
+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([])
+
+class VideoPatientExaminationViewSet(viewsets.ModelViewSet):
+    """
+    ViewSet for PatientExamination CRUD operations in the context of video files
+    Handles POST and PATCH for video examinations at timestamps
+    """
+
+
+    def get_queryset(self):
+        video_id = self.request.query_params.get('videoId')
+        if video_id:
+            return PatientExamination.objects.filter(video_id=video_id)
+        return PatientExamination.objects.all()
+
+    def _validate_create_data(self, request):
+        """
+        Validate incoming data for create.
+        Returns (clean_data, errors) where errors is a dict of field issues.
+        """
+        data = request.data.copy()
+        errors = {}
+
+        # patient_id validation
+        if 'patient_id' not in data:
+            errors['patient_id'] = 'This field is required.'
+        else:
+            try:
+                data['patient_id'] = int(data['patient_id'])
+            except (TypeError, ValueError):
+                errors['patient_id'] = 'Must be an integer.'
+
+        # exam_date validation
+        if 'exam_date' not in data:
+            errors['exam_date'] = 'This field is required.'
+        else:
+            from django.utils.dateparse import parse_date
+            parsed = parse_date(data['exam_date'])
+            if not parsed:
+                errors['exam_date'] = 'Invalid date format.'
+            else:
+                data['exam_date'] = parsed
+
+        # video_file presence
+        if 'video_file' not in data:
+            errors['video_file'] = 'This field is required.'
+
+        return data, errors
+
+
+    def _create_examination_data(self, validated_data):
+        """
+        Create examination and video record, then return payload.
+        """
+        # assume Examination, Video imported above
+        exam = Examination.objects.create(
+            patient_id=validated_data['patient_id'],
+            date=validated_data['exam_date']
+        )
+        vid = VideoFile.objects.create(
+            examination=exam,
+            file=validated_data['video_file']
+        )
+        return {
+            'examination_id': exam.id,
+            'video_id': vid.id
+        }
+
+
+    def create(self, request, *args, **kwargs):
+        """
+        Create a new video examination.
+        """
+        logger = logging.getLogger(__name__)
+        clean_data, errors = self._validate_create_data(request)
+        if errors:
+            return Response({'errors': errors}, status=400)
+
+        try:
+            payload = self._create_examination_data(clean_data)
+            return Response(payload, status=201)
+        except DatabaseError as db_err:
+            return Response(
+                {'error': f'Database error: {db_err}'},
+                status=500
+            )
+        except Exception:
+            logger.exception("Unexpected error in create()")
+            return Response(
+                {'error': 'Internal server error'},
+                status=500
+            )
+
+    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': timezone.now().isoformat()
+                }
+                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)
+
+

endoreg_db/views/patient_finding/__init__.py

@@ -0,0 +1,7 @@
+from .patient_finding import PatientFindingViewSet
+from .patient_finding_optimized import OptimizedPatientFindingViewSet
+
+__all__ = [
+    "PatientFindingViewSet",
+    "OptimizedPatientFindingViewSet",
+]

endoreg_db/views/patient_finding/patient_finding.py

@@ -0,0 +1,64 @@
+from endoreg_db.models import PatientFinding
+from endoreg_db.serializers import PatientFindingSerializer
+from rest_framework.response import Response
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.decorators import action
+from django_filters.rest_framework import DjangoFilterBackend
+
+
+class PatientFindingViewSet(ModelViewSet):
+    queryset = PatientFinding.objects.all()
+    serializer_class = PatientFindingSerializer
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['patient_examination']
+    
+    @action(detail=False, methods=['get'], url_path='by-examination/(?P<patient_examination_id>[^/.]+)')
+    def get_patient_findings_by_examination(self, request, patient_examination_id=None):
+        """Explicitly get patient findings by patient examination id_
+
+        Args:
+            request (_type_): _description_
+            patient_examination_id (_type_, optional): _description_. Defaults to None.
+
+        Returns:
+            _type_: _description_
+        """
+        patient_finding_objs = PatientFinding.objects.filter(patient_examination=patient_examination_id)
+        serializer = self.get_serializer(patient_finding_objs, many=True)
+        return Response(serializer.data)
+    
+
+    @action(detail=False, methods=['get'], url_path='by-id/(?P<patient_finding_id>[^/.]+)')
+    def get_patient_finding_by_id(self, request, patient_finding_id=None):
+        """_summary_
+
+        Args:
+            request (_type_): _description_
+            patient_finding_id (_type_, optional): _description_. Defaults to None.
+
+        Returns:
+            _type_: _description_
+        """
+        patient_finding_obj = PatientFinding.objects.filter(id=patient_finding_id)
+        serializer = self.get_serializer(patient_finding_obj, many=True)
+        return Response(serializer.data)
+    
+    def add_patient_finding(self, request):
+        """
+        Endpoint to add a new finding to a PatientExamination
+        POST /api/patient_findings/add/
+        """
+        
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        return Response(serializer.data, status=201)
+    
+    def get_all_patient_findings(self, request):
+        """
+        Endpoint to retrieve all PatientFindings
+        GET /api/patient_findings/
+        """
+        findings = PatientFinding.objects.all()
+        serializer = self.get_serializer(findings, many=True)
+        return Response(serializer.data)