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

endoreg_db/utils/case_generator/case_generator.py

@@ -1,159 +0,0 @@
-from endoreg_db.models import CaseTemplate, CaseTemplateRule, CaseTemplateRuleType
-from endoreg_db.case_generator.lab_sample_factory import LabSampleFactory
-
-DEFAULT_CASE_TEMPLATE_NAME = "pre_default_screening_colonoscopy"
-
-class CaseGenerator:
-    """
-    Provides methods to generate cases based on a template.
-    """
-
-    def __init__(self, template: CaseTemplate = None):
-        """
-        Initializes the CaseGenerator with a template.
-
-        Args:
-            template (CaseTemplate, optional): The template to use for case generation. Defaults to the predefined template.
-        """
-        self.template = template or CaseTemplate.objects.get(name=DEFAULT_CASE_TEMPLATE_NAME)
-        self.lab_sample_factory = LabSampleFactory()
-
-        # Define available rule types
-        rule_type_names = [
-            "create-object",
-            "set-field-default",
-            "set-field-by-distribution",
-            "set-field-by-value",
-            "set-field-single-choice",
-            "set-field-multiple-choice",
-        ]
-        self.available_rule_types = CaseTemplateRuleType.objects.filter(name__in=rule_type_names)
-
-    def _validate_rule_type(self, rule_type: CaseTemplateRuleType):
-        """
-        Validates if the rule type is supported.
-
-        Args:
-            rule_type (CaseTemplateRuleType): The rule type to validate.
-
-        Raises:
-            ValueError: If the rule type is not supported.
-        """
-        if rule_type not in self.available_rule_types:
-            raise ValueError(f"Rule type {rule_type} is not supported.")
-
-    def _apply_create_object(self, rule: CaseTemplateRule, parent=None):
-        """
-        Applies a create-object rule to generate a model instance.
-
-        Args:
-            rule (CaseTemplateRule): The rule to apply.
-            parent (Optional[Model]): The parent object for the rule.
-
-        Returns:
-            Model: The created model instance.
-        """
-        target_model = rule.get_target_model()
-        extra_params = rule.extra_parameters or {}
-        create_method_info = extra_params.get("create_method", {})
-
-        assert create_method_info, "Create method must be set for a create-object rule."
-
-        create_method = getattr(target_model, create_method_info["name"])
-        kwargs = create_method_info.get("kwargs", {})
-
-        if parent:
-            kwargs[rule.parent_field] = parent
-
-        target_instance = create_method(**kwargs)
-        target_instance.save()
-
-        for action in extra_params.get("actions", []):
-            action_method = getattr(target_instance, action["name"])
-            action_kwargs = action.get("kwargs", {})
-            action_method(**action_kwargs)
-
-        for chained_rule in rule.chained_rules.all():
-            self.apply_rule(chained_rule, parent=target_instance)
-
-        return target_instance
-
-    def _apply_set_field_by_distribution(self, rule: CaseTemplateRule, parent):
-        """
-        Applies a set-field-by-distribution rule.
-
-        Args:
-            rule (CaseTemplateRule): The rule to apply.
-            parent (Model): The parent object for the rule.
-
-        Returns:
-            Model: The updated parent object.
-        """
-        assert parent, "Parent must be provided for set-field-by-distribution rules."
-        assert rule.target_field, "Target field must be specified for the rule."
-
-        distribution = rule.get_distribution()
-        value = distribution.generate_value()
-
-        setattr(parent, rule.target_field, value)
-        parent.save()
-        return parent
-
-    def apply_rule(self, rule: CaseTemplateRule, parent=None):
-        """
-        Applies a rule based on its type to generate a case.
-
-        Args:
-            rule (CaseTemplateRule): The rule to apply.
-            parent (Optional[Model]): The parent object for the rule.
-
-        Returns:
-            Model: The case by applying the rule.
-        """
-        self._validate_rule_type(rule.rule_type)
-
-        if rule.rule_type.name == "create-object":
-            return self._apply_create_object(rule, parent)
-
-        if rule.rule_type.name == "set-field-by-distribution":
-            return self._apply_set_field_by_distribution(rule, parent)
-
-        raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
-
-    def generate_case(self, case_template: CaseTemplate = None):
-        """
-        Generates a case based on the provided or default template.
-
-        Args:
-            case_template (CaseTemplate, optional): The template to use for case generation. Defaults to None.
-
-        Returns:
-            Tuple[Model, Model]: The generated patient and medication schedule.
-        """
-        case_template = case_template or CaseTemplate.objects.get(name=DEFAULT_CASE_TEMPLATE_NAME)
-
-        create_patient_rule = case_template.get_create_patient_rule()
-        patient = self.apply_rule(create_patient_rule)
-
-        medication_schedule_rule = case_template.get_create_patient_medication_schedule_rule()
-        medication_schedule = self.apply_rule(medication_schedule_rule, parent=patient)
-
-        return patient, medication_schedule
-
-        # if not create_new_patient:
-        #     raise NotImplementedError("Only new patients are supported at the moment.")
-        # else:
-        #     # TODO Implement patient rules
-        #     patient_rules = None # all rules of type "create_patient"
-        #     patient = self.generate_patient(patient_rules)
-
-        # # Generate case based on template
-        # rules = self.template.get_rules()
-        # chained_rules = set()
-
-        # for rule in rules:
-        #     rule_chain = rule.get_all_downward_chained_rules()
-        #     chained_rules.add(rule)
-        #     chained_rules.update(rule_chain)
-
-        # return chained_rules

