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

endoreg_db/urls/__init__.py

@@ -0,0 +1,72 @@
+from django.urls import path, include
+from django.conf import settings
+from django.conf.urls.static import static
+from rest_framework.routers import DefaultRouter
+
+# Phase 1.2: Media Management URLs ✅ IMPLEMENTED  
+from .media import urlpatterns as media_url_patterns
+
+from endoreg_db.views import (
+    VideoViewSet,
+    ExaminationViewSet,
+    VideoExaminationViewSet,
+    FindingViewSet,
+    FindingClassificationViewSet, 
+    PatientFindingViewSet,
+    PatientExaminationViewSet
+)
+
+from .anonymization import url_patterns as anonymization_url_patterns
+from .classification import url_patterns as classification_url_patterns
+from .auth import urlpatterns as auth_url_patterns
+from .examination import urlpatterns as examination_url_patterns
+from .files import urlpatterns as files_url_patterns
+from .label_video_segments import url_patterns as label_video_segments_url_patterns
+from .label_video_segment_validate import url_patterns as label_video_segment_validate_url_patterns
+# TODO Phase 1.2: Implement VideoMediaView and PDFMediaView before enabling
+# from .media import urlpatterns as media_url_patterns
+from .sensitive_meta import urlpatterns as pdf_url_patterns
+from .report import url_patterns as report_url_patterns
+from .upload import urlpatterns as upload_url_patterns
+from .video import url_patterns as video_url_patterns
+from .requirements import urlpatterns as requirements_url_patterns
+from .patient import urlpatterns as patient_url_patterns
+from .stats import url_patterns as stats_url_patterns
+
+api_urls = []
+api_urls += classification_url_patterns
+api_urls += anonymization_url_patterns
+api_urls += auth_url_patterns
+api_urls += examination_url_patterns
+api_urls += files_url_patterns
+api_urls += label_video_segments_url_patterns
+api_urls += label_video_segment_validate_url_patterns  # Neue Validierungs-Endpunkte
+# Phase 1.2: Enable media_url_patterns ✅ IMPLEMENTED
+api_urls += media_url_patterns
+api_urls += pdf_url_patterns
+api_urls += report_url_patterns
+api_urls += upload_url_patterns
+api_urls += video_url_patterns
+api_urls += requirements_url_patterns
+api_urls += patient_url_patterns
+api_urls += stats_url_patterns
+
+router = DefaultRouter()
+router.register(r'videos', VideoViewSet, basename='videos')  
+router.register(r'examinations', ExaminationViewSet)
+router.register(r'video-examinations', VideoExaminationViewSet, basename='video-examinations')
+router.register(r'findings', FindingViewSet)
+router.register(r'classifications', FindingClassificationViewSet)
+router.register(r'patient-findings', PatientFindingViewSet)
+router.register(r'patient-examinations', PatientExaminationViewSet)
+
+# Export raw API urlpatterns (no prefix). The project-level endoreg_db/urls.py mounts these under /api/.
+urlpatterns = [
+    path('', include(api_urls)),  # Specific routes first
+    path('', include(router.urls)),  # Generic router routes second
+]
+
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
+    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
+

endoreg_db/urls/anonymization.py

@@ -0,0 +1,32 @@
+from django.urls import path
+from endoreg_db.views.anonymization import (
+    AnonymizationOverviewView,
+    AnonymizationValidateView,
+    start_anonymization,
+    anonymization_current,
+    anonymization_status,
+    polling_coordinator_info,
+    clear_processing_locks,
+    has_raw_video_file,
+)
+from endoreg_db.views.anonymization import media_management
+
+url_patterns = [
+    # URL patterns for anonymization overview
+    path('anonymization/items/overview/', AnonymizationOverviewView.as_view(), name='anonymization_items_overview'),
+    path('anonymization/<int:file_id>/current/', anonymization_current, name='set_current_for_validation'),
+    path('anonymization/<int:file_id>/start/', start_anonymization, name='start_anonymization'),
+    path('anonymization/<int:file_id>/status/', anonymization_status, name='get_anonymization_status'),
+    path('anonymization/<int:file_id>/validate/', AnonymizationValidateView.as_view(), name='validate_anonymization'),
+        # Polling Coordination API (new endpoints)
+    path('anonymization/polling-info/', polling_coordinator_info, name='polling_coordinator_info'),
+    path('anonymization/clear-locks/', clear_processing_locks, name='clear_processing_locks'),
+    path('anonymization/<int:file_id>/has-raw/', has_raw_video_file, name='has_raw_video_file'),
+
+    
+    # Media Management API (new endpoints)
+    path('media-management/status/', media_management.MediaManagementView.as_view(), name='media_management_status'),
+    path('media-management/cleanup/', media_management.MediaManagementView.as_view(), name='media_management_cleanup'),
+    path('media-management/force-remove/<int:file_id>/', media_management.force_remove_media, name='force_remove_media'),
+    path('media-management/reset-status/<int:file_id>/', media_management.reset_processing_status, name='reset_processing_status'),
+]

