endoreg-db 0.8.6.1__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/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')
-