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

endoreg_db/views/anonymization/validate.py

@@ -0,0 +1,63 @@
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from django.db import transaction
+from endoreg_db.models import VideoFile, RawPdfFile
+from endoreg_db.serializers.anonymization import SensitiveMetaValidateSerializer
+
+
+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
+    }
+    
+    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)
+        payload = serializer.validated_data
+        payload.setdefault("is_verified", True)
+
+        # Try Video first
+        video = VideoFile.objects.filter(pk=file_id).first()
+        if video:
+            # Ensure center_name is in payload for hash calculation
+            if video.center and not payload.get("center_name"):
+                payload["center_name"] = video.center.name
+                
+            ok = video.validate_metadata_annotation(payload)
+            #if ok:
+            #    video._cleanup_raw_assets()
+            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)
+
+        # Then PDF
+        pdf = RawPdfFile.objects.filter(pk=file_id).first()
+        if pdf:
+            # Ensure center_name is in payload for hash calculation
+            if pdf.center and not payload.get("center_name"):
+                payload["center_name"] = pdf.center.name
+                
+            ok = pdf.validate_metadata_annotation(payload)
+            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)
+
+        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)

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/{views.py → auth/keycloak.py}

@@ -1,25 +1,26 @@
-#for keycloak need to make separate onne,demo
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.views import APIView
 from rest_framework.response import Response
 
-from django.shortcuts import redirect, render
+from django.shortcuts import redirect
 from django.conf import settings
 from urllib.parse import urlencode
 import requests
+from django.http import HttpResponse
 
 """
-    User hits /api/videos/
+    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 /api/videos/ again
+    User is redirected to /videos/ again
     Middleware now sees token, verifies it, injects user
-    DRF view (VideoView) is allowed to execute and returns data
+    DRF view (KeycloakVideoView) is allowed to execute and returns data
 """
-class VideoView(APIView):
+class KeycloakVideoView(APIView):
     permission_classes = [IsAuthenticated] #This uses DRF permissions to ensure request.user.is_authenticated == True.
+    print("1")
 
     def get(self, request):
         """
@@ -31,6 +32,7 @@ class VideoView(APIView):
 
 
 def keycloak_login(request):
+    print("1")
 
     """
     - This gets triggered when middleware redirects to /login/.
@@ -47,18 +49,20 @@ def keycloak_login(request):
         "redirect_uri": redirect_uri,
     }
     # Redirect user to Keycloak login page.
-    return redirect(f"{auth_url}?{urlencode(params)}")
+    print("1")
 
+    return redirect(f"{auth_url}?{urlencode(params)}")
 
-import json
-from django.http import HttpResponse
 
-from django.http import HttpResponse, HttpResponseRedirect
-import json
 
 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)
@@ -97,11 +101,13 @@ def keycloak_callback(request):
         request.session["refresh_token"] = token_data["refresh_token"]
         print("Refresh Token:", request.session.get("refresh_token"))
 
-        return redirect("/api/videos/")
+        return redirect("/videos/")
 
     except Exception as e:
         return HttpResponse(f" Exception during token exchange: {str(e)}", status=500)
 
 
 def public_home(request):
-    return HttpResponse("just for demo - This is a public home page — no login required.")
+    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])

endoreg_db/views/finding_classification/__init__.py

@@ -0,0 +1,13 @@
+from .finding_classification import FindingClassificationViewSet
+from .get_classification_choices import (
+    get_classification_choices,
+    get_morphology_choices, # DEPRECATED
+    get_location_choices, # DEPRECATED
+)
+
+__all__ = [
+    "FindingClassificationViewSet",
+    "get_classification_choices",
+    "get_morphology_choices", # DEPRECATED
+    "get_location_choices", # DEPRECATED
+]

endoreg_db/views/finding_classification/finding_classification.py

@@ -0,0 +1,42 @@
+# endoreg_db/views/finding_classification/base.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 rest_framework import status
+from endoreg_db.models import (
+    FindingClassification,
+)
+from ...serializers.finding_classification import (
+    FindingClassificationSerializer,
+    FindingClassificationChoiceSerializer,
+)
+
+class FindingClassificationViewSet(ReadOnlyModelViewSet):
+    queryset = FindingClassification.objects.all()
+    serializer_class = FindingClassificationSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly]
+
+    @action(detail=True, methods=['get'])
+    def choices(self, request, pk=None):
+        """
+        Get choices for a specific location classification.
+        Called by: GET /api/finding-classifications/{id}/choices/
+        """
+        try:
+            classification = self.get_object()
+            choices = classification.get_choices()
+            
+            serializer = FindingClassificationChoiceSerializer(choices, many=True)
+            return Response(serializer.data)
+        except FindingClassification.DoesNotExist:
+            return Response(
+                {"error": "FindingClassification not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+        except Exception as e:
+            return Response(
+                {"error": str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+