endoreg_db/urls/auth.py

@@ -0,0 +1,16 @@
+from django.urls import path
+
+from endoreg_db.views import (
+    public_home,
+    keycloak_login,
+    keycloak_callback,
+    csrf_token_view,
+)
+
+urlpatterns = [
+    # Authentication endpoints
+    path('endoreg_db/', public_home, name='public_home'),
+    path('login/', keycloak_login, name='keycloak_login'),
+    path('login/callback/', keycloak_callback, name='keycloak_callback'),
+    path('conf/', csrf_token_view, name='csrf_token'),
+]

endoreg_db/urls/classification.py

@@ -0,0 +1,39 @@
+'''
+---------------------------------------------------------------------------------------
+CLASSIFICATION API ENDPOINTS
+
+Diese Endpunkte führen automatische Polyp-Klassifikationen durch:
+- NICE: Für digitale Chromoendoskopie/NBI-basierte Klassifikation
+- PARIS: Für Standard-Weißlicht-Klassifikation
+
+Diese APIs sind für Backend-Verarbeitung gedacht und werden typischerweise
+nach dem Import eines Videos automatisch aufgerufen.
+---------------------------------------------------------------------------------------
+'''
+
+from django.urls import path
+
+url_patterns = [
+    # NICE Classification API
+    # POST /api/classifications/nice/
+    # Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
+    # Führt NICE-Klassifikation für spezifizierte Videos durch
+    # path('classifications/nice/', ForNiceClassificationView.as_view(), name='nice_classification'),
+    
+    # PARIS Classification API  
+    # POST /api/classifications/paris/
+    # Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
+    # Führt PARIS-Klassifikation für spezifizierte Videos durch
+    # path('classifications/paris/', ForParisClassificationView.as_view(), name='paris_classification'),
+    
+    # Batch Classification API (beide Typen)
+    # POST /api/classifications/batch/
+    # Body: {"video_ids": [1, 2, 3], "types": ["nice", "paris"]}
+    # Führt beide Klassifikationstypen für spezifizierte Videos durch
+    # path('classifications/batch/', BatchClassificationView.as_view(), name='batch_classification'),
+    
+    # Classification Status API
+    # GET /api/classifications/status/<video_id>/
+    # Gibt den Status der Klassifikationen für ein Video zurück
+    # path('classifications/status/<int:video_id>/', ClassificationStatusView.as_view(), name='classification_status'),
+]

endoreg_db/urls/examination.py

@@ -0,0 +1,54 @@
+from django.urls import path
+from endoreg_db.views import (
+    get_findings_for_examination,
+    get_classifications_for_finding,
+    get_classification_choices,
+    get_classifications_for_examination,
+    ExaminationCreateView,
+    PatientExaminationDetailView,
+    PatientExaminationListView,
+)
+
+urlpatterns = [# URL patterns for ExaminationForm.vue API calls
+    path(
+        'examinations/<int:examination_id>/findings/',
+        get_findings_for_examination,
+        name='get_findings_for_examination'
+    ),
+    path(
+        'findings/<int:finding_id>/classifications/',
+        get_classifications_for_finding,
+        name='get_classifications_for_finding'
+    ),
+    path(
+        'classifications/<int:classification_id>/choices/',
+        get_classification_choices,
+        name='get_choices_for_classification'
+    ),
+    # NEW: Examination CRUD endpoints for SimpleExaminationForm
+    # POST /api/examinations/create/ - Create new examination
+    # GET /api/examinations/{id}/ - Get examination details
+    # PATCH /api/examinations/{id}/ - Update examination
+    # GET /api/examinations/list/ - List examinations with filtering
+    # TODO: Clearly Distinguish between Examination (the template) and PatientExamination (the instance).
+    # The views below handle PatientExamination instances, which represent a specific examination performed on a patient.
+    # The URL names are updated to reflect this, using the 'patient_examination_*' prefix for clarity.
+    # TODO: Clearly Distinguish between Examination and PatientExamination by using 'patient-examination' prefix for clarity
+    path('patient-examinations/create/', ExaminationCreateView.as_view(), name='patient_examination_create'),
+    path('patient-examinations/<int:pk>/',     PatientExaminationDetailView.as_view(), name='patient_examination_detail'),
+    path('patient-examinations/list/', PatientExaminationListView.as_view(), name='patient_examination_list'),
+
+    # NEW ENDPOINTS FOR RESTRUCTURED FRONTEND
+    path(
+        'patient-examinations/<int:exam_id>/classifications/',
+        get_classifications_for_examination,
+        name='get_classifications_for_examination'
+    ),
+    
+    path(
+        'patient-examinations/<int:examination_id>/findings/',
+        get_findings_for_examination,
+        name='get_patient_examination_findings'
+    ),
+
+]

