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

endoreg_db/views/meta/sensitive_meta_list.py

@@ -0,0 +1,104 @@
+from endoreg_db.models import SensitiveMeta
+from endoreg_db.serializers.meta.sensitive_meta_detail import SensitiveMetaDetailSerializer
+
+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 SensitiveMetaListView(APIView):
+    """
+    API endpoint to list SensitiveMeta entries with filtering options.
+
+    GET: Returns paginated list of SensitiveMeta entries
+    """
+
+    permission_classes = DEBUG_PERMISSIONS  
+
+    def get(self, request):
+        """
+        List SensitiveMeta entries with optional filtering.
+
+        Query Parameters:
+        - verified: Filter by verification status (true/false)
+        - center: Filter by center name
+        - limit: Number of results to return (default 20)
+        - offset: Offset for pagination (default 0)
+        """
+        try:
+            # Base queryset with related data
+            queryset = SensitiveMeta.objects.select_related(
+                'center',
+                'patient_gender',
+                'state'
+            ).prefetch_related('examiners')
+
+            # Apply filters
+            verified_filter = request.query_params.get('verified')
+            if verified_filter is not None:
+                if verified_filter.lower() == 'true':
+                    # Filter for entries where both DOB and names are verified
+                    queryset = queryset.filter(
+                        state__dob_verified=True,
+                        state__names_verified=True
+                    )
+                elif verified_filter.lower() == 'false':
+                    # Filter for entries that are not fully verified
+                    queryset = queryset.exclude(
+                        state__dob_verified=True,
+                        state__names_verified=True
+                    )
+
+            center_filter = request.query_params.get('center')
+            if center_filter:
+                queryset = queryset.filter(center__name__icontains=center_filter)
+
+            # Pagination
+            try:
+                limit = int(request.query_params.get('limit', 10))
+                if limit < 0:
+                    limit = 10
+            except (ValueError, TypeError):
+                limit = 10
+            
+            try:
+                offset = int(request.query_params.get('offset', 0))
+                if offset < 0:
+                    offset = 0
+            except (ValueError, TypeError):
+                offset = 0
+
+            # Enforce a maximum limit
+            if limit > 100:
+                limit = 100
+
+            paginated_queryset = queryset[offset:offset + limit]
+
+            # Serialize results
+            serializer = SensitiveMetaDetailSerializer(paginated_queryset, many=True)
+
+            response_data = {
+                "results": serializer.data,
+                "total_count": queryset.count(),
+                "limit": limit,
+                "offset": offset,
+                "has_more": (offset + limit) < queryset.count()
+            }
+
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        except ValueError as e:
+            return Response(
+                {"error": f"Invalid query parameters: {e}"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Error listing SensitiveMeta entries: {e}")
+            return Response(
+                {"error": "Internal server error occurred"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/meta/sensitive_meta_verification.py

@@ -0,0 +1,71 @@
+from endoreg_db.models import SensitiveMeta
+from endoreg_db.serializers.meta import SensitiveMetaDetailSerializer, SensitiveMetaVerificationSerializer
+
+from django.db import transaction
+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 SensitiveMetaVerificationView(APIView):
+    """
+    API endpoint specifically for updating verification state.
+
+    POST: Update verification flags (dob_verified, names_verified) for a SensitiveMeta
+    """
+
+    permission_classes = DEBUG_PERMISSIONS  # Changed from IsAuthenticated for development
+
+    @transaction.atomic
+    def post(self, request):
+        """
+        Update verification state for a SensitiveMeta instance.
+
+        Expected payload:
+        {
+            "sensitive_meta_id": 123,
+            "dob_verified": true,
+            "names_verified": true
+        }
+        """
+        serializer = SensitiveMetaVerificationSerializer(data=request.data)
+
+        if serializer.is_valid():
+            try:
+                state = serializer.save()
+                sensitive_meta_id = serializer.validated_data['sensitive_meta_id']
+
+                # Get updated SensitiveMeta for response
+                sensitive_meta = SensitiveMeta.objects.get(id=sensitive_meta_id)
+                response_serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+
+                response_data = {
+                    "message": "Verification state updated successfully",
+                    "sensitive_meta": response_serializer.data,
+                    "state_verified": state.is_verified
+                }
+
+                logger.info(
+                    f"Updated verification state for SensitiveMeta {sensitive_meta_id} "
+                    f"by user {request.user}. Overall verified: {state.is_verified}"
+                )
+
+                return Response(response_data, status=status.HTTP_200_OK)
+
+            except Exception as e:
+                logger.error(f"Error in verification update: {e}")
+                return Response(
+                    {"error": f"Failed to update verification state: {e}"},
+                    status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                )
+        else:
+            return Response(
+                {
+                    "error": "Validation failed",
+                    "details": serializer.errors
+                },
+                status=status.HTTP_400_BAD_REQUEST
+            )

endoreg_db/views/misc/__init__.py

@@ -0,0 +1,63 @@
+from .center import CenterViewSet
+from .csrf import csrf_token_view
+from .gender import GenderViewSet
+from .stats import (
+    ExaminationStatsView,
+    VideoSegmentStatsView,
+    SensitiveMetaStatsView,
+    GeneralStatsView,
+)
+from .secure_file_url_view import SecureFileUrlView
+from .secure_file_serving_view import SecureFileServingView
+from .secure_url_validate import validate_secure_url
+
+from .translation import (
+    ExaminationTranslationOptions,
+    FindingTranslationOptions,
+    FindingClassificationTranslationOptions,
+    FindingClassificationChoiceTranslationOptions,
+    InterventionTranslationOptions,
+    TranslatedFieldMixin,
+    TranslationMigrationHelper,
+    TranslatedFixtureLoader,
+    MODELTRANSLATION_SETTINGS
+)
+from .upload_views import (
+    UploadFileView,
+    UploadStatusView,
+)
+
+__all__ = [
+    "CenterViewSet",
+    'csrf_token_view',
+
+    # Gender view
+    "GenderViewSet",
+
+    # Stats views
+    'ExaminationStatsView',
+    'VideoSegmentStatsView',
+    'SensitiveMetaStatsView',
+    "GeneralStatsView",
+
+    # Secure File / URL views
+    "SecureFileUrlView",
+    "SecureFileServingView",
+    "validate_secure_url",
+
+    # Translation options
+    'ExaminationTranslationOptions',
+    'FindingTranslationOptions',
+    'FindingClassificationTranslationOptions',
+    'FindingClassificationChoiceTranslationOptions',
+    'InterventionTranslationOptions',
+    'TranslatedFieldMixin',
+    'TranslationMigrationHelper',
+    'TranslatedFixtureLoader',
+    'MODELTRANSLATION_SETTINGS',
+
+    # Upload views
+    'UploadFileView',
+    'UploadStatusView',
+
+]

endoreg_db/views/misc/center.py

@@ -0,0 +1,13 @@
+from endoreg_db.models import Center
+from endoreg_db.serializers.administration import CenterSerializer
+
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+
+from rest_framework import viewsets
+
+
+class CenterViewSet(viewsets.ReadOnlyModelViewSet):
+    """API endpoint für Center-Optionen (nur lesend)"""
+    queryset = Center.objects.all()
+    serializer_class = CenterSerializer
+    permission_classes = DEBUG_PERMISSIONS

endoreg_db/views/misc/gender.py

@@ -0,0 +1,14 @@
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
+from ...models import Gender
+from ...serializers.administration import GenderSerializer
+
+
+class GenderViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    API endpoint for Gender options.
+    Provides read-only access to gender choices for patient forms.
+    """
+    queryset = Gender.objects.all()
+    serializer_class = GenderSerializer
+    permission_classes = [IsAuthenticatedOrReadOnly]

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