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

endoreg_db/serializers/report/mixins.py

@@ -1,45 +0,0 @@
-from pathlib import Path
-from typing import TYPE_CHECKING, Literal
-from django.utils import timezone
-
-if TYPE_CHECKING:
-    from endoreg_db.models import RawPdfFile
-
-class ReportStatusMixin:
-    """
-    Mixin class for report serializers to provide status, updated_at, and file_type fields.
-    """
-
-    def get_status(self, obj:"RawPdfFile") -> Literal['approved'] | Literal['pending']:
-        """
-        Return the report status as 'approved' if the report has been processed, otherwise 'pending'.
-        
-        Parameters:
-            obj (RawPdfFile): The report file instance to check.
-        
-        Returns:
-            Literal['approved'] | Literal['pending']: The status of the report based on its processing state.
-        """
-        if obj.state_report_processed:
-            return 'approved'
-        if obj.state_report_processing_required:
-            return 'pending'
-        return 'pending'
-
-    def get_updated_at(self, obj:"RawPdfFile") -> "timezone.datetime":
-        """
-        Return the last update time for the given RawPdfFile object.
-        
-        If the object's creation date is available, it is returned; otherwise, the current time is used.
-        """
-        return obj.date_created if obj.date_created else timezone.now()
-
-    def get_file_type(self, obj:"RawPdfFile"    ) -> "str":
-        """
-        Return the file type of the associated file as a lowercase string without the leading dot.
-        
-        If the object has no file, returns 'unknown'.
-        """
-        if obj.file:
-            return Path(obj.file.name).suffix.lower().lstrip('.')
-        return 'unknown'

endoreg_db/serializers/report/report.py

@@ -1,105 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.meta.report_meta import ReportMetaSerializer
-from endoreg_db.serializers.report.secure_file_url import SecureFileUrlSerializer
-from endoreg_db.serializers.report.mixins import ReportStatusMixin
-
-from django.utils import timezone
-from rest_framework import serializers
-
-
-import uuid
-from datetime import timedelta
-from pathlib import Path
-
-
-class ReportDataSerializer(ReportStatusMixin, serializers.ModelSerializer):
-    """
-    Hauptserializer für Report-Daten mit sicherer URL
-    """
-    report_meta = ReportMetaSerializer(source='sensitive_meta', read_only=True)
-    secure_file_url = SecureFileUrlSerializer(read_only=True)
-    file_type = serializers.SerializerMethodField()
-
-    # Status und updated_at hinzufügen (da sie im RawPdfFile Model fehlen)
-    status = serializers.SerializerMethodField()
-    updated_at = serializers.SerializerMethodField()
-
-    class Meta:
-        model = RawPdfFile
-        fields = [
-            'id', 'anonymized_text', 'status', 'report_meta',
-            'secure_file_url', 'file_type', 'created_at', 'updated_at'
-        ]
-
-    def get_updated_at(self, obj):
-        """
-        Return the updated timestamp for the object, using `created_at` if available or the current time otherwise.
-        """
-        return obj.created_at if obj.created_at else timezone.now()
-
-    def get_file_type(self, obj):
-        """
-        Return the file extension of the associated file in lowercase, or 'unknown' if no file is present.
-        
-        Parameters:
-            obj: The object instance containing the file.
-        
-        Returns:
-            str: The file extension without the leading dot, or 'unknown' if the file is missing.
-        """
-        if obj.file:
-            return Path(obj.file.name).suffix.lower().lstrip('.')
-        return 'unknown'
-
-    def to_representation(self, instance):
-        """
-        Returns the serialized representation of the instance, including a secure file URL if a file exists and a request context is available.
-        """
-        data = super().to_representation(instance)
-
-        # Sichere URL generieren wenn file vorhanden
-        if instance.file and hasattr(instance.file, 'url'):
-            request = self.context.get('request')
-            if request:
-                # Sichere URL mit Token generieren
-                secure_url_data = self._generate_secure_url(instance, request)
-                data['secure_file_url'] = secure_url_data
-
-        return data
-
-    def _generate_secure_url(self, instance, request):
-        """
-        Generate a secure URL for downloading the file associated with the given instance, including an expiration time and file metadata.
-        
-        Parameters:
-            instance: The model instance containing the file.
-            request: The HTTP request object used to build the absolute URL.
-        
-        Returns:
-            dict: A dictionary containing the secure URL, expiration timestamp, file type, original filename, and file size in bytes.
-        """
-        # Token für sichere URL generieren
-        token = str(uuid.uuid4())
-        expires_at = timezone.now() + timedelta(hours=2)  # 2 Stunden gültig
-
-        # URL zusammenbauen
-        secure_url = request.build_absolute_uri(
-            f"/api/reports/{instance.id}/secure-file/?token={token}"
-        )
-
-        # Dateigröße ermitteln
-        file_size = 0
-        try:
-            if instance.file:
-                file_size = instance.file.size
-        except OSError:
-            # Datei nicht verfügbar oder Berechtigung fehlt
-            file_size = 0
-
-        return {
-            'url': secure_url,
-            'expires_at': expires_at,
-            'file_type': self.get_file_type(instance),
-            'original_filename': Path(instance.file.name).name if instance.file else 'unknown',
-            'file_size': file_size
-        }