endoreg_db/urls/files.py

@@ -0,0 +1,6 @@
+from django.urls import path
+from endoreg_db.views import AvailableFilesListView
+
+urlpatterns = [
+    path('available-files/', AvailableFilesListView.as_view(), name='available_files_list'),
+]

endoreg_db/urls/label_video_segment_validate.py

@@ -0,0 +1,33 @@
+from django.urls import path
+
+from endoreg_db.views.label_video_segment.validate import (
+    LabelVideoSegmentValidateView,
+    BulkSegmentValidateView,
+    VideoSegmentValidationCompleteView
+)
+
+url_patterns = [
+    # Einzelne Segment-Validierung
+    # POST /api/label-video-segment/<int:segment_id>/validate/
+    path(
+        'label-video-segment/<int:segment_id>/validate/',
+        LabelVideoSegmentValidateView.as_view(),
+        name='label_video_segment_validate'
+    ),
+    
+    # Bulk-Validierung mehrerer Segmente
+    # POST /api/label-video-segments/validate-bulk/
+    path(
+        'label-video-segments/validate-bulk/',
+        BulkSegmentValidateView.as_view(),
+        name='label_video_segments_validate_bulk'
+    ),
+    
+    # Alle Segmente eines Videos als validiert markieren
+    # POST /api/videos/<int:video_id>/segments/validate-complete/
+    path(
+        'videos/<int:video_id>/segments/validate-complete/',
+        VideoSegmentValidationCompleteView.as_view(),
+        name='video_segments_validate_complete'
+    ),
+]

endoreg_db/urls/label_video_segments.py

@@ -0,0 +1,44 @@
+from django.urls import path
+from endoreg_db.views import (
+    create_video_segment_annotation, 
+    update_label_video_segment,
+    SensitiveMetaDetailView,
+    video_segments_view,
+    video_segment_detail_view,
+    get_lvs_by_name_and_video_id
+)
+
+url_patterns = [
+    path(
+        "lvs/by-label-name/<str:label_name>/by-video-id/<int:video_id>/",
+        get_lvs_by_name_and_video_id,
+        name='get_lvs_by_name_and_video_id'
+    ),
+    path(
+        'annotations/',
+        create_video_segment_annotation,
+        name='create_annotation'
+    ),
+    path(
+        'annotations/<int:annotation_id>/',
+        update_label_video_segment,
+        name='update_annotation'
+    ),
+    path(
+        'save-anonymization-annotation-video/<int:annotation_id>/',
+        SensitiveMetaDetailView.as_view(),
+        name='save_anonymization_annotation_video'
+    ),
+    # Label Video Segment API endpoints
+    path(
+        'video-segments/',
+        video_segments_view,
+        name='video_segments'
+    ),
+    path(
+        'video-segments/<int:segment_id>/',
+        video_segment_detail_view,
+        name='video_segment_detail'
+    ),
+
+]

endoreg_db/urls/media.py

@@ -0,0 +1,32 @@
+from django.urls import path
+
+from endoreg_db.views.media import (
+    VideoMediaView,
+    PDFMediaManagementView as PDFMediaView,  # Alias to avoid conflict with legacy pdf.PDFMediaView
+)
+from endoreg_db.views import (
+    VideoStreamView,
+)
+# ---------------------------------------------------------------------------------------
+# ANNOTATION API ENDPOINTS
+#
+# New endpoints for segment annotation management that create user-source segments
+# POST /api/annotations/ - Create new annotation (creates user segment if type=segment)
+# PATCH /api/annotations/<id>/ - Update annotation (creates user segment if timing/label changed)
+# ---------------------------------------------------------------------------------------
+
+# Simplified Meta and Validation Endpoints
+    
+urlpatterns = [
+    # Video media endpoints
+    path("media/videos/", VideoMediaView.as_view(), name="video-list"),
+    path("media/videos/<int:pk>/", VideoStreamView.as_view(), name="video-detail-stream"),  # Support ?type= params
+    path("media/videos/<int:pk>/details/", VideoMediaView.as_view(), name="video-detail"),  # JSON metadata
+    path("media/videos/<int:pk>/stream/", VideoStreamView.as_view(), name="video-stream"),  # Legacy support
+
+    # PDF media endpoints
+    path("media/pdfs/", PDFMediaView.as_view(), name="pdf-list"),
+    path("media/pdfs/<int:pk>/", PDFMediaView.as_view(), name="pdf-detail"),
+    path("media/pdfs/<int:pk>/stream/", PDFMediaView.as_view(), name="pdf-stream"),
+]
+    # ---------------------------------------------------------------------------------------

