endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/misc/upload_views.py

@@ -0,0 +1,241 @@
+import mimetypes
+
+from django.http import Http404
+from django.urls import reverse
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from rest_framework import status
+from rest_framework.parsers import FormParser, MultiPartParser
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+# 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 report 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: report, 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,3 @@
+from .patient import PatientViewSet
+
+__all__ = ["PatientViewSet"]

endoreg_db/views/patient/patient.py

@@ -0,0 +1,253 @@
+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.authz.permissions import PolicyPermission
+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 = [PolicyPermission]
+    # permission_classes = [PolicyPermission]
+
+    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/__init__.py

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

endoreg_db/views/patient_examination/patient_examination.py

@@ -0,0 +1,141 @@
+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)