endoreg_db/serializers/report/report_list.py

@@ -1,22 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.meta import ReportMetaSerializer
-from endoreg_db.serializers.report.mixins import ReportStatusMixin
-
-from django.utils import timezone
-from rest_framework import serializers
-
-
-from pathlib import Path
-
-
-class ReportListSerializer(ReportStatusMixin, serializers.ModelSerializer):
-    """
-    Vereinfachter Serializer für Report-Listen
-    """
-    report_meta = ReportMetaSerializer(source='sensitive_meta', read_only=True)
-    file_type = serializers.SerializerMethodField()
-    updated_at = serializers.SerializerMethodField()
-
-    class Meta:
-        model = RawPdfFile
-        fields = ['id', 'status', 'report_meta', 'file_type', 'created_at', 'updated_at']

endoreg_db/serializers/report/secure_file_url.py

@@ -1,26 +0,0 @@
-from rest_framework import serializers
-
-
-class SecureFileUrlSerializer(serializers.Serializer):
-    """
-    Serializer für sichere File-URLs mit Ablaufzeit
-    """
-    url = serializers.URLField()
-    expires_at = serializers.DateTimeField()
-    file_type = serializers.CharField(max_length=20)
-    original_filename = serializers.CharField(max_length=255)
-    file_size = serializers.IntegerField()
-
-    def create(self, validated_data):
-        # Nicht implementiert, da nur für Ausgabe verwendet
-        """
-        Raises NotImplementedError to indicate that instance creation is not supported for this serializer.
-        """
-        raise NotImplementedError("SecureFileUrlSerializer ist nur für Ausgabe gedacht")
-
-    def update(self, instance, validated_data):
-        # Nicht implementiert, da nur für Ausgabe verwendet  
-        """
-        Raises NotImplementedError to indicate that updating is not supported, as this serializer is intended for output only.
-        """
-        raise NotImplementedError("SecureFileUrlSerializer ist nur für Ausgabe gedacht")

endoreg_db/services/requirements_object.py