endoreg_db/urls/patient.py

@@ -0,0 +1,19 @@
+from endoreg_db.views import (
+    GenderViewSet,
+    CenterViewSet,
+    PatientViewSet,
+    PatientFindingViewSet
+)
+from rest_framework.routers import DefaultRouter
+from django.urls import path, include
+
+router = DefaultRouter()
+router.register(r'patients', PatientViewSet)
+router.register(r'centers', CenterViewSet)
+router.register(r'genders', GenderViewSet)
+router.register(r'patient-findings', PatientFindingViewSet)
+
+urlpatterns = [
+    path('', include(router.urls)),
+    path('check_pe_exist/<int:pk>/', PatientViewSet.as_view({'get': 'check_pe_exist'}), name='check_pe_exist'),
+]

endoreg_db/urls/report.py

@@ -0,0 +1,78 @@
+from django.urls import path
+from endoreg_db.views import (
+    ReportListView,
+    ReportWithSecureUrlView,
+    SecureFileUrlView,
+    ReportFileMetadataView,
+    SecureFileServingView,
+    validate_secure_url,
+)
+
+url_patterns = [        # ---------------------------------------------------------------------------------------
+        # REPORT SERVICE ENDPOINTS
+        #
+        # Neue API-Endpunkte für den Report-Service mit sicheren URLs
+        #
+        # Diese Endpunkte ermöglichen es dem Frontend (UniversalReportViewer), 
+        # Reports mit zeitlich begrenzten, sicheren URLs zu laden und anzuzeigen.
+        #
+        # Verwendung im Frontend:
+        #   - loadReportWithSecureUrl(reportId) 
+        #   - generateSecureUrl(reportId, fileType)
+        #   - validateCurrentUrl()
+        #
+        # ---------------------------------------------------------------------------------------
+
+        # API-Endpunkt für paginierte Report-Listen mit Filterung
+        # GET /api/reports/?page=1&page_size=20&status=pending&file_type=pdf&patient_name=John
+        # Lädt eine paginierte Liste aller Reports mit optionalen Filtern
+        path('reports/', 
+            ReportListView.as_view(), 
+            name='report_list'
+        ),
+
+        # API-Endpunkt für Reports mit automatischer sicherer URL-Generierung
+        # GET /api/reports/{report_id}/with-secure-url/
+        # Lädt Report-Daten inklusive Metadaten und generiert automatisch eine sichere URL
+        path(
+            'reports/<int:report_id>/with-secure-url/', 
+            ReportWithSecureUrlView.as_view(), 
+            name='report_with_secure_url'
+        ),
+
+        # API-Endpunkt für manuelle sichere URL-Generierung  
+        # POST /api/secure-file-urls/
+        # Body: {"report_id": 123, "file_type": "pdf"}
+        # Generiert eine neue sichere URL für einen bestehenden Report
+        path(
+            'secure-file-urls/', 
+            SecureFileUrlView.as_view(), 
+            name='generate_secure_file_url'
+        ),
+
+        # API-Endpunkt für Report-Datei-Metadaten
+        # GET /api/reports/{report_id}/file-metadata/
+        # Gibt Datei-Metadaten zurück (Größe, Typ, Datum, etc.)
+        path(
+            'reports/<int:report_id>/file-metadata/', 
+            ReportFileMetadataView.as_view(), 
+            name='report_file_metadata'
+        ),
+
+        # Sichere Datei-Serving-Endpunkt mit Token-Validierung
+        # GET /api/reports/{report_id}/secure-file/?token={token}
+        # Serviert die tatsächliche Datei über eine sichere, tokenbasierte URL
+        path(
+            'reports/<int:report_id>/secure-file/', 
+            SecureFileServingView.as_view(), 
+            name='secure_file_serving'
+        ),
+        # URL-Validierungs-Endpunkt
+        # GET /api/validate-secure-url/?url={url}
+        # Validiert, ob eine sichere URL noch gültig ist
+        path(
+            'validate-secure-url/', 
+            validate_secure_url, 
+            name='validate_secure_url'
+        ),
+]

