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

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)

endoreg_db/views/patient_finding/patient_finding_optimized.py

@@ -0,0 +1,259 @@
+from endoreg_db.models import Examination, Finding, FindingClassification, PatientFinding
+from endoreg_db.serializers.patient_finding import PatientFindingClassificationSerializer, PatientFindingDetailSerializer, PatientFindingListSerializer, PatientFindingWriteSerializer
+
+
+from django.db import transaction
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.cache import cache_page
+from django.views.decorators.vary import vary_on_headers
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.filters import OrderingFilter, SearchFilter
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+
+class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
+    """
+    Hochoptimiertes ViewSet für PatientFinding mit Query-Optimierung,
+    Bulk-Endpoints und intelligenter Serializer-Auswahl
+    """
+    permission_classes = [IsAuthenticated]
+    filter_backends = [DjangoFilterBackend, OrderingFilter, SearchFilter]
+    filterset_fields = ['patient_examination__patient', 'finding', 'patient_examination__examination']
+    ordering_fields = ['id', 'patient_examination__date_start']
+    search_fields = ['finding__name', 'patient_examination__patient__first_name', 'patient_examination__patient__last_name']
+
+    def get_queryset(self):
+        """Optimierte QuerySet mit Prefetching basierend auf Action"""
+        base_queryset = PatientFinding.objects.select_related(
+            'patient_examination__patient',
+            'patient_examination__examination',
+            'finding'
+        )
+
+        # Detail-Views: fetch nested relations
+        if self.action in ['retrieve', 'update', 'partial_update']:
+            return base_queryset.prefetch_related(
+                "classifications__classification",
+                "classifications__choice",
+                # 'locations__location_classification',
+                # 'locations__location_choice',
+                # 'morphologies__morphology_classification', 
+                # 'morphologies__morphology_choice',
+                'interventions__intervention'
+            )
+
+        # For List-Views: fetch only necessary relations
+        return base_queryset
+
+    def get_serializer_class(self):
+        """Intelligente Serializer-Auswahl basierend auf Action"""
+        if self.action == 'list':
+            return PatientFindingListSerializer
+        elif self.action in ['create', 'update', 'partial_update']:
+            return PatientFindingWriteSerializer
+        else:
+            return PatientFindingDetailSerializer
+
+    @method_decorator(cache_page(60 * 15))  # 15 Minuten Cache
+    @method_decorator(vary_on_headers('Accept-Language'))
+    @action(detail=False, methods=['get'])
+    def examination_manifest(self, request):
+        """
+        Bulk-Endpoint: Liefert alle Setup-Daten für eine Examination in einem Call
+        """
+        examination_id = request.query_params.get('examination_id')
+        if not examination_id:
+            return Response(
+                {'error': 'examination_id parameter erforderlich'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            examination = Examination.objects.get(id=examination_id)
+        except Examination.DoesNotExist:
+            return Response(
+                {'error': 'Examination nicht gefunden'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # Alle Daten in optimierten Queries laden
+        findings = examination.get_available_findings().prefetch_related(
+            'location_classifications__choices',
+            'morphology_classifications__choices'
+        )
+
+        manifest_data = {
+            'examination': {
+                'id': examination.id,
+                'name': examination.name,
+                # 'name_de': examination.name_de,
+                # 'name_en': examination.name_en,
+            },
+            'findings': []
+        }
+
+        for finding in findings:
+            assert isinstance(finding, Finding), "Expected Finding instance"
+            finding_data = {
+                'id': finding.id,
+                'name': finding.name,
+                # 'name_de': finding.name_de,
+                # 'name_en': finding.name_en,
+                "classifications": [],
+                'location_classifications': [],
+                'morphology_classifications': []
+            }
+
+            for classification_obj in finding.get_classifications():
+                assert isinstance(classification_obj, FindingClassification), "Expected FindingClassification instance"
+                classification_data = {
+                    'id': classification_obj.id,
+                    'name': classification_obj.name,
+                    "choices": [
+                        {
+                            'id': choice.id,
+                            'name': choice.name,
+                        }
+                        for choice in classification_obj.choices.all()
+                    ]
+                }
+
+                finding_data['classifications'].append(classification_data)
+
+    @action(detail=False, methods=['post'])
+    def bulk_create(self, request):
+        """
+        Bulk-Endpoint für gleichzeitige Erstellung mehrerer PatientFindings
+        Optimiert für Mobile Apps mit schlechter Verbindung
+        """
+        findings_data = request.data.get('findings', [])
+        if not findings_data:
+            return Response(
+                {'error': 'findings array required'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        created_findings = []
+        errors = []
+
+        with transaction.atomic():
+            for i, finding_data in enumerate(findings_data):
+                serializer = self.get_serializer(data=finding_data)
+                if serializer.is_valid():
+                    try:
+                        finding = serializer.save()
+                        created_findings.append({
+                            'index': i,
+                            'id': finding.id,
+                            'status': 'created'
+                        })
+                    except Exception as e:
+                        errors.append({
+                            'index': i,
+                            'error': str(e),
+                            'status': 'error'
+                        })
+                else:
+                    errors.append({
+                        'index': i,
+                        'errors': serializer.errors,
+                        'status': 'validation_error'
+                    })
+
+        return Response({
+            'created': created_findings,
+            'errors': errors,
+            'total_processed': len(findings_data),
+            'success_count': len(created_findings),
+            'error_count': len(errors)
+        }, status=status.HTTP_201_CREATED if created_findings else status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=['post'])
+    def add_classification(self, request, pk=None):
+        """
+        Create and link a PatientFindingClassification to the PatientFinding
+
+        Called by: POST /api/patient-findings/{id}/add-classification/ #TODO CHECK
+
+        Expected payload: {
+            "classification_id": 1,
+            "choice_id": 2
+
+        """
+        patient_finding = self.get_object()
+        assert isinstance(patient_finding, PatientFinding), "Expected PatientFinding instance"
+        classification_data = request.data
+
+        # Validierung
+        classification_id = classification_data.get('classification_id')
+        choice_id = classification_data.get('choice_id')
+
+        if not classification_id or not choice_id:
+            return Response(
+                {'error': 'classification und choice erforderlich'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        patient_finding.add_classification(classification_id, choice_id)
+        try:
+            patient_finding_classification = patient_finding.add_classification(classification_id, choice_id)
+            serializer = PatientFindingClassificationSerializer(patient_finding_classification)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        except FindingClassification.DoesNotExist:
+            return Response(
+                {'error': 'location_classification nicht gefunden'},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+    @action(detail=False, methods=['get'])
+    def export_for_analysis(self, request):
+        """
+        Export-Endpoint für Datenanalyse mit flacher Struktur
+        Unterstützt CSV/JSON Export mit denormalisierten Daten
+        """
+        queryset = self.filter_queryset(self.get_queryset())
+
+        # Format-Parameter
+        export_format = request.query_params.get('format', 'json')
+
+        # Flache Datenstruktur für Analyse
+        export_data = []
+        for finding in queryset:
+            assert isinstance(finding, PatientFinding), "Expected PatientFinding instance"
+            base_data = {
+                'finding_id': finding.id,
+                'patient_id': finding.patient_examination.patient.id,
+                'patient_name': finding.patient_examination.patient.get_full_name(),
+                'examination_type': finding.patient_examination.examination.name,
+                'examination_date': finding.patient_examination.date_start,
+                'finding_name': finding.finding.name,
+            }
+
+            # Locations denormalisieren
+            for classification in finding.classifications.all():
+                classification_data = base_data.copy()
+                classification_data.update({
+                    'location_classification': classification.location_classification.name,
+                    'location_choice': classification.location_choice.name,
+                    'location_subcategories': classification.subcategories,
+                })
+                export_data.append(classification_data)
+
+            # Wenn keine Locations, trotzdem Base-Data hinzufügen
+            if not finding.locations.exists():
+                export_data.append(base_data)
+
+        if export_format == 'csv':
+            # CSV-Export implementierung würde hier hin
+            pass
+
+        return Response({
+            'data': export_data,
+            'count': len(export_data),
+            'exported_at': timezone.now()
+        })

endoreg_db/views/patient_finding_classification/__init__.py

@@ -0,0 +1,5 @@
+from .pfc_create import create_patient_finding_classification
+
+__all__ = [
+    "create_patient_finding_classification",
+]

endoreg_db/views/patient_finding_classification/pfc_create.py

@@ -0,0 +1,67 @@
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from rest_framework import status
+from endoreg_db.models import (
+    PatientFinding,
+    FindingClassificationChoice,
+    FindingClassification
+)
+
+@api_view(['POST'])
+def create_patient_finding_classification(request):
+    """
+    Create a patient finding classification relationship.
+    Expected payload: {
+        "patient_finding_id": 1,
+        "classification_id": 2,
+        "classification_choice_id": 2
+    }
+    """
+    try:
+        patient_finding_id = request.data.get('patient_finding_id')
+        choice_id = request.data.get('classification_choice_id')
+        classification_id = request.data.get('classification_id')
+        
+        if not patient_finding_id or not choice_id:
+            return Response(
+                {'detail': 'patient_finding_id and classification_choice_id are required'}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Get the objects
+        try:
+            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
+        except PatientFinding.DoesNotExist:
+            return Response(
+                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        
+        try:
+            choice = FindingClassificationChoice.objects.get(id=choice_id)
+        except FindingClassificationChoice.DoesNotExist:
+            return Response(
+                {'detail': f'ClassificationChoice with id {choice_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        try:
+            FindingClassification.objects.get(id=classification_id)
+        except FindingClassification.DoesNotExist:
+            return Response(
+                {'detail': f'Classification with id {classification_id} not found'}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+        patient_finding_classification = patient_finding.add_classification(classification_id = classification_id, choice_id = choice_id)
+        
+        return Response({
+            'id': patient_finding_classification.id,
+            'patient_finding_id': patient_finding.id,
+            'classification_choice_id': choice.id
+        }, status=status.HTTP_201_CREATED)
+        
+    except Exception as e:
+        return Response(
+            {'detail': f'Error creating patient finding classification: {str(e)}'}, 
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )

endoreg_db/views/patient_finding_location/__init__.py

@@ -0,0 +1,5 @@
+from .pfl_create import create_patient_finding_location
+
+__all__ = [
+    "create_patient_finding_location",
+]