endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

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,
+}