endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/views/misc/secure_file_serving_view.py

@@ -1,80 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,79 +0,0 @@
-# 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/patient_examination/DEPRECATED_video_backup.py

@@ -1,164 +0,0 @@
-# from rest_framework import viewsets, status
-# from rest_framework.response import Response
-# from django.shortcuts import get_object_or_404
-# from endoreg_db.models import Examination, VideoFile, Finding, FindingClassification
-# from django.db import transaction
-# from django.utils import timezone
-# import logging
-
-
-# class VideoExaminationViewSet(viewsets.ModelViewSet):
-#     """
-#     ViewSet for Video Examination CRUD operations
-#     Handles POST and PATCH for video examinations at timestamps
-#     """
-#     def get_queryset(self):
-#         return []
-
-#     def create(self, request, *args, **kwargs):
-
-#         logger = logging.getLogger(__name__)
-#         try:
-#             data = request.data
-#             required_fields = ['videoId', 'timestamp', 'examinationTypeId', 'findingId']
-#             for field in required_fields:
-#                 if field not in data or data[field] is None:
-#                     return Response({'error': f'Missing or null required field: {field}'}, status=status.HTTP_400_BAD_REQUEST)
-#             try:
-#                 video_id = int(data['videoId'])
-#                 timestamp = float(data['timestamp'])
-#                 examination_type_id = int(data['examinationTypeId'])
-#                 finding_id = int(data['findingId'])
-#             except (ValueError, TypeError) as e:
-#                 return Response({'error': f'Invalid data type in request: {str(e)}'}, status=status.HTTP_400_BAD_REQUEST)
-#             if timestamp < 0:
-#                 return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
-#             with transaction.atomic():
-#                 try:
-#                     video = VideoFile.objects.get(id=video_id)
-#                 except VideoFile.DoesNotExist:
-#                     return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 try:
-#                     examination = Examination.objects.get(id=examination_type_id)
-#                 except Examination.DoesNotExist:
-#                     return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 try:
-#                     finding = Finding.objects.get(id=finding_id)
-#                 except Finding.DoesNotExist:
-#                     return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if data.get('locationClassificationId'):
-#                     try:
-#                         FindingClassification.objects.get(id=data['locationClassificationId'], classification_types__name__iexact="location")
-#                     except FindingClassification.DoesNotExist:
-#                         return Response({'error': 'Location classification not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if data.get('morphologyClassificationId'):
-#                     try:
-#                         FindingClassification.objects.get(id=data['morphologyClassificationId'], classification_types__name__iexact="morphology")
-#                     except FindingClassification.DoesNotExist:
-#                         return Response({'error': 'Morphology classification not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 examination_data = {
-#                     'id': f"exam_{video.id}_{timestamp}_{examination.id}",
-#                     'video_id': video_id,
-#                     'timestamp': timestamp,
-#                     'examination_type': examination.name,
-#                     'finding': finding.name,
-#                     'location_classification': data.get('locationClassificationId'),
-#                     'location_choice': data.get('locationChoiceId'),
-#                     'morphology_classification': data.get('morphologyClassificationId'),
-#                     'morphology_choice': data.get('morphologyChoiceId'),
-#                     'interventions': data.get('interventionIds', []),
-#                     'notes': data.get('notes', ''),
-#                     'created_at': timezone.now().isoformat()
-#                 }
-#                 logger.info(f"Created video examination for video {video_id} at timestamp {timestamp}")
-#                 return Response(examination_data, status=status.HTTP_201_CREATED)
-#         except Exception as e:
-#             logger.error(f"Unexpected error creating examination: {str(e)}")
-#             return Response({'error': 'Internal server error while creating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-#     def update(self, request, *args, **kwargs):
-#         logger = logging.getLogger(__name__)
-#         try:
-#             examination_id = kwargs.get('pk')
-#             if not examination_id:
-#                 return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
-#             data = request.data
-#             if 'videoId' in data:
-#                 try:
-#                     data['videoId'] = int(data['videoId'])
-#                 except (ValueError, TypeError):
-#                     return Response({'error': 'Invalid videoId format'}, status=status.HTTP_400_BAD_REQUEST)
-#             if 'timestamp' in data:
-#                 try:
-#                     timestamp = float(data['timestamp'])
-#                     if timestamp < 0:
-#                         return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
-#                     data['timestamp'] = timestamp
-#                 except (ValueError, TypeError):
-#                     return Response({'error': 'Invalid timestamp format'}, status=status.HTTP_400_BAD_REQUEST)
-#             with transaction.atomic():
-#                 if 'videoId' in data:
-#                     try:
-#                         VideoFile.objects.get(id=data['videoId'])
-#                     except VideoFile.DoesNotExist:
-#                         return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if 'examinationTypeId' in data:
-#                     try:
-#                         examination_type_id = int(data['examinationTypeId'])
-#                         Examination.objects.get(id=examination_type_id)
-#                     except (ValueError, TypeError):
-#                         return Response({'error': 'Invalid examination type ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#                     except Examination.DoesNotExist:
-#                         return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 if 'findingId' in data:
-#                     try:
-#                         finding_id = int(data['findingId'])
-#                         Finding.objects.get(id=finding_id)
-#                     except (ValueError, TypeError):
-#                         return Response({'error': 'Invalid finding ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#                     except Finding.DoesNotExist:
-#                         return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
-#                 examination_data = {
-#                     'id': examination_id,
-#                     'video_id': data.get('videoId'),
-#                     'timestamp': data.get('timestamp'),
-#                     'examination_type': data.get('examinationTypeId'),
-#                     'finding': data.get('findingId'),
-#                     'location_classification': data.get('locationClassificationId'),
-#                     'location_choice': data.get('locationChoiceId'),
-#                     'morphology_classification': data.get('morphologyClassificationId'),
-#                     'morphology_choice': data.get('morphologyChoiceId'),
-#                     'interventions': data.get('interventionIds', []),
-#                     'notes': data.get('notes', ''),
-#                     'updated_at': '2024-01-01T00:00:00Z'
-#                 }
-#                 logger.info(f"Updated video examination {examination_id}")
-#                 return Response(examination_data, status=status.HTTP_200_OK)
-#         except Exception as e:
-#             logger.error(f"Unexpected error updating examination {examination_id}: {str(e)}")
-#             return Response({'error': 'Internal server error while updating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-#     def destroy(self, request, *args, **kwargs):
-#         logger = logging.getLogger(__name__)
-#         try:
-#             examination_id = kwargs.get('pk')
-#             if not examination_id:
-#                 return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
-#             try:
-#                 if not str(examination_id).strip():
-#                     return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#             except (ValueError, TypeError):
-#                 return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
-#             with transaction.atomic():
-#                 logger.info(f"Deleted video examination {examination_id}")
-#                 return Response({'message': f'Examination {examination_id} deleted successfully'}, status=status.HTTP_204_NO_CONTENT)
-#         except Exception as e:
-#             logger.error(f"Unexpected error deleting examination {examination_id}: {str(e)}")
-#             return Response({'error': 'Internal server error while deleting examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-# from rest_framework.decorators import api_view
-# @api_view(["GET"])
-# def get_examinations_for_video(request, video_id):
-#     _video = get_object_or_404(VideoFile, id=video_id)
-#     #TODO no functionality implemented yet
-#     return Response([])

