endoreg-db 0.8.8.0__py3-none-any.whl → 0.8.9.2__py3-none-any.whl

endoreg_db/views/meta/available_files_list.py

@@ -1,146 +0,0 @@
-from endoreg_db.models import RawPdfFile, VideoFile
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-import logging
-
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-logger = logging.getLogger(__name__)
-
-class AvailableFilesListView(APIView):
-    """
-    API endpoint to list available PDFs and videos for anonymization selection.
-
-    GET: Returns lists of available PDF and video files with their metadata
-    """
-
-    permission_classes = DEBUG_PERMISSIONS
-
-    def _validate_pagination_params(self, request):
-        """Validates and returns pagination parameters, raising ValueError on failure."""
-        try:
-            limit = int(request.query_params.get('limit', 50))
-            offset = int(request.query_params.get('offset', 0))
-        except (ValueError, TypeError):
-            raise ValueError("Invalid 'limit' or 'offset' parameter. Must be integers.")
-
-        if limit < 0 or offset < 0:
-            raise ValueError("'limit' and 'offset' must be non-negative.")
-        
-        if limit > 100:
-            logger.warning(f"Client requested limit of {limit}, capping at 100.")
-            limit = 100
-
-        return limit, offset
-
-    def get(self, request):
-        """
-        List available PDF and video files for anonymization selection.
-
-        Query Parameters:
-        - type: Filter by file type ('pdf' or 'video')
-        - status: Filter by anonymization status
-        - limit: Number of results to return (default 50, max 100)
-        - offset: Offset for pagination (default 0)
-
-        Returns:
-        {
-            "pdfs": [...],
-            "videos": [...],
-            "total_pdfs": N,
-            "total_videos": N
-        }
-        """
-        try:
-            limit, offset = self._validate_pagination_params(request)
-            file_type = request.query_params.get('type', 'all').lower()
-        except ValueError as e:
-            return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
-
-        try:
-            response_data = {}
-
-            # Get PDFs if requested
-            if file_type in ['all', 'pdf']:
-                pdf_queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
-                total_pdfs = pdf_queryset.count()
-                paginated_pdfs = pdf_queryset[offset:offset + limit]
-
-                pdf_list = []
-                for pdf in paginated_pdfs:
-                    # Safely handle missing file attribute
-                    file_name = 'Unknown'
-                    file_path = None
-                    if hasattr(pdf, 'file') and pdf.file:
-                        file_name = pdf.file.name.split('/')[-1]
-                        file_path = pdf.file.name
-                    pdf_data = {
-                        'id': pdf.id,
-                        'filename': file_name,
-                        'file_path': file_path,
-                        'sensitive_meta_id': pdf.sensitive_meta_id,
-                        'anonymized_text': getattr(pdf, 'anonymized_text', None),
-                        'created_at': pdf.date_created if hasattr(pdf, 'created_at') else None,
-                        'patient_info': None
-                    }
-
-                    # Add patient info if available
-                    if pdf.sensitive_meta:
-                        pdf_data['patient_info'] = {
-                            'patient_first_name': pdf.sensitive_meta.patient_first_name,
-                            'patient_last_name': pdf.sensitive_meta.patient_last_name,
-                            'patient_dob': pdf.sensitive_meta.patient_dob,
-                            'examination_date': pdf.sensitive_meta.examination_date,
-                            'center_name': pdf.sensitive_meta.center.name if pdf.sensitive_meta.center else None
-                        }
-
-                    pdf_list.append(pdf_data)
-
-                response_data['pdfs'] = pdf_list
-                response_data['total_pdfs'] = total_pdfs
-
-            # Get Videos if requested
-            if file_type in ['all', 'video']:
-                video_queryset = VideoFile.objects.select_related('sensitive_meta').all()
-                total_videos = video_queryset.count()
-                paginated_videos = video_queryset[offset:offset + limit]
-
-                video_list = []
-                for video in paginated_videos:
-                    # Safely handle missing raw_file attribute
-                    file_name = 'Unknown'
-                    file_path = None
-                    if hasattr(video, 'raw_file') and video.raw_file:
-                        file_name = video.raw_file.name.split('/')[-1]
-                        file_path = video.raw_file.name
-                    video_data = {
-                        'id': video.id,
-                        'filename': file_name,
-                        'file_path': file_path,
-                        'sensitive_meta_id': video.sensitive_meta_id,
-                        'patient_info': None
-                    }
-
-                    # Add patient info if available
-                    if video.sensitive_meta:
-                        video_data['patient_info'] = {
-                            'patient_first_name': video.sensitive_meta.patient_first_name,
-                            'patient_last_name': video.sensitive_meta.patient_last_name,
-                            'patient_dob': video.sensitive_meta.patient_dob,
-                            'examination_date': video.sensitive_meta.examination_date,
-                            'center_name': video.sensitive_meta.center.name if video.sensitive_meta.center else None
-                        }
-
-                    video_list.append(video_data)
-
-                response_data['videos'] = video_list
-                response_data['total_videos'] = total_videos
-
-            return Response(response_data)
-        except Exception as e:
-            logger.error(f"Error listing available files: {e}", exc_info=True)
-            return Response(
-                {"error": "An unexpected error occurred while fetching files."},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/meta/report_meta.py

@@ -1,53 +0,0 @@
-from endoreg_db.models import RawPdfFile
-
-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
-
-logger = logging.getLogger(__name__)
-
-class ReportFileMetadataView(APIView):
-    """
-    API-Endpunkt für Report-Datei-Metadaten
-    GET /api/reports/{report_id}/file-metadata/
-    """
-
-    def get(self, _request, report_id):
-        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
-                )
-
-            metadata = self._get_file_metadata(report)
-            return Response(metadata)
-
-        except (ValueError, TypeError) as e:
-            logger.error("Fehler beim Laden der Datei-Metadaten: %s", str(e))
-            return Response(
-                {"error": "Metadaten konnten nicht geladen werden"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
-
-    def _get_file_metadata(self, report):
-        """Sammelt Datei-Metadaten"""
-        file_path = Path(report.file.name)
-
-        try:
-            file_size = report.file.size
-        except OSError:
-            file_size = 0
-
-        return {
-            'filename': file_path.name,
-            'file_type': file_path.suffix.lower().lstrip('.'),
-            'file_size': file_size,
-            'upload_date': report.created_at if hasattr(report, 'created_at') else None,
-            'last_modified': report.updated_at if hasattr(report, 'updated_at') else None
-        }

endoreg_db/views/meta/sensitive_meta_detail.py

@@ -1,85 +0,0 @@
-from endoreg_db.models import SensitiveMeta
-from endoreg_db.serializers import SensitiveMetaDetailSerializer, SensitiveMetaUpdateSerializer
-
-from django.db import transaction
-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 endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-import logging
-
-logger = logging.getLogger(__name__)
-
-class SensitiveMetaDetailView(APIView):
-    """
-    API endpoint to retrieve and update SensitiveMeta details with verification state.
-
-    GET: Returns detailed SensitiveMeta information for annotation/verification
-    PATCH: Updates SensitiveMeta fields including verification state
-    """
-
-    @transaction.atomic
-    def patch(self, request, sensitive_meta_id=None):
-        """
-        Update SensitiveMeta fields including verification state.
-
-        Accepts partial updates for any field in SensitiveMetaUpdateSerializer.
-        Special handling for verification state changes.
-        """
-        if not sensitive_meta_id:
-            return Response(
-                {"error": "sensitive_meta_id is required"},
-                status=status.HTTP_400_BAD_REQUEST
-            )
-
-        try:
-            # Get the SensitiveMeta instance
-            sensitive_meta = get_object_or_404(SensitiveMeta, id=sensitive_meta_id)
-
-            # Validate and update using serializer
-            serializer = SensitiveMetaUpdateSerializer(
-                sensitive_meta,
-                data=request.data,
-                partial=True
-            )
-
-            if serializer.is_valid():
-                updated_instance = serializer.save()
-
-                # Return updated data using detail serializer
-                response_serializer = SensitiveMetaDetailSerializer(updated_instance)
-
-                response_data = {
-                    "message": "SensitiveMeta updated successfully",
-                    "sensitive_meta": response_serializer.data,
-                    "updated_fields": list(request.data.keys())
-                }
-
-                logger.info(
-                    f"Updated SensitiveMeta {sensitive_meta_id} by user {request.user}. "
-                    f"Fields: {list(request.data.keys())}"
-                )
-
-                return Response(response_data, status=status.HTTP_200_OK)
-            else:
-                return Response(
-                    {
-                        "error": "Validation failed",
-                        "details": serializer.errors
-                    },
-                    status=status.HTTP_400_BAD_REQUEST
-                )
-
-        except SensitiveMeta.DoesNotExist:
-            return Response(
-                {"error": f"SensitiveMeta with ID {sensitive_meta_id} not found"},
-                status=status.HTTP_404_NOT_FOUND
-            )
-        except Exception as e:
-            logger.error(f"Error updating SensitiveMeta {sensitive_meta_id}: {e}")
-            return Response(
-                {"error": "Internal server error occurred"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

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