endoreg_db/utils/case_generator/utils.py

@@ -1,30 +0,0 @@
-from endoreg_db.models import CaseTemplate
-from endoreg_db.case_generator.case_generator import CaseGenerator
-
-# TEMPLATE_NAME = "pre_endo-anticoagulation-af-low_risk"
-TEMPLATE_NAME = "pre_default_screening_colonoscopy"
-
-def fetch_template(template_name: str = DEFAULT_TEMPLATE_NAME) -> CaseTemplate:
-    """
-    Fetches a CaseTemplate by name.
-
-    Args:
-        template_name (str): The name of the template to fetch. Defaults to DEFAULT_TEMPLATE_NAME.
-
-    Returns:
-        CaseTemplate: The fetched CaseTemplate instance.
-    """
-    return CaseTemplate.objects.get(name=template_name)
-
-def initialize_case_generator(template_name: str = DEFAULT_TEMPLATE_NAME) -> CaseGenerator:
-    """
-    Initializes a CaseGenerator with the specified template.
-
-    Args:
-        template_name (str): The name of the template to use. Defaults to DEFAULT_TEMPLATE_NAME.
-
-    Returns:
-        CaseGenerator: An instance of CaseGenerator initialized with the template.
-    """
-    template = fetch_template(template_name)
-    return CaseGenerator(template)

endoreg_db/views/pdf/pdf_media.py