endoreg_db/views/patient_finding_location/__init__.py

@@ -1,5 +0,0 @@
-from .pfl_create import create_patient_finding_location
-
-__all__ = [
-    "create_patient_finding_location",
-]

endoreg_db/views/patient_finding_location/pfl_create.py

@@ -1,70 +0,0 @@
-from endoreg_db.serializers.patient_finding.patient_finding import PatientFindingSerializer
-from rest_framework.viewsets import ModelViewSet
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-from rest_framework import status
-from endoreg_db.models.medical.patient.patient_finding import PatientFinding
-from endoreg_db.models.medical.patient.patient_finding_location import PatientFindingLocation
-from endoreg_db.models.medical.patient.patient_finding_morphology import PatientFindingMorphology
-from endoreg_db.models import ( FindingLocationClassificationChoice, FindingMorphologyClassificationChoice )
-from rest_framework import serializers
-from utils.permissions import EnvironmentAwarePermission
-
-class PatientFindingViewSet(ModelViewSet):
-    queryset = PatientFinding.objects.all()
-    serializer_class = PatientFindingSerializer
-
-@api_view(['POST'])
-@permission_classes([EnvironmentAwarePermission])
-def create_patient_finding_location(request):
-    """
-    Create a patient finding location relationship.
-    Expected payload: {
-        "patient_finding_id": 1,
-        "location_classification_choice_id": 2
-    }
-    """
-    try:
-        patient_finding_id = request.data.get('patient_finding_id')
-        choice_id = request.data.get('location_classification_choice_id')
-        
-        if not patient_finding_id or not choice_id:
-            return Response(
-                {'detail': 'patient_finding_id and location_classification_choice_id are required'}, 
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        
-        # Get the objects
-        try:
-            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
-        except PatientFinding.DoesNotExist:
-            return Response(
-                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        try:
-            choice = FindingLocationClassificationChoice.objects.get(id=choice_id)
-        except FindingLocationClassificationChoice.DoesNotExist:
-            return Response(
-                {'detail': f'LocationClassificationChoice with id {choice_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        # Create the relationship
-        patient_finding_location = PatientFindingLocation.objects.create(
-            patient_finding=patient_finding,
-            location_classification_choice=choice
-        )
-        
-        return Response({
-            'id': patient_finding_location.id,
-            'patient_finding_id': patient_finding.id,
-            'location_classification_choice_id': choice.id
-        }, status=status.HTTP_201_CREATED)
-        
-    except Exception as e:
-        return Response(
-            {'detail': f'Error creating patient finding location: {str(e)}'}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )

endoreg_db/views/patient_finding_morphology/__init__.py

@@ -1,5 +0,0 @@
-from .pfm_create import create_patient_finding_morphology
-
-__all__ = [
-    "create_patient_finding_morphology",
-]

endoreg_db/views/patient_finding_morphology/pfm_create.py

@@ -1,70 +0,0 @@
-from endoreg_db.serializers.patient_finding.patient_finding import PatientFindingSerializer
-from rest_framework.viewsets import ModelViewSet
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-from rest_framework import status
-from endoreg_db.models.medical.patient.patient_finding import PatientFinding
-from endoreg_db.models.medical.patient.patient_finding_location import PatientFindingLocation
-from endoreg_db.models.medical.patient.patient_finding_morphology import PatientFindingMorphology
-from endoreg_db.models import ( FindingLocationClassificationChoice, FindingMorphologyClassificationChoice)
-from rest_framework import serializers
-from utils.permissions import EnvironmentAwarePermission
-
-class PatientFindingViewSet(ModelViewSet):
-    queryset = PatientFinding.objects.all()
-    serializer_class = PatientFindingSerializer
-
-@api_view(['POST'])
-@permission_classes([EnvironmentAwarePermission])
-def create_patient_finding_morphology(request):
-    """
-    Create a patient finding morphology relationship.
-    Expected payload: {
-        "patient_finding_id": 1,
-        "morphology_classification_choice_id": 2
-    }
-    """
-    try:
-        patient_finding_id = request.data.get('patient_finding_id')
-        choice_id = request.data.get('morphology_classification_choice_id')
-        
-        if not patient_finding_id or not choice_id:
-            return Response(
-                {'detail': 'patient_finding_id and morphology_classification_choice_id are required'}, 
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        
-        # Get the objects
-        try:
-            patient_finding = PatientFinding.objects.get(id=patient_finding_id)
-        except PatientFinding.DoesNotExist:
-            return Response(
-                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        try:
-            choice = FindingMorphologyClassificationChoice.objects.get(id=choice_id)
-        except FindingMorphologyClassificationChoice.DoesNotExist:
-            return Response(
-                {'detail': f'MorphologyClassificationChoice with id {choice_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
-            )
-        
-        # Create the relationship
-        patient_finding_morphology = PatientFindingMorphology.objects.create(
-            patient_finding=patient_finding,
-            morphology_classification_choice=choice
-        )
-        
-        return Response({
-            'id': patient_finding_morphology.id,
-            'patient_finding_id': patient_finding.id,
-            'morphology_classification_choice_id': choice.id
-        }, status=status.HTTP_201_CREATED)
-        
-    except Exception as e:
-        return Response(
-            {'detail': f'Error creating patient finding morphology: {str(e)}'}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )

endoreg_db/views/pdf/__init__.py

@@ -1,8 +0,0 @@
-from .reimport import PdfReimportView
-from .pdf_stream import PdfStreamView
-
-
-__all__ = [
-    "PdfReimportView",
-    "PdfStreamView",
-]