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

endoreg_db/views/anonymization/validate.py

@@ -0,0 +1,107 @@
+import logging
+from typing import Any, Dict, cast
+
+from django.db import transaction
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from endoreg_db.models import RawPdfFile, VideoFile
+from endoreg_db.serializers.anonymization import SensitiveMetaValidateSerializer
+
+
+logger = logging.getLogger(__name__)
+
+
+class AnonymizationValidateView(APIView):
+    """
+    POST /api/anonymization/<int:file_id>/validate/
+    
+    Validiert und aktualisiert SensitiveMeta-Felder für Videos oder PDFs.
+    
+    Body (Datumsfelder bevorzugt in deutschem Format DD.MM.YYYY; ISO YYYY-MM-DD ebenfalls akzeptiert):
+    {
+      "patient_first_name": "Max",
+      "patient_last_name":  "Mustermann",
+      "patient_dob":        "21.03.1994",      // DD.MM.YYYY bevorzugt
+      "examination_date":   "15.02.2024",      // DD.MM.YYYY bevorzugt
+      "casenumber":         "12345",
+      "anonymized_text":    "...",             // nur für PDFs; Videos ignorieren
+      "is_verified":        true               // optional; default true
+      "file_type":        "video"            // optional; "video" oder "pdf"; wenn nicht angegeben, wird zuerst Video, dann PDF versucht
+    }
+    
+    Rückwärtskompatibilität: ISO-Format (YYYY-MM-DD) wird ebenfalls akzeptiert.
+    """
+
+    @transaction.atomic
+    def post(self, request, file_id: int):
+        # Serializer-Validierung mit deutscher Datums-Priorität
+        serializer = SensitiveMetaValidateSerializer(data=request.data or {})
+        serializer.is_valid(raise_exception=True)
+        validated_data = cast(Dict[str, Any], serializer.validated_data)
+        payload: Dict[str, Any] = dict(validated_data)
+        if "is_verified" not in payload:
+            payload["is_verified"] = True
+
+        file_type = payload.get("file_type")
+
+        # Try Video first (unless explicitly requesting PDF)
+        if file_type in (None, "video"):
+            video = VideoFile.objects.select_related("center").filter(pk=file_id).first()
+            if video is not None:
+                prepared_payload = self._prepare_payload(payload, video)
+                try:
+                    ok = video.validate_metadata_annotation(prepared_payload)
+                except Exception:  # pragma: no cover - defensive safety net
+                    logger.exception("Video validation crashed for id=%s", file_id)
+                    return Response(
+                        {"error": "Video validation encountered an unexpected error."},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+                if not ok:
+                    return Response({"error": "Video validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+
+                return Response({"message": "Video validated."}, status=status.HTTP_200_OK)
+
+            if file_type == "video":
+                return Response({"error": f"Video {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        # Then PDF (unless explicitly requesting Video)
+        if file_type in (None, "pdf"):
+            pdf = RawPdfFile.objects.select_related("center").filter(pk=file_id).first()
+            if pdf is not None:
+                prepared_payload = self._prepare_payload(payload, pdf)
+                try:
+                    ok = pdf.validate_metadata_annotation(prepared_payload)
+                except Exception:  # pragma: no cover - defensive safety net
+                    logger.exception("PDF validation crashed for id=%s", file_id)
+                    return Response(
+                        {"error": "PDF validation encountered an unexpected error."},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+                if not ok:
+                    return Response({"error": "PDF validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+
+                return Response({"message": "PDF validated."}, status=status.HTTP_200_OK)
+
+            if file_type == "pdf":
+                return Response({"error": f"PDF {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)
+
+    @staticmethod
+    def _prepare_payload(base_payload: Dict[str, Any], file_obj: Any) -> Dict[str, Any]:
+        """Return a fresh payload tailored for the given file object."""
+
+        prepared = dict(base_payload)
+        prepared.pop("file_type", None)
+
+        center = getattr(file_obj, "center", None)
+        center_name = getattr(center, "name", None)
+        if center_name and not prepared.get("center_name"):
+            prepared["center_name"] = center_name
+
+        return prepared

endoreg_db/views/auth/__init__.py

@@ -0,0 +1,13 @@
+from .keycloak import (
+    KeycloakVideoView,
+    keycloak_login,
+    keycloak_callback,
+    public_home,
+)
+
+__all__ = [
+    "KeycloakVideoView",
+    "keycloak_login",
+    "keycloak_callback",
+    "public_home",
+]

endoreg_db/views/auth/keycloak.py

@@ -0,0 +1,113 @@
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.views import APIView
+from rest_framework.response import Response
+
+from django.shortcuts import redirect
+from django.conf import settings
+from urllib.parse import urlencode
+import requests
+from django.http import HttpResponse
+
+"""
+    User hits /videos/
+    Middleware checks for token; if missing, redirects to /login/
+    /login/ redirects to Keycloak
+    User logs in → Keycloak sends them back to /login/callback/
+    /login/callback/ exchanges code for token, stores it in session
+    User is redirected to /videos/ again
+    Middleware now sees token, verifies it, injects user
+    DRF view (KeycloakVideoView) is allowed to execute and returns data
+"""
+class KeycloakVideoView(APIView):
+    permission_classes = [IsAuthenticated] #This uses DRF permissions to ensure request.user.is_authenticated == True.
+    print("1")
+
+    def get(self, request):
+        """
+        We already inject a mock user in the middleware, so this will pass if the middleware succeeded.
+        Returns a message including the Keycloak username.
+        """
+        username = getattr(request.user, 'preferred_username', 'Unknown')
+        return Response({"message": f"🎥 Hello, {username}. You are viewing protected videos!"})
+
+
+def keycloak_login(request):
+    print("1")
+
+    """
+    - This gets triggered when middleware redirects to /login/.
+    """
+    redirect_uri = request.build_absolute_uri('/login/callback/')
+    print("Redirect URI:", redirect_uri)
+    auth_url = f"{settings.KEYCLOAK_SERVER_URL}/realms/{settings.KEYCLOAK_REALM}/protocol/openid-connect/auth"
+
+    #OAuth2 Authorization Code Flow
+    params = {
+        "client_id": settings.KEYCLOAK_CLIENT_ID,
+        "response_type": "code",
+        "scope": "openid",
+        "redirect_uri": redirect_uri,
+    }
+    # Redirect user to Keycloak login page.
+    print("1")
+
+    return redirect(f"{auth_url}?{urlencode(params)}")
+
+
+
+def keycloak_callback(request):
+
+    #User lands here after login (Keycloak redirects here with code).
+    """
+    Handles the OAuth2 callback from Keycloak, exchanging the authorization code for tokens.
+    
+    Receives the authorization code from Keycloak, exchanges it for access and refresh tokens, stores them in the user's session, and redirects to the protected videos page. Returns an error response if the code is missing, the token exchange fails, or an exception occurs.
+    """
+    code = request.GET.get("code")
+    if not code:
+        return HttpResponse(" No authorization code provided.", status=400)
+
+    # Exchanges the code for an access_token.
+    token_url = f"{settings.KEYCLOAK_SERVER_URL}/realms/{settings.KEYCLOAK_REALM}/protocol/openid-connect/token"
+    redirect_uri = request.build_absolute_uri('/login/callback/')
+
+    data = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "client_id": settings.KEYCLOAK_CLIENT_ID,
+        "client_secret": settings.KEYCLOAK_CLIENT_SECRET,
+        "redirect_uri": redirect_uri,
+    }
+
+    try:
+        response = requests.post(token_url, data=data)
+
+        print("Token Response Status:", response.status_code)
+        print(" Token Response Body:", response.text)
+
+        if response.status_code != 200:
+            return HttpResponse(
+                f"<h2> Token exchange failed</h2><pre>{response.text}</pre>",
+                status=500
+            )
+
+        token_data = response.json()
+
+        if "access_token" not in token_data:
+            return HttpResponse(" Access token missing in response.", status=500)
+
+        #  Stores the token in Django session. Middleware will use this on the next request.
+        request.session["access_token"] = token_data["access_token"]
+        request.session["refresh_token"] = token_data["refresh_token"]
+        print("Refresh Token:", request.session.get("refresh_token"))
+
+        return redirect("/videos/")
+
+    except Exception as e:
+        return HttpResponse(f" Exception during token exchange: {str(e)}", status=500)
+
+
+def public_home(request):
+    print("Reached the public home page!")  
+    return HttpResponse("This is a public home page — no login required.")
+

endoreg_db/views/examination/__init__.py

@@ -0,0 +1,33 @@
+from .examination_manifest_cache import ExaminationManifestCache
+from .examination import ExaminationViewSet
+from .get_finding_classification_choices import (
+    get_classification_choices_for_examination,
+    get_morphology_classification_choices_for_examination,
+    get_location_classification_choices_for_examination, 
+)
+from .get_finding_classifications import (
+    get_classifications_for_examination,
+    get_location_classifications_for_examination,
+    get_morphology_classifications_for_examination,
+)
+from .get_findings import get_findings_for_examination
+from .get_instruments import get_instruments_for_examination
+from .get_interventions import get_interventions_for_examination
+
+
+__all__ = [
+    "ExaminationManifestCache",
+    'ExaminationViewSet',
+
+    'get_classification_choices_for_examination',
+    'get_morphology_classification_choices_for_examination',
+    'get_location_classification_choices_for_examination',
+
+    'get_classifications_for_examination',
+    'get_location_classifications_for_examination',
+    'get_morphology_classifications_for_examination',
+
+    'get_findings_for_examination',
+    'get_instruments_for_examination',
+    'get_interventions_for_examination',
+]

endoreg_db/views/examination/examination.py

@@ -0,0 +1,37 @@
+from rest_framework.viewsets import ReadOnlyModelViewSet
+from rest_framework.response import Response
+from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+
+from endoreg_db.models import (
+    Examination
+)
+from endoreg_db.serializers import ExaminationSerializer, FindingSerializer
+
+class ExaminationViewSet(ReadOnlyModelViewSet):
+    """
+    ViewSet for handling Examination related operations.
+    """
+    queryset = Examination.objects.all()
+    serializer_class = ExaminationSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly]
+
+    # Deprecated: we only use the ExaminationSerializer for now
+    # def get_serializer_class(self):
+    #     """
+    #     Returns the serializer class based on the request.
+    #     """
+    #     if self.request.query_params.get('optimized', 'false').lower() == 'true':
+    #         return OptimizedExaminationSerializer
+    #     return ExaminationSerializer
+
+    @action(detail=True, methods=['get'])
+    def findings(self, request, pk=None):
+        """
+        Get findings associated with a specific examination.
+        Called by: GET /api/examinations/{id}/findings/
+        """
+        examination = self.get_object()
+        findings = examination.get_available_findings()
+        serializer = FindingSerializer(findings, many=True)
+        return Response(serializer.data)

endoreg_db/views/examination/examination_manifest_cache.py

@@ -0,0 +1,26 @@
+from django.core.cache import cache
+
+
+class ExaminationManifestCache:
+    """Cache-Manager für Examination Manifests"""
+
+    @staticmethod
+    def get_cache_key(examination_id, language='en'):
+        return f"examination_manifest:{examination_id}:{language}"
+
+    @staticmethod
+    def get_manifest(examination_id, language='en'):
+        cache_key = ExaminationManifestCache.get_cache_key(examination_id, language)
+        return cache.get(cache_key)
+
+    @staticmethod
+    def set_manifest(examination_id, data, language='en', timeout=60*60):  # 1 Stunde
+        cache_key = ExaminationManifestCache.get_cache_key(examination_id, language)
+        cache.set(cache_key, data, timeout)
+
+    @staticmethod
+    def invalidate_manifest(examination_id):
+        """Invalidiere Cache für alle Sprachen"""
+        for lang in ['en', 'de']:
+            cache_key = ExaminationManifestCache.get_cache_key(examination_id, lang)
+            cache.delete(cache_key)

endoreg_db/views/examination/get_finding_classification_choices.py

@@ -0,0 +1,59 @@
+from endoreg_db.models import (
+    Examination,
+    FindingClassificationChoice,
+)
+from rest_framework.response import Response
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import api_view
+
+@api_view(["GET"])
+def get_classification_choices_for_examination(request, exam_id):
+    """
+    Retrieves distinct morphology classification choices for a specific examination.
+    
+    Returns a list of unique morphology classification choices associated with the required and optional morphology classification types of findings linked to the given examination.
+    """
+    exam = get_object_or_404(Examination, id=exam_id)
+    findings = exam.get_available_findings()
+    all_classifications = set()
+    for finding in findings:
+        all_classifications.update(set(finding.get_classifications()))
+    choices = FindingClassificationChoice.objects.filter(
+        classification__in=all_classifications
+    ).distinct()
+    return Response([{"id": c.id, "name": c.name} for c in choices])
+
+@api_view(["GET"])
+def get_morphology_classification_choices_for_examination(request, exam_id):
+    """
+    Retrieves distinct morphology classification choices for a specific examination.
+    
+    Returns a list of unique morphology classification choices associated with the required and optional morphology classification types of findings linked to the given examination.
+    """
+    exam = get_object_or_404(Examination, id=exam_id)
+    findings = exam.get_available_findings()
+    all_classifications = set()
+    for finding in findings:
+        all_classifications.update(set(finding.get_morphology_classifications()))
+    choices = FindingClassificationChoice.objects.filter(
+        classification__in=all_classifications
+    ).distinct()
+    return Response([{"id": c.id, "name": c.name} for c in choices])
+
+@api_view(["GET"])
+def get_location_classification_choices_for_examination(request, exam_id):
+    """
+    Retrieves distinct location classification choices for a specific examination.
+    
+    Returns a list of unique location classification choices associated with the required and optional location classification types of findings linked to the given examination.
+    """
+    
+    exam = get_object_or_404(Examination, id=exam_id)
+    findings = exam.get_available_findings()
+    all_classifications = set()
+    for finding in findings:
+        all_classifications.update(set(finding.get_location_classifications()))
+    choices = FindingClassificationChoice.objects.filter(
+        classification__in=all_classifications
+    ).distinct()
+    return Response([{"id": c.id, "name": c.name} for c in choices])

endoreg_db/views/examination/get_finding_classifications.py

@@ -0,0 +1,36 @@
+
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from django.shortcuts import get_object_or_404
+from endoreg_db.models import Examination, FindingClassification
+from endoreg_db.utils.translation import build_multilingual_response
+
+@api_view(["GET"])
+def get_classifications_for_examination(request, exam_id):
+    """
+    Retrieves all classifications for a specific examination.
+    
+    Returns a list of all FindingClassification objects linked to the given examination.
+    """
+    exam = get_object_or_404(Examination, id=exam_id)
+    classifications = FindingClassification.objects.filter(examinations=exam)
+    result = [build_multilingual_response(c) for c in classifications]
+    return Response(result)
+
+@api_view(["GET"])
+def get_location_classifications_for_examination(request, exam_id):
+    exam = get_object_or_404(Examination, id=exam_id)
+    location_classifications = FindingClassification.objects.filter(
+        classification_types__name__iexact="location",
+        examinations=exam
+    )
+    return Response([{"id": lc.id, "name": lc.name} for lc in location_classifications])
+
+@api_view(["GET"])
+def get_morphology_classifications_for_examination(request, exam_id):
+    exam = get_object_or_404(Examination, id=exam_id)
+    morphology_classifications = FindingClassification.objects.filter(
+        classification_types__name__iexact="morphology",
+        examinations=exam
+    )
+    return Response([{"id": mc.id, "name": mc.name} for mc in morphology_classifications])

endoreg_db/views/examination/get_findings.py

@@ -0,0 +1,41 @@
+
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from django.shortcuts import get_object_or_404
+from endoreg_db.models import Examination
+from ...serializers.finding import FindingSerializer
+from endoreg_db.utils.translation import build_multilingual_response
+from endoreg_db.models import PatientExamination
+
+@api_view(["GET"])
+def get_findings_for_examination(request, examination_id):
+    """
+    Retrieve findings for an examination.
+
+    Query Parameters:
+        format (str): Response format - 'optimized' or 'multilingual' (default: 'optimized')
+    """
+    exam = get_object_or_404(Examination, id=examination_id)
+    findings = exam.get_available_findings()
+
+    response_format = request.query_params.get('format', 'optimized')
+    if response_format == 'multilingual':
+        return Response([
+            build_multilingual_response(f)
+            for f in findings
+        ])
+    else:
+        serializer = FindingSerializer(findings, many=True)
+        return Response(serializer.data)
+    
+
+def get_findings_for_patient_examination(request, patient_examination_id):
+    """
+    Retrieve findings for a specific PatientExamination.
+    """
+    # Assuming PatientExamination model has a related_name 'patient_findings' for its findings
+    patient_examination = get_object_or_404(PatientExamination, id=patient_examination_id)
+    findings = patient_examination.patient_findings.all()
+    serializer = FindingSerializer(findings, many=True)
+    return Response(serializer.data)
+

endoreg_db/views/examination/get_instruments.py

@@ -0,0 +1,18 @@
+# from endoreg_db.models import (
+#     Examination,
+#     FindingClassificationChoice,
+# )
+from rest_framework.response import Response
+# from django.shortcuts import get_object_or_404
+from rest_framework.decorators import api_view
+
+
+@api_view(["GET"])
+def get_instruments_for_examination(request, exam_id):
+    # Placeholder if you plan to link instruments to exams
+    """
+    Returns an empty list of instruments for the specified examination.
+    
+    This placeholder endpoint is intended for future implementation of instrument retrieval linked to an examination.
+    """
+    return Response([])

endoreg_db/views/examination/get_interventions.py

@@ -0,0 +1,14 @@
+from endoreg_db.models import Examination, FindingIntervention
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+
+
+@api_view(["GET"])
+def get_interventions_for_examination(request, exam_id):
+    exam = get_object_or_404(Examination, id=exam_id)
+    findings = exam.get_available_findings()
+    interventions = FindingIntervention.objects.filter(findings__in=findings).distinct()
+    return Response([{"id": i.id, "name": i.name} for i in interventions])

endoreg_db/views/finding/__init__.py

@@ -0,0 +1,9 @@
+from .finding import FindingViewSet
+from .get_interventions import get_interventions_for_finding
+from .get_classifications import get_classifications_for_finding
+
+__all__ = [
+    "FindingViewSet",
+    "get_interventions_for_finding",
+    "get_classifications_for_finding"
+]

endoreg_db/views/finding/finding.py

@@ -0,0 +1,112 @@
+# endoreg_db/views/finding_views.py
+from rest_framework.viewsets import ReadOnlyModelViewSet
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from endoreg_db.models import Finding
+from ...serializers.finding import FindingSerializer
+
+class FindingViewSet(ReadOnlyModelViewSet):
+    queryset = Finding.objects.all()
+    serializer_class = FindingSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly]
+
+    @action(detail=True, methods=['get'])
+    def location_classifications(self, request, pk=None):
+        """
+        Get location classifications for a specific finding.
+        Called by: GET /api/findings/{id}/location-classifications/
+        """
+        try:
+            finding = self.get_object()
+            
+            assert isinstance(finding, Finding), "Finding object is not valid"
+            location_classifications = finding.get_location_classifications()
+            
+            # Return with choices included
+            result = []
+            for lc in location_classifications:
+                lc_data = {
+                    'id': lc.id,
+                    'name': lc.name,
+                    'name_de': getattr(lc, 'name_de', ''),
+                    'name_en': getattr(lc, 'name_en', ''),
+                    'description': getattr(lc, 'description', ''),
+                    'description_de': getattr(lc, 'description_de', ''),
+                    'description_en': getattr(lc, 'description_en', ''),
+                    'required': True,  # TODO: Determine if required or optional
+                    'choices': []
+                }
+                
+                # Get choices for this classification
+                choices = lc.get_choices()
+                for choice in choices:
+                    lc_data['choices'].append({
+                        'id': choice.id,
+                        'name': choice.name,
+                        'name_de': getattr(choice, 'name_de', ''),
+                        'name_en': getattr(choice, 'name_en', ''),
+                        'description': getattr(choice, 'description', ''),
+                        'description_de': getattr(choice, 'description_de', ''),
+                        'description_en': getattr(choice, 'description_en', ''),
+                        'classificationId': lc.id
+                    })
+                
+                result.append(lc_data)
+            
+            return Response(result)
+        except Exception as e:
+            return Response({'error': str(e)}, status=500)
+
+    @action(detail=True, methods=['get'])
+    def morphology_classifications(self, request, pk=None):
+        """
+        Get morphology classifications for a specific finding.
+        Called by: GET /api/findings/{id}/morphology-classifications/
+        """
+        try:
+            finding = self.get_object()
+            assert isinstance(finding, Finding), "Finding object is not valid"
+            morphology_classifications = finding.get_morphology_classifications()
+            
+            # Return with choices included
+            result = []
+            for mc in morphology_classifications:
+                mc_data = {
+                    'id': mc.id,
+                    'name': mc.name,
+                    'name_de': getattr(mc, 'name_de', ''),
+                    'name_en': getattr(mc, 'name_en', ''),
+                    'description': getattr(mc, 'description', ''),
+                    'description_de': getattr(mc, 'description_de', ''),
+                    'description_en': getattr(mc, 'description_en', ''),
+                    'required': True,  # TODO: Determine if required or optional
+                    'choices': []
+                }
+                
+                # Get choices for this classification
+                choices = mc.get_choices()
+                for choice in choices:
+                    mc_data['choices'].append({
+                        'id': choice.id,
+                        'name': choice.name,
+                        'name_de': getattr(choice, 'name_de', ''),
+                        'name_en': getattr(choice, 'name_en', ''),
+                        'description': getattr(choice, 'description', ''),
+                        'description_de': getattr(choice, 'description_de', ''),
+                        'description_en': getattr(choice, 'description_en', ''),
+                        'classificationId': mc.id
+                    })
+                
+                result.append(mc_data)
+            
+            return Response(result)
+        except Exception as e:
+            return Response({'error': str(e)}, status=500)
+      
+    @action(detail=False, methods=['get'], url_path='by-id/(?P<finding_id>[^/.]+)')
+    def get_finding_by_id(self, request, finding_id=None):
+        findings_obj = Finding.objects.filter(id=finding_id)
+        serializer = FindingSerializer(findings_obj, many=False)
+        return Response(serializer.data)
+    

endoreg_db/views/finding/get_classifications.py

@@ -0,0 +1,14 @@
+from endoreg_db.models import Finding
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+
+
+@api_view(["GET"])
+def get_classifications_for_finding(request, finding_id):
+    finding = get_object_or_404(Finding, id=finding_id)
+    classifications = finding.get_classifications()
+
+    return Response([{"id": i.id, "name": i.name} for i in classifications])

endoreg_db/views/finding/get_interventions.py

@@ -0,0 +1,17 @@
+from endoreg_db.models import Examination, Finding
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+
+
+@api_view(["GET"])
+def get_interventions_for_finding(request, exam_id, finding_id):
+    exam = get_object_or_404(Examination, id=exam_id)
+    finding = get_object_or_404(Finding, id=finding_id)
+    exam_findings = exam.get_available_findings()
+    if finding not in exam_findings:
+        return Response({"error": "Finding not found for this examination"}, status=404)
+    interventions = finding.finding_interventions.all()
+    return Response([{"id": i.id, "name": i.name} for i in interventions])