@@ -1,239 +0,0 @@
-from django.http import FileResponse, Http404, StreamingHttpResponse
-import mimetypes
-import os
-import logging
-import re
-from ...models import RawPdfFile
-from ...serializers._old.raw_pdf_meta_validation import PDFFileForMetaSerializer, SensitiveMetaUpdateSerializer
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
-from ...models import SensitiveMeta
-from django.views.decorators.clickjacking import xframe_options_sameorigin
-from django.utils.decorators import method_decorator
-from django.db import transaction
-from django.urls import reverse
-from django.utils.encoding import iri_to_uri
-from endoreg_db.utils.paths import PDF_DIR, STORAGE_DIR
-from .pdf_stream_views import ClosingFileWrapper
-
-logger = logging.getLogger(__name__)
-_RANGE_RE = re.compile(r"bytes=(\d+)-(\d*)")
-
-class PDFMediaView(APIView):
-    """
-    Unified API for PDFs to support frontend flows:
-    - Without `id`: returns next PDF metadata (including anonymized_text) and stream URLs
-    - With `id`: streams the PDF (original by default; `?variant=anonymized` for anonymized)
-    - Integrates with Media Management expectations (clean deletion after validation is handled elsewhere)
-    """
-
-    def get(self, request):
-        """
-        Handles both:
-        - Fetching PDF metadata (if `id` is NOT provided)
-        - Streaming the actual PDF file (if `id` is provided)
-        """
-        pdf_id = request.GET.get("id")
-        last_id = request.GET.get("last_id")
-
-        if pdf_id:
-            return self.serve_pdf_file(pdf_id)
-        else:
-            return self.fetch_pdf_metadata(last_id)
-
-    def fetch_pdf_metadata(self, last_id):
-        """
-        Fetches the first or next available PDF metadata and provides stream URLs.
-        """
-        pdf_entry = PDFFileForMetaSerializer.get_next_pdf(last_id)
-        if pdf_entry is None:
-            return Response({"error": "No more PDFs available."}, status=status.HTTP_404_NOT_FOUND)
-
-        serialized_pdf = PDFFileForMetaSerializer(pdf_entry, context={'request': self.request})
-
-        # Build stream URLs pointing to this unified endpoint
-        try:
-            media_url = reverse('pdf_media')
-        except Exception:
-            media_url = "/api/pdf/media/"
-        stream_url = f"{media_url}?id={pdf_entry.id}"
-        anon_stream_url = f"{media_url}?id={pdf_entry.id}&variant=anonymized"
-
-        data = dict(serialized_pdf.data)
-        data.update({
-            'stream_url': iri_to_uri(self.request.build_absolute_uri(stream_url)),
-            'anonymized_stream_url': iri_to_uri(self.request.build_absolute_uri(anon_stream_url)),
-            'pdf_id': pdf_entry.id,
-            'has_anonymized': bool(getattr(pdf_entry, 'anonymized_file', None) and getattr(pdf_entry.anonymized_file, 'name', None)),
-        })
-        return Response(data, status=status.HTTP_200_OK)
-
-    @method_decorator(xframe_options_sameorigin)
-    def serve_pdf_file(self, pdf_id):
-        """
-        Streams the actual PDF file (original or anonymized) with Range support.
-        Query param `variant=anonymized` selects anonymized file; default is original.
-        """
-        variant = (self.request.GET.get('variant') or 'original').lower()
-        range_header = self.request.headers.get("Range")
-
-        try:
-            pdf_entry = RawPdfFile.objects.get(id=pdf_id)
-        except RawPdfFile.DoesNotExist:
-            return Response({"error": "Invalid PDF ID."}, status=status.HTTP_400_BAD_REQUEST)
-
-        # Choose file according to variant
-        file_field = None
-        if variant == 'anonymized' and getattr(pdf_entry, 'anonymized_file', None):
-            file_field = pdf_entry.anonymized_file
-        else:
-            file_field = pdf_entry.file
-
-        if not file_field:
-            return Response({"error": "PDF file not found."}, status=status.HTTP_404_NOT_FOUND)
-
-        # Resolve path and attempt self-heal for originals
-        try:
-            file_path = file_field.path
-        except Exception:
-            file_path = None
-
-        if not file_path or not os.path.exists(file_path):
-            if variant != 'anonymized':
-                # Try to self-heal original reference to sensitive storage
-                sensitive_path = os.path.join(str(PDF_DIR), "sensitive", f"{pdf_entry.pdf_hash}.pdf")
-                if os.path.exists(sensitive_path):
-                    try:
-                        relative_name = os.path.relpath(sensitive_path, str(STORAGE_DIR))
-                        if getattr(pdf_entry.file, 'name', None) != relative_name:
-                            pdf_entry.file.name = relative_name
-                            pdf_entry.save(update_fields=['file'])
-                            logger.info("Self-healed PDF file reference for ID %s -> %s", pdf_entry.id, pdf_entry.file.path)
-                        file_path = sensitive_path
-                    except Exception as e:
-                        logger.error("Failed to self-heal file path for PDF %s: %s", pdf_entry.id, e)
-                        file_path = sensitive_path
-            # If still missing (or anonymized missing), fail
-        if not file_path or not os.path.exists(file_path):
-            raise Http404("PDF file not found on server.")
-
-        # Prepare headers
-        safe_filename = os.path.basename(getattr(file_field, 'name', None) or f"document_{pdf_id}.pdf")
-        if not safe_filename.endswith('.pdf'):
-            safe_filename += '.pdf'
-
-        file_size = os.path.getsize(file_path)
-
-        # Range support
-        if range_header:
-            match = _RANGE_RE.match(range_header)
-            if match:
-                start = int(match.group(1))
-                end = int(match.group(2) or file_size - 1)
-
-                if start < 0 or start >= file_size:
-                    raise Http404("Invalid range")
-                if end >= file_size:
-                    end = file_size - 1
-
-                chunk_size = end - start + 1
-                try:
-                    fh = open(file_path, 'rb')
-                    fh.seek(start)
-                    resp = StreamingHttpResponse(
-                        ClosingFileWrapper(fh, blksize=8192),
-                        status=206,
-                        content_type="application/pdf",
-                    )
-                    resp["Content-Length"] = str(chunk_size)
-                    resp["Content-Range"] = f"bytes {start}-{end}/{file_size}"
-                    resp["Accept-Ranges"] = "bytes"
-                    resp["Content-Disposition"] = f'inline; filename="{safe_filename}"'
-                    return resp
-                except (OSError, IOError) as e:
-                    logger.error(f"Error opening PDF file for range request: {e}")
-                    raise Http404("Error accessing PDF file")
-
-        # Fallback: serve full file
-        mime_type, _ = mimetypes.guess_type(file_path)
-        try:
-            fh = open(file_path, 'rb')
-            response = FileResponse(fh, content_type=mime_type or "application/pdf")
-            response["Content-Length"] = str(file_size)
-            response["Accept-Ranges"] = "bytes"
-            response["Content-Disposition"] = f'inline; filename="{safe_filename}"'
-            return response
-        except (OSError, IOError) as e:
-            logger.error(f"Error opening PDF file: {e}")
-            raise Http404("Error accessing PDF file")
-
-class UpdateSensitiveMetaView(APIView):
-    """
-    API endpoint to update patient details in the SensitiveMeta table.
-    Handles partial updates (only edited fields) and raw file deletion after validation acceptance.
-    """
-
-    @transaction.atomic
-    def patch(self, request, *args, **kwargs):
-        """
-        Updates the provided fields for a specific patient record.
-        Only updates fields that are sent in the request.
-        Automatically deletes raw PDF files when validation is accepted.
-        """
-        sensitive_meta_id = request.data.get("sensitive_meta_id")
-
-        if not sensitive_meta_id:
-            return Response({"error": "sensitive_meta_id is required."}, status=status.HTTP_400_BAD_REQUEST)
-
-        try:
-            sensitive_meta = SensitiveMeta.objects.get(id=sensitive_meta_id)
-        except SensitiveMeta.DoesNotExist:
-            return Response({"error": "Patient record not found."}, status=status.HTTP_404_NOT_FOUND)
-
-        is_accepting_validation = request.data.get("is_verified", False)
-        delete_raw_files = request.data.get("delete_raw_files", False)
-        if is_accepting_validation:
-            delete_raw_files = True
-            logger.info(f"Validation accepted for PDF SensitiveMeta {sensitive_meta_id}, marking raw files for deletion")
-
-        serializer = SensitiveMetaUpdateSerializer(sensitive_meta, data=request.data, partial=True)
-
-        if serializer.is_valid():
-            updated_sm = serializer.save()
-            if delete_raw_files and updated_sm.is_verified:
-                try:
-                    pdf_file = RawPdfFile.objects.filter(sensitive_meta=updated_sm).first()
-                    if pdf_file:
-                        self._schedule_raw_file_deletion(pdf_file)
-                        logger.info(f"Scheduled raw file deletion for PDF {pdf_file.id}")
-                    else:
-                        logger.warning(f"No PDF file found for SensitiveMeta {sensitive_meta_id}")
-                except Exception as e:
-                    logger.error(f"Error scheduling raw file deletion for PDF SensitiveMeta {sensitive_meta_id}: {e}")
-            return Response({"message": "Patient information updated successfully.", "updated_data": serializer.data}, status=status.HTTP_200_OK)
-
-        return Response({"error": "Invalid data.", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
-
-    def _schedule_raw_file_deletion(self, pdf_file):
-        """
-        Schedule deletion of raw PDF file after validation acceptance.
-        Deletes the original (sensitive) file but keeps anonymized_file for frontend.
-        """
-        try:
-            def cleanup_raw_files():
-                try:
-                    if pdf_file.file and getattr(pdf_file.file, 'path', None) and os.path.exists(pdf_file.file.path):
-                        logger.info(f"Deleting original (sensitive) PDF file: {pdf_file.file.path}")
-                        os.remove(pdf_file.file.path)
-                        pdf_file.file = None
-                        pdf_file.save(update_fields=['file'])
-                        logger.info(f"Successfully deleted original file for PDF {pdf_file.id}")
-                    else:
-                        logger.info(f"Original file already deleted or not found for PDF {pdf_file.id}")
-                except Exception as e:
-                    logger.error(f"Error during raw file cleanup for PDF {pdf_file.id}: {e}")
-            transaction.on_commit(cleanup_raw_files)
-        except Exception as e:
-            logger.error(f"Error scheduling raw file deletion for PDF {pdf_file.id}: {e}")
-            raise

endoreg_db/views/report/__init__.py

@@ -1,9 +0,0 @@
-from .report_list import ReportListView
-from .report_with_secure_url import ReportWithSecureUrlView
-from .start_examination import start_examination
-
-__all__ = [
-    "ReportListView",
-    "ReportWithSecureUrlView",
-    "start_examination",
-]

endoreg_db/views/report/report_list.py

@@ -1,112 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.report.report_list import ReportListSerializer
-
-from django.core.paginator import Paginator
-from django.db.models import Q
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-
-import logging
-logger = logging.getLogger(__name__)
-
-class ReportListView(APIView):
-    """
-    API-Endpunkt für paginierte Report-Listen mit optionaler Filterung
-    GET /api/reports/
-    """
-
-    def get(self, request):
-        try:
-            # Query-Parameter abrufen
-            page = int(request.GET.get('page', 1))
-            page_size = min(int(request.GET.get('page_size', 20)), 100)  # Max 100 pro Seite
-
-            # Filter-Parameter
-            file_type_filter = request.GET.get('file_type')
-            patient_name_filter = request.GET.get('patient_name')
-            casenumber_filter = request.GET.get('casenumber')
-            date_from = request.GET.get('date_from')
-            date_to = request.GET.get('date_to')
-
-            # Base QuerySet mit related data
-            queryset = RawPdfFile.objects.select_related('sensitive_meta').all()
-
-            # Filter anwenden
-            if patient_name_filter:
-                queryset = queryset.filter(
-                    Q(sensitive_meta__patient_first_name__icontains=patient_name_filter) |
-                    Q(sensitive_meta__patient_last_name__icontains=patient_name_filter)
-                )
-
-            if casenumber_filter:
-                queryset = queryset.filter(
-                    sensitive_meta__case_number__icontains=casenumber_filter
-                )
-
-            if file_type_filter:
-                # Filter basierend auf Dateiendung
-                queryset = queryset.filter(file__endswith=f'.{file_type_filter}')
-
-            if date_from:
-                queryset = queryset.filter(created_at__gte=date_from)
-
-            if date_to:
-                queryset = queryset.filter(created_at__lte=date_to)
-
-            # Sortierung (neueste zuerst)
-            queryset = queryset.order_by('-created_at')
-
-            # Paginierung
-            paginator = Paginator(queryset, page_size)
-
-            if page > paginator.num_pages:
-                return Response({
-                    'count': paginator.count,
-                    'next': None,
-                    'previous': None,
-                    'results': []
-                })
-
-            page_obj = paginator.get_page(page)
-
-            # Serialisierung
-            serializer = ReportListSerializer(
-                page_obj.object_list,
-                many=True,
-                context={'request': request}
-            )
-
-            # URLs für Paginierung
-            next_url = None
-            previous_url = None
-
-            if page_obj.has_next():
-                next_url = request.build_absolute_uri(
-                    f"?page={page_obj.next_page_number()}&page_size={page_size}"
-                )
-
-            if page_obj.has_previous():
-                previous_url = request.build_absolute_uri(
-                    f"?page={page_obj.previous_page_number()}&page_size={page_size}"
-                )
-
-            return Response({
-                'count': paginator.count,
-                'next': next_url,
-                'previous': previous_url,
-                'results': serializer.data
-            })
-
-        except ValueError as e:
-            logger.error("Ungültige Parameter in ReportListView: %s", str(e))
-            return Response(
-                {"error": "Ungültige Parameter"},
-                status=status.HTTP_400_BAD_REQUEST
-            )
-        except (AttributeError, TypeError, OSError) as e:
-            logger.error("Fehler in ReportListView: %s", str(e))
-            return Response(
-                {"error": "Fehler beim Laden der Reports"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/report/report_with_secure_url.py

@@ -1,28 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.report.report import ReportDataSerializer
-
-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
-
-import logging
-logger = logging.getLogger(__name__)
-
-class ReportWithSecureUrlView(APIView):
-    """
-    API-Endpunkt für Reports mit sicherer URL-Generierung
-    GET /api/reports/{report_id}/with-secure-url/
-    """
-
-    def get(self, request, report_id):
-        try:
-            report = get_object_or_404(RawPdfFile, id=report_id)
-            serializer = ReportDataSerializer(report, context={'request': request})
-            return Response(serializer.data)
-        except (ValueError, TypeError) as e:
-            logger.error("Fehler beim Laden des Reports %s: %s", report_id, str(e))
-            return Response(
-                {"error": "Report konnte nicht geladen werden"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/report/start_examination.py

@@ -1,7 +0,0 @@
-from django.shortcuts import render
-from django.contrib.admin.views.decorators import staff_member_required
-
-@staff_member_required
-def start_examination(request):
-    return render(request, 'admin/start_examination.html')
-