endoreg_db/urls/requirements.py

@@ -0,0 +1,13 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from endoreg_db.views.requirement.lookup import LookupViewSet
+from endoreg_db.views.requirement.evaluate import evaluate_requirements
+
+
+router = DefaultRouter()
+router.register(r"lookup", LookupViewSet, basename="lookup/")
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("evaluate-requirements/", evaluate_requirements, name="evaluate-requirements/"),
+]

endoreg_db/urls/sensitive_meta.py

@@ -0,0 +1,36 @@
+from django.urls import path
+
+# Prefer explicit imports to avoid relying on parent __init__ exports
+from endoreg_db.views import (
+    SensitiveMetaDetailView,
+    SensitiveMetaVerificationView,
+    SensitiveMetaListView,
+)
+
+urlpatterns = [
+
+    # Sensitive Meta Detail API
+    path(
+        'pdf/sensitivemeta/<int:sensitive_meta_id>/', 
+        SensitiveMetaDetailView.as_view(), 
+        name='sensitive_meta_detail'
+    ),
+    # Alternative endpoint for query parameter access (backward compatibility)
+    path(
+        'pdf/sensitivemeta/', 
+        SensitiveMetaDetailView.as_view(), 
+        name='sensitive_meta_query'
+    ),
+
+    # Sensitive Meta Verification API
+    path(
+        'pdf/sensitivemeta/verify/', 
+        SensitiveMetaVerificationView.as_view(), 
+        name='sensitive_meta_verify'),
+
+    # Sensitive Meta List API
+    path(
+        'pdf/sensitivemeta/list/', 
+        SensitiveMetaListView.as_view(), 
+        name='sensitive_meta_list'),
+]

endoreg_db/urls/stats.py

@@ -0,0 +1,46 @@
+from django.urls import path
+
+from endoreg_db.views import (
+    ExaminationStatsView,
+    VideoSegmentStatsView,
+    SensitiveMetaStatsView,
+    GeneralStatsView,
+)
+
+url_patterns = [
+    # ---------------------------------------------------------------------------------------
+    # STATISTICS API ENDPOINTS
+    #
+    # Diese Endpunkte stellen Dashboard-Statistiken bereit für das Frontend
+    # ---------------------------------------------------------------------------------------
+
+    # Examination Statistics API
+    # GET /api/examinations/stats/
+    # Liefert Statistiken über Examinations und PatientExaminations
+    path('examinations/stats/', ExaminationStatsView.as_view(), name='examination_stats'),
+
+    # Video Segment Statistics API  
+    # GET /api/video-segment/stats/  (Note: singular 'segment' to match frontend)
+    # Liefert Statistiken über Video-Segmente und Label-Verteilung
+    path('video-segment/stats/', VideoSegmentStatsView.as_view(), name='video_segment_stats'),
+
+    # Alternative Video Segments Statistics API (plural version for compatibility)
+    # GET /api/video-segments/stats/
+    path('video-segments/stats/', VideoSegmentStatsView.as_view(), name='video_segments_stats'),
+
+    # Sensitive Meta Statistics API
+    # GET /api/video/sensitivemeta/stats/
+    # Liefert Statistiken über SensitiveMeta-Einträge und Verifikationsstatus
+    path('video/sensitivemeta/stats/', SensitiveMetaStatsView.as_view(), name='sensitive_meta_stats'),
+
+    # General Dashboard Statistics API
+    # GET /api/stats/
+    # Liefert allgemeine Übersichtsstatistiken für das Dashboard
+    path('stats/', GeneralStatsView.as_view(), name='general_stats'),
+
+    path(
+    'video-segments/stats/', 
+    VideoSegmentStatsView.as_view(), 
+    name='video_segments_stats'
+    ),
+]

endoreg_db/urls/upload.py

@@ -0,0 +1,20 @@
+from django.urls import path
+
+from endoreg_db.views import (
+    UploadFileView,
+    UploadStatusView,
+)
+
+urlpatterns = [
+    # Upload endpoints
+    path(
+        'upload/', 
+        UploadFileView.as_view(), 
+        name='video_upload'
+    ),
+    path(
+        'upload/<uuid:id>/status', 
+        UploadStatusView.as_view(), 
+        name='upload_status'
+    ),
+]