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

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

endoreg_db/views/misc/upload_views.py

@@ -0,0 +1,240 @@
+import mimetypes
+from django.http import Http404
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.parsers import MultiPartParser, FormParser
+from rest_framework.permissions import AllowAny
+from django.views.decorators.csrf import csrf_exempt
+from django.utils.decorators import method_decorator
+
+# Try to import python-magic, but provide fallback if not available
+try:
+    import magic
+    MAGIC_AVAILABLE = True
+except ImportError:
+    MAGIC_AVAILABLE = False
+
+from endoreg_db.models.upload_job import UploadJob
+from endoreg_db.serializers.misc.upload_job import (
+    UploadJobStatusSerializer,
+)
+
+# Try to import celery task, but provide fallback
+try:
+    from endoreg_db.tasks.upload_tasks import process_upload_job
+    CELERY_AVAILABLE = True
+except ImportError:
+    CELERY_AVAILABLE = False
+    # Define a dummy function for development
+    def process_upload_job(job_id):
+        pass
+
+
+@method_decorator(csrf_exempt, name='dispatch')
+class UploadFileView(APIView):
+    """
+    Handle file uploads (POST /api/upload/).
+    
+    Accepts multipart/form-data with a 'file' field containing PDF or video files.
+    Creates an UploadJob and starts asynchronous processing.
+    
+    Returns:
+        201 Created: {"upload_id": "<uuid>", "status_url": "/api/upload/<uuid>/status/"}
+        400 Bad Request: File validation errors
+    """
+    
+    parser_classes = [MultiPartParser, FormParser]
+    permission_classes = [AllowAny]  # Adjust based on your auth requirements
+    
+    # Maximum file size (1 GiB)
+    MAX_FILE_SIZE = 1024 * 1024 * 1024  # 1 GiB in bytes
+    
+    # Allowed MIME types
+    ALLOWED_MIME_TYPES = {
+        'application/pdf',
+        'video/mp4',
+        'video/avi', 
+        'video/quicktime',
+        'video/x-msvideo',
+        'video/x-ms-wmv'
+    }
+
+    def post(self, request, *args, **kwargs):
+        """
+        Handle file upload and create processing job.
+        """
+        # Validate file presence
+        if 'file' not in request.FILES:
+            return Response(
+                {'error': 'No file provided. Please include a file in the "file" field.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        uploaded_file = request.FILES['file']
+        
+        # Validate file is not empty
+        if not uploaded_file or uploaded_file.size == 0:
+            return Response(
+                {'error': 'Uploaded file is empty. Please select a valid file.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Validate file size
+        if uploaded_file.size > self.MAX_FILE_SIZE:
+            return Response(
+                {'error': f'File too large. Maximum size is {self.MAX_FILE_SIZE // (1024**3)} GB.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Validate filename
+        if not uploaded_file.name or uploaded_file.name.strip() == '':
+            return Response(
+                {'error': 'Invalid filename. Please ensure the file has a valid name.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Detect MIME type
+        try:
+            content_type = self._detect_mime_type(uploaded_file)
+        except Exception as e:
+            return Response(
+                {'error': f'Could not determine file type: {str(e)}'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        # Validate MIME type
+        if content_type not in self.ALLOWED_MIME_TYPES:
+            return Response(
+                {'error': f'Unsupported file type: {content_type}. Allowed types: PDF, MP4, AVI, MOV, WMV.'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        try:
+            # Create upload job
+            upload_job = UploadJob.objects.create(
+                file=uploaded_file,
+                content_type=content_type
+            )
+            
+            # Start asynchronous processing if Celery is available
+            if CELERY_AVAILABLE:
+                try:
+                    process_upload_job.delay(str(upload_job.id))
+                except Exception as e:
+                    # If Celery task fails to start, mark job as failed
+                    upload_job.mark_failed(f'Failed to start processing: {str(e)}')
+                    return Response(
+                        {'error': f'Failed to start processing: {str(e)}'},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    )
+            else:
+                # For development without Celery, mark as processing immediately
+                upload_job.mark_processing()
+                # In production, this would be handled by Celery
+                # For now, just leave it in processing state
+            
+            # Prepare response
+            status_url = reverse('upload_status', kwargs={'id': upload_job.id})
+            response_data = {
+                'upload_id': str(upload_job.id),  # Ensure UUID is converted to string
+                'status_url': status_url,
+                'message': 'Upload job created successfully'
+            }
+            
+            # Return the response data directly since serializer fields are read-only
+            return Response(
+                response_data,
+                status=status.HTTP_201_CREATED
+            )
+            
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to create upload job: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _detect_mime_type(self, uploaded_file) -> str:
+        """
+        Detect MIME type using python-magic as primary method,
+        fallback to mimetypes module.
+        """
+        try:
+            # Reset file pointer
+            uploaded_file.seek(0)
+            
+            # Try python-magic first (more reliable) if available
+            if MAGIC_AVAILABLE:
+                try:
+                    # Read first chunk for magic detection
+                    chunk = uploaded_file.read(2048)
+                    uploaded_file.seek(0)  # Reset again
+                    
+                    mime_type = magic.from_buffer(chunk, mime=True)
+                    if mime_type and mime_type != 'application/octet-stream':
+                        return mime_type
+                except Exception:
+                    pass  # Fall back to mimetypes
+            
+            # Fallback to mimetypes module
+            mime_type, _ = mimetypes.guess_type(uploaded_file.name)
+            if mime_type:
+                return mime_type
+            
+            # Last resort - check file extension
+            if uploaded_file.name.lower().endswith('.pdf'):
+                return 'application/pdf'
+            elif uploaded_file.name.lower().endswith(('.mp4', '.m4v')):
+                return 'video/mp4'
+            elif uploaded_file.name.lower().endswith('.avi'):
+                return 'video/avi'
+            elif uploaded_file.name.lower().endswith(('.mov', '.qt')):
+                return 'video/quicktime'
+            elif uploaded_file.name.lower().endswith('.wmv'):
+                return 'video/x-ms-wmv'
+            
+            raise ValueError("Could not determine file type")
+            
+        finally:
+            # Ensure file pointer is reset
+            uploaded_file.seek(0)
+
+
+class UploadStatusView(APIView):
+    """
+    Get upload job status (GET /api/upload/<uuid>/status/).
+    
+    Returns current processing status and relevant metadata.
+    Should be polled every 2 seconds by the frontend.
+    
+    Returns:
+        200 OK: Status information
+        404 Not Found: Upload job not found
+    """
+    
+    permission_classes = [AllowAny]  # Adjust based on your auth requirements
+
+    def get(self, request, id, *args, **kwargs):
+        """
+        Return the current status of an upload job.
+        """
+        try:
+            # Look up upload job by UUID
+            upload_job = UploadJob.objects.select_related('sensitive_meta').get(id=id)
+            
+            # Serialize the response
+            serializer = UploadJobStatusSerializer(upload_job)
+            
+            return Response(
+                serializer.data,
+                status=status.HTTP_200_OK
+            )
+            
+        except UploadJob.DoesNotExist:
+            raise Http404("Upload job not found")
+        except Exception as e:
+            return Response(
+                {'error': f'Failed to get upload status: {str(e)}'},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/patient/__init__.py

@@ -0,0 +1,5 @@
+from .patient import PatientViewSet
+
+__all__ = [
+    "PatientViewSet"
+]