endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/patient_examination/patient_examination_create.py

@@ -0,0 +1,58 @@
+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,63 @@
+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,72 @@
+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,228 @@
+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,
+    PatientExamination,
+)
+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,71 @@
+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)