@@ -1,147 +0,0 @@
-from ast import List
-import pickle
-from endoreg_db.models import Requirement, Examination, PatientExamination
-from endoreg_db.serializers import PatientExaminationSerializer, ExaminationSerializer, FindingClassificationSerializer, RequirementSerializer
-
-
-class LookupService:
-    def __init__(self, db_session):
-        self.db_session = db_session
-        self.hexdict = int()
-
-    def hash_lookup(self, key, value):
-        """
-        Store a key-value pair in the lookup dictionary.
-        """
-        lookup_dict = pickle.loads(bytes.fromhex(self.hexdict))
-        lookup_dict[key] = value
-        self.hexdict = pickle.dumps(dict).hex()
-        return True
-    def hash_retrieve(self, key):
-        """
-        Retrieve a value by key from the lookup dictionary.
-        """
-        lookup_dict = pickle.loads(bytes.fromhex(self.hexdict))
-        return lookup_dict.get(key, None)
-    
-    def hash_add_key_value(self, key, value):
-        """
-        Add a key-value pair to the lookup dictionary.
-        """
-        lookup_dict = pickle.loads(bytes.fromhex(self.hexdict))
-        lookup_dict[key] = value
-        self.hexdict = pickle.dumps(lookup_dict).hex()
-        return True
-    
-    def hash_dehash(self):
-        """
-        Retrieve the entire lookup dictionary.
-        """
-        lookup_dict = pickle.loads(bytes.fromhex(self.hexdict))
-        return lookup_dict
-    
-    def fetch_examination_dict(self, patient_id, tags: List[str] = None):
-        """
-        Fetch examinations for a given patient ID, optionally filtered by tags.
-        """
-        query = self.db_session.query(Examination).filter(Examination.patient_id == patient_id)
-        if tags:
-            query = query.filter(Examination.tags.any(Examination.tags.in_(tags)))
-        examinations = query.all()
-        return [ExaminationSerializer(exam).data for exam in examinations]  
-    
-    def fetch_patient_examination_by_id(self, patient_id, examination_id):
-        """
-        Fetch a patient examination object from the database by its ID.
-        """
-        return self.db_session.query(PatientExamination).filter(PatientExamination.id == patient_examination_id).first()
-    
-    def fetch_patient_examinations(self, patient_id):
-        """
-        Fetch all patient examinations for a given patient ID.
-        """
-        examinations = self.db_session.query(PatientExamination).filter(PatientExamination.patient_id == patient_id).all()
-        return [PatientExaminationSerializer(exam).data for exam in examinations]
-
-    def fetch_findings_by_patient_examination(self, patient_examination_id):
-        """
-        Fetch findings associated with a given patient examination ID.
-        """
-        patient_examination = self.db_session.query(PatientExamination).filter(PatientExamination.id == patient_examination_id).first()
-        if not patient_examination:
-            return []
-        return [finding.serialize() for finding in patient_examination.findings]
-    
-    def fetch_classifications_by_finding(self, finding_id):
-        """
-        Fetch classifications associated with a given finding ID.
-        """
-        finding = self.db_session.query(Finding).filter(Finding.id == finding_id).first()
-        if not finding:
-            return []
-        return [classification.serialize() for classification in finding.classifications]
-    
-    def fetch_default_finding_classification(self):
-        """
-        Fetch the default finding classification from the database.
-        """
-        return self.db_session.query(FindingClassification).filter(FindingClassification.is_default == True).first()
-    
-    def fetch_finding_classification_choice_by_requirement(self, requirement_id):
-        """
-        Retrieve finding classification choices based on the provided requirement ID.
-        """
-        requirement = self.get_requirement_by_id(requirement_id)
-        if not requirement:
-            return []
-        return [choice.serialize() for choice in requirement.finding_classification_choices]
-    
-    def fetch_requirement_choices_by_requirement(self, requirement_id):
-        """
-        Retrieve requirement choices based on the provided requirement ID.
-        """
-        requirement = self.get_requirement_by_id(requirement_id)
-        if not requirement:
-            return []
-        return [choice.serialize() for choice in requirement.requirement_choices]
-    
-    def available_finding_classification_choices_by_finding_classification(self, finding_classification):
-        """
-        Retrieve available finding classification choices based on the provided finding classification.
-        """
-        return self.db_session.query(FindingClassificationChoice).filter(
-            FindingClassificationChoice.finding_classification_id == finding_classification.id
-        ).all()
-
-    def get_requirement_by_id(self, requirement_id):
-        """
-        Fetch a requirement object from the database by its ID.
-        """
-        return self.db_session.query(Requirement).filter(Requirement.id == requirement_id).first()
-
-    def get_all_requirements_for_requirement_sets(self, requirement_set_ids: List[int]):
-        """
-        Fetch all requirements associated with the given requirement set IDs.
-        """
-        return self.db_session.query(Requirement).filter(Requirement.requirement_set_id.in_(requirement_set_ids)).all()
-    
-    def get_all_requirement_sets_for_examination(self, examination_id):
-        """
-        Fetch all requirement sets associated with the given examination ID.
-        """
-        examination = self.db_session.query(Examination).filter(Examination.id == examination_id).first()
-        if not examination:
-            return []
-        return [req_set.serialize() for req_set in examination.requirement_sets]
-
-    def serialize_requirement(self, requirement):
-        """
-        Serialize a requirement object to a byte stream.
-        """
-        return pickle.dumps(requirement)
-
-    def deserialize_requirement(self, serialized_requirement):
-        """
-        Deserialize a byte stream back to a requirement object.
-        """
-        return pickle.loads(serialized_requirement)