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

endoreg_db/views/meta/report_meta.py

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

@@ -0,0 +1,148 @@
+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
+    """
+
+    permission_classes = DEBUG_PERMISSIONS  # Changed from IsAuthenticated for development
+
+    def get(self, request, sensitive_meta_id=None):
+        """
+        Retrieve SensitiveMeta details for display and annotation.
+
+        Supports both URL parameter and query parameter access patterns:
+        - /api/pdf/sensitivemeta/123/ (URL parameter)
+        - /api/pdf/sensitivemeta/?id=123 (query parameter - for backward compatibility)
+        - /api/pdf/sensitivemeta/ (list all - returns empty list instead of 400)
+
+        Returns detailed information suitable for user verification.
+        """
+        # Handle both URL parameter and query parameter patterns
+        if not sensitive_meta_id:
+            sensitive_meta_id = request.query_params.get('id')
+
+        # If no ID provided, return empty list instead of error
+        if not sensitive_meta_id:
+            return Response([], status=status.HTTP_200_OK)
+
+        try:
+            # Convert to int if it's a string
+            sensitive_meta_id = int(sensitive_meta_id)
+
+            # Get the SensitiveMeta instance with related data
+            sensitive_meta = SensitiveMeta.objects.select_related(
+                'center',
+                'patient_gender',
+                'pseudo_patient',
+                'pseudo_examination'
+            ).prefetch_related(
+                'examiners',
+                'state'
+            ).get(id=sensitive_meta_id)
+
+            # Serialize for display
+            serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+
+            # Return direct data to match anonymization store expectations
+            # Instead of wrapping in "sensitive_meta" key, return data directly
+            response_data = serializer.data
+
+            logger.info(f"Retrieved SensitiveMeta {sensitive_meta_id} for user {request.user}")
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        except ValueError:
+            return Response(
+                {"error": "Invalid sensitive_meta_id format. Must be an integer."},
+                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 retrieving SensitiveMeta {sensitive_meta_id}: {e}")
+            return Response(
+                {"error": "Internal server error occurred"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    @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/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/csrf.py

@@ -0,0 +1,7 @@
+from django.http import JsonResponse
+from django.middleware.csrf import get_token
+
+# New view to return the CSRF token in JSON format
+def csrf_token_view(request):
+    token = get_token(request)
+    return JsonResponse({'csrf_token': token})

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