oots-lib 0.1.0__py3-none-any.whl

oots_lib/Transport.py

@@ -0,0 +1,139 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import NoReturn
+
+from XRoad import RedisCache, Transport, XClient
+from XRoad.plugins import UXPHistoryPlugin
+
+from oots_lib.import_env import import_env
+from oots_lib.lib.exception import EDMException, TransportError
+from oots_lib.lib.toLogger import ToLogger
+from oots_lib.lib.UseRedis import get_redis_client
+
+_logger = logging.getLogger(__name__)
+
+TREMBITA_URL = import_env("TREMBITA_URL")
+TREMBITA_CLIENT_ID = import_env("TREMBITA_CLIENT_ID")
+TREMBITA_CACHE = int(import_env("TREMBITA_CACHE"))
+REDIS_URL = import_env("REDIS_URL")
+
+
+class SOAPTransport(ABC):
+    def __init__(self, service: str, conversation_id: str, if_send_error: bool = True):
+        self.service = service
+        self.conversation_id = conversation_id
+        self.if_send_error = if_send_error
+
+        self.to_logger = ToLogger(conversation_id)
+        self.redis = get_redis_client()
+
+        _logger.info(f"Надсилаємо запит до сервісу: {self.service}")
+
+        cache = RedisCache(REDIS_URL, timeout=3600 * 24)
+        transport = Transport(operation_timeout=60 * 5, cache=cache)
+        self.history = UXPHistoryPlugin()
+
+        self.client = None
+        try:
+            self.client = XClient(
+                TREMBITA_URL, client=TREMBITA_CLIENT_ID, service=self.service,
+                transport=transport,
+                plugins=[self.history, ]
+            )
+        except Exception as e:
+            _logger.exception("Помилка створення XClient")
+            self.send_error_message(
+                code="EDM:ERR:0006",  # NOSONAR
+                message="Сталася помилка при створенні з'єднення до Трембіти",
+                detail=f"Сталася помилка при створенні з'єднення до Трембіти: {e}",
+                cause=e,
+            )
+
+        _logger.info(f"XClient успішно створений: {self.client}")
+
+    def send_error_message(
+        self,
+        code: str,
+        message: str,
+        detail: str,
+        cause: BaseException | None = None,
+    ) -> NoReturn:
+        """Сигналізує про помилку транспорту виключенням.
+
+        При `if_send_error` помилка додатково публікується до Redis та черги
+        через :class:`EDMException`, інакше кидається :class:`TransportError`.
+        Метод завжди кидає виключення, щоб помилка не залишалась непоміченою.
+        """
+        _logger.error(f"Помилка: code={code}, message={message}, detail={detail}")
+        if self.if_send_error:
+            raise EDMException(
+                redis=self.redis,
+                queue=None,
+                key=None,
+                message_id=str(self.conversation_id),
+                code=code,
+                message=message,
+                detail=detail,
+            ) from cause
+
+        raise TransportError(f"[{code}] {message}: {detail}") from cause
+
+    @abstractmethod
+    def parsing_response(self, responce: dict) -> list[dict]:
+        ...
+
+    def response(self, request: dict) -> list[dict]:
+
+        _logger.info(f"Запит до сервісу: {self.service}")
+        if self.client is None:
+            self.send_error_message(
+                code="EDM:ERR:0006",
+                message="З'єднання до Трембіти не встановлено",
+                detail=f"XClient для сервісу {self.service} не створений",
+            )
+
+        try:
+            response = self.client.request(**request)
+        except Exception as e:
+            _logger.exception("Помилка виконання запиту до Трембіти")
+            self.send_error_message(
+                code="EDM:ERR:0006",
+                message="Сталася помилка при виконанні запиту до Сервісу даних",
+                detail=f"Сталася помилка при виконанні запиту до Сервісу даних: {e}",
+                cause=e,
+            )
+
+        try:
+            result = response["body"]
+        except (KeyError, IndexError, TypeError) as e:
+            self.send_error_message(
+                code="EDM:ERR:0006",
+                message="Відповідь від Сервісу даних має некоректну структуру",
+                detail=f"Не вдалося отримати body.GetDocumentsByPersonResult: {e}",
+                cause=e,
+            )
+
+        self._logging_trembita_transaction()
+
+        _logger.debug(f"Результат відповіді: {result}")
+        return self.parsing_response(result)
+
+    def _logging_trembita_transaction(self):
+        if self.to_logger is None or self.client is None or self.history is None:
+            _logger.debug("Журналювання транзакції пропущено: відсутні client/history або логер")
+            return
+
+        self.to_logger.append_calls(
+            {
+                "dataservice": self.service,
+                "timestamp": self.history.transaction_date.isoformat(),
+                "trembita_msg_id": self.client.id,
+                "transaction_id": self.history.transaction_id,
+            }
+        )
+
+        _logger.debug(f"Дані журналу транзакції: {self.to_logger.payload}")
+        try:
+            self.to_logger.send_to_logger()
+        except Exception:
+            _logger.exception("Не вдалося надіслати журнал транзакції")

oots_lib/__init__.py

@@ -0,0 +1,77 @@
+"""Public API for the OOTS evidence library."""
+
+from importlib import import_module
+
+__all__ = [
+    "Base",
+    "MainBase",
+    "NS",
+    "SOAPTransport",
+    "EDMException",
+    "BaseEDMException",
+    "AuthenticationException",
+    "AuthorizationException",
+    "InvalidRequestException",
+    "ObjectNotFoundException",
+    "QueryException",
+    "TimeoutException",
+    "UnresolvedReferenceException",
+    "UnsupportedCapabilityException",
+    "MakeEvidence",
+    "UseRedisAsync",
+    "get_redis_client",
+    "initialize_redis",
+    "close_redis",
+    "generate_pdf_from_xslt",
+    "Identifier",
+    "Person",
+    "EDMRequest",
+    "Evidences",
+    "Description",
+    "Classification",
+    "RepositoryItemRef",
+    "ExtrinsicObjectType",
+    "RegistryPackageType",
+]
+
+_LAZY_IMPORTS = {
+    "Base": ("oots_lib.models.Base", "Base"),
+    "MainBase": ("oots_lib.models.Base", "MainBase"),
+    "NS": ("oots_lib.lib.NS", "NS"),
+    "SOAPTransport": ("oots_lib.Transport", "SOAPTransport"),
+    "EDMException": ("oots_lib.lib.exception", "EDMException"),
+    "BaseEDMException": ("oots_lib.lib.exceptions", "EDMException"),
+    "AuthenticationException": ("oots_lib.lib.exceptions", "AuthenticationException"),
+    "AuthorizationException": ("oots_lib.lib.exceptions", "AuthorizationException"),
+    "InvalidRequestException": ("oots_lib.lib.exceptions", "InvalidRequestException"),
+    "ObjectNotFoundException": ("oots_lib.lib.exceptions", "ObjectNotFoundException"),
+    "QueryException": ("oots_lib.lib.exceptions", "QueryException"),
+    "TimeoutException": ("oots_lib.lib.exceptions", "TimeoutException"),
+    "UnresolvedReferenceException": ("oots_lib.lib.exceptions", "UnresolvedReferenceException"),
+    "UnsupportedCapabilityException": ("oots_lib.lib.exceptions", "UnsupportedCapabilityException"),
+    "MakeEvidence": ("oots_lib.lib.MakeEvidence", "MakeEvidence"),
+    "UseRedisAsync": ("oots_lib.lib.UseRedis", "UseRedisAsync"),
+    "get_redis_client": ("oots_lib.lib.UseRedis", "get_redis_client"),
+    "initialize_redis": ("oots_lib.lib.UseRedis", "initialize_redis"),
+    "close_redis": ("oots_lib.lib.UseRedis", "close_redis"),
+    "generate_pdf_from_xslt": ("oots_lib.lib.CreatePDF", "generate_pdf_from_xslt"),
+    "Identifier": ("oots_lib.models.Person", "Identifier"),
+    "Person": ("oots_lib.models.Person", "Person"),
+    "EDMRequest": ("oots_lib.models.RequestEDM", "EDMRequest"),
+    "Evidences": ("oots_lib.models.ResponseEvidences", "Evidences"),
+    "Description": ("oots_lib.models.ResponseEvidences", "Description"),
+    "Classification": ("oots_lib.models.ResponseEvidences", "Classification"),
+    "RepositoryItemRef": ("oots_lib.models.ResponseEvidences", "RepositoryItemRef"),
+    "ExtrinsicObjectType": ("oots_lib.models.ResponseEvidences", "ExtrinsicObjectType"),
+    "RegistryPackageType": ("oots_lib.models.ResponseEvidences", "RegistryPackageType"),
+}
+
+
+def __getattr__(name: str):
+    if name not in _LAZY_IMPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module_name, attr_name = _LAZY_IMPORTS[name]
+    module = import_module(module_name)
+    value = getattr(module, attr_name)
+    globals()[name] = value
+    return value

oots_lib/import_env.py

@@ -0,0 +1,12 @@
+import logging
+import os
+
+_logger = logging.getLogger(__name__)
+
+
+def import_env(key: str, default: str | None = None) -> str:
+    value = os.getenv(key, default)
+    if value is None:
+        _logger.error("Environment variable %s is not set", key)
+        raise ValueError(f"Environment variable {key} is not set")
+    return value

oots_lib/lib/CreatePDF.py

@@ -0,0 +1,83 @@
+import logging
+import pathlib
+import re
+from collections.abc import Iterable
+
+from lxml import etree
+
+from oots_lib.lib.xml_safety import safe_fromstring, safe_parse
+
+try:
+    from weasyprint import CSS, HTML  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - optional dependency
+    CSS = None
+    HTML = None
+
+
+_logger = logging.getLogger(__name__)
+
+path = pathlib.Path(__file__).parent
+XSLT_FILE = path / "rdf-display.xsl"
+BIRTH_CERTIFICATE_XSLT_FILE = path / "annexI_birth.xsl"
+MARRIAGE_CERTIFICATE_XSLT_FILE = path / "annexIV_marriage.xsl"
+DISABILITY_CERTIFICATE_XSLT_FILE = path / "disability.xsl"
+
+
+def generate_pdf_from_xslt(
+    rdf: str | bytes,
+    xslt_file: pathlib.Path | str = XSLT_FILE,
+    css: Iterable[str] | None = None,
+) -> bytes:
+    """
+    Виконує XSLT-трансформацію XML у HTML, а потім перетворює HTML у PDF.
+    """
+    if HTML is None or CSS is None:
+        raise ModuleNotFoundError(
+            "weasyprint is required for PDF generation. "
+            "Install the optional dependency to use generate_pdf_from_xslt()."
+        )
+
+    # Крок 1: Завантаження та виконання XSLT-трансформації
+
+    # Конвертація xslt_file у pathlib.Path якщо потрібно
+    if isinstance(xslt_file, str):
+        xslt_file = pathlib.Path(xslt_file)
+
+    # Завантаження XML-документа
+    if isinstance(rdf, bytes):
+        rdf = rdf.decode("utf-8")
+
+    xml = re.sub(r"<\?xml [^>]*\?>\s*", '', rdf, count=1)
+    xml = xml.strip()
+    xml_tree = safe_fromstring(xml)
+
+    # Завантаження XSLT-таблиці стилів
+    xslt_root = safe_parse(xslt_file)
+    transform = etree.XSLT(
+        xslt_root,
+        access_control=etree.XSLTAccessControl.DENY_ALL,  # type: ignore[attr-defined]
+    )
+
+    # Виконання трансформації: XML -> HTML (як etree.ElementTree)
+    html_tree = transform(xml_tree)
+
+    # Серіалізація HTML у рядок
+    html_content = etree.tostring(
+        html_tree,
+        pretty_print=True,
+        method="html",
+        encoding='utf-8'
+    ).decode('utf-8')
+
+    # Крок 2: Перетворення HTML у PDF за допомогою WeasyPrint
+
+    html_object = HTML(string=html_content)
+
+    stylesheets = [CSS(string='@page { size: A4; margin: 1.5cm; }')]
+    for c in (css or []):
+        stylesheets.append(CSS(string=c))
+
+    # Виклик write_pdf() без аргументу target повертає PDF як bytes.
+    pdf_bytes: bytes = html_object.write_pdf(stylesheets=stylesheets)  # type: ignore[assignment]
+
+    return pdf_bytes

oots_lib/lib/EvidanceMetadata.py

@@ -0,0 +1,92 @@
+import logging
+import uuid
+
+from lxml import etree
+
+from oots_lib.lib.NS import NS
+
+_logger = logging.getLogger(__name__)
+
+__all__ = [
+    "EMetadata",
+    "IssuingAuthority",
+    "IsConformantTo",
+    "Distribution",
+    "IsAbout",
+]
+
+class EMetadata(NS):
+    def __init__(self):
+        super().__init__()
+        self._xml: etree._Element = self._element("sdg", "Evidence")
+        self._subelement(self._xml, "sdg", "Identifier", text=uuid.uuid4())
+
+    def issuingAuthority(self, issuingAuthority: etree._Element):   # NOSONAR
+        self._xml.append(issuingAuthority)
+
+    def isConformeant(self, isConformeant: etree._Element):   # NOSONAR
+        self._xml.append(isConformeant)
+
+    def distribution(self, distribution: etree._Element):
+        self._xml.append(distribution)
+
+    def isAbout(self, isAbout: etree._Element):    # NOSONAR
+        self._xml.append(isAbout)
+
+
+class IssuingAuthority(NS):
+    def __init__(self, shema, value):
+        super().__init__()
+        self._xml: etree._Element = self._element("sdg", "IssuingAuthority")
+        self._subelement(
+            self._xml, "sdg", "Identifier", text=value, attrib={"schemeID": shema}
+        )
+
+    def name(self, lang: str, name: str):
+        self._subelement(
+            self._xml, "sdg", "Name", text=name, attrib={"lang": f"{lang}".upper()}
+        )
+        return self
+
+
+class Distribution(NS):
+    def __init__(self, content_type):
+        super().__init__()
+        self._xml: etree._Element = self._element("sdg", "Distribution")
+        self._subelement(self._xml, "sdg", "Format", text=content_type)
+
+    def ConformsTo(self, url):
+        self._subelement(self._xml, "sdg", "ConformsTo", text=url)
+
+    def Transformation(self, url):
+        self._subelement(self._xml, "sdg", "Transformation", text=url)
+
+
+class IsConformantTo(NS):
+    def __init__(self, conformance):
+        super().__init__()
+        self._xml: etree._Element = self._element("sdg", "IsConformantTo")
+        self._subelement(
+            self._xml, "sdg", "EvidenceTypeClassification", text=conformance
+        )
+
+    def title(self, lang, title):
+        self._subelement(
+            self._xml, "sdg", "Title", text=title, attrib={"lang": lang.upper()}
+        )
+
+    def description(self, lang, description):
+        self._subelement(
+            self._xml,
+            "sdg",
+            "Description",
+            text=description,
+            attrib={"lang": lang.upper()},
+        )
+
+
+class IsAbout(NS):
+    def __init__(self, person: etree._Element):
+        super().__init__()
+        self._xml: etree._Element = self._element("sdg", "IsAbout")
+        self._xml.append(person)

oots_lib/lib/MakeEvidence.py

@@ -0,0 +1,282 @@
+import base64
+import logging
+from dataclasses import is_dataclass
+
+from pyRegRep4 import deep_get
+from pyRegRep4.RIMParsing import Parsing
+
+from oots_lib.import_env import import_env
+from oots_lib.lib.EvidanceMetadata import (
+    Distribution,
+    EMetadata,
+    IsAbout,
+    IsConformantTo,
+    IssuingAuthority,
+)
+from oots_lib.lib.exception import EDMException
+from oots_lib.lib.toLogger import ToLogger
+from oots_lib.lib.UseRedis import UseRedisAsync as Redis
+from oots_lib.models.Base import MainBase
+from oots_lib.models.Person import Person, get_person_from_redis
+from oots_lib.models.RequestEDM import get_edm_request_from_redis
+from oots_lib.models.ResponseEvidences import (
+    Classification,
+    Evidences,
+    ExtrinsicObjectType,
+    RegistryPackageType,
+    RepositoryItemRef,
+    save_evidences_to_redis,
+)
+from oots_lib.redis_keys import Keys
+
+_logger = logging.getLogger(__name__)
+
+KEYS = Keys()
+QUEUE_OUTCOMING = import_env("QUEUE_OUTCOMING")
+IF_PREVIEW: bool = import_env("IF_PREVIEW").lower() == 'true'
+
+
+class MakeEvidence:
+    ISSUING_AUTHORITY_ID = ""
+    ISSUING_AUTHORITY_SCHEME = ""
+    ISSUING_AUTHORITY_NAME = ""
+    CONFORMANT_TO_URL = ''
+
+    def __init__(self, message_id: str, redis: Redis):
+        super().__init__()
+
+        self.message_id = message_id
+        self.redis = redis
+
+        self.person: Person | None = None
+        self.request: Parsing | None = None
+        self.as4: dict | None | None = None
+
+        self.log: ToLogger | None | None = None
+        self.evidence: Evidences | None = None
+        self._request_content_type: str | None = None
+
+        self.request_to_service: dict | None = None
+
+        self.response_from_service = None
+        self.data: MainBase | None = None
+        self.title = ""
+        self.description: list[str] = []
+
+    def _edm_exception(self, code: str, message: str, detail: str) -> EDMException:
+        """Створює EDMException з контекстом цього повідомлення."""
+        return EDMException(
+            redis=self.redis,
+            queue=None,
+            key=None,
+            message_id=str(self.message_id),
+            code=code,
+            message=message,
+            detail=detail,
+        )
+
+    @property
+    def if_preview(self):
+        _logger.debug(f"Перевірка прапора preview для повідомлення {self.message_id}")
+
+        if self.request is None:
+            raise ValueError(
+                f"Запит для повідомлення {self.message_id} не зчитаний: спершу викличте read_data()"
+            )
+
+        request: dict = self.request.serialize()
+        preview: bool = deep_get(request, 'doc', 'PossibilityForPreview', default=False)
+
+        _logger.debug(f"Значення прапора preview у запиті: {preview}")
+        _logger.debug(f"Прапор preview встановлено, використовуємо глобальне налаштування IF_PREVIEW: {IF_PREVIEW}")
+
+        pr = False if not preview and not IF_PREVIEW else True
+
+        _logger.debug(f"Результат перевірки прапора preview для повідомлення {self.message_id}: {pr}")
+        return pr
+
+    async def read_data(self):
+        """Зчитує вхідні дані повідомлення з Redis.
+
+        Raises:
+            EDMException: Якщо запит EDM або дані особи відсутні у Redis
+        """
+        request_key = KEYS.get_request_edm(self.message_id)
+        request = await get_edm_request_from_redis(self.redis, request_key)
+        if request is None:
+            raise self._not_found(
+                message="Запит EDM не знайдено",
+                detail=f"У Redis відсутній запит EDM за ключем {request_key}",
+            )
+        self.request = Parsing(request.content)
+
+        person_key = KEYS.get_request_person(self.message_id)
+        self.person = await get_person_from_redis(self.redis, person_key)
+        if self.person is None:
+            raise self._not_found(
+                message="Інформацію про людину не знайдено",
+                detail=f"У Redis відсутні дані особи за ключем {person_key}",
+            )
+
+        self.as4 = await self.redis.get_from_redis(KEYS.get_request_as4(self.message_id))
+
+    def _not_found(self, message: str, detail: str) -> EDMException:
+        return self._edm_exception(
+            code="EDM:ERR:0004", message=message, detail=detail
+        )
+
+    async def load_data_to_redis(self):
+        """
+        Зберігає сформовані докази до Redis у форматі Evidences.
+
+        Після збереження перевіряє preview-прапор через get_flag()
+        і за потреби відправляє повідомлення на обробку.
+        """
+        _logger.info(f"Збереження набору доказів для повідомлення {self.message_id}")
+
+        if is_dataclass(self.evidence):
+            await save_evidences_to_redis(self.redis, KEYS.get_response_evidence(self.message_id), self.evidence)
+        else:
+            raise TypeError(f"Очікувався Evidences, отримано {type(self.evidence)}")
+
+        # Перевіряємо, чи потрібно відправляти на обробку
+        if not self.if_preview:
+            _logger.info(f"Відправляємо повідомлення {self.message_id} до черги обробки")
+            await self.redis.push_to_queue(QUEUE_OUTCOMING, f"{self.message_id}")
+        else:
+            _logger.debug(f"Повідомлення {self.message_id} потребує preview, обробка відкладена")
+
+    def generate_metadata(self, main_evidence: bool = True):
+        if self.person is None:
+            raise ValueError(
+                f"Дані особи для повідомлення {self.message_id} не зчитані: спершу викличте read_data()"
+            )
+        person_tree = self.person.xml_tree
+        if person_tree is None:
+            raise ValueError(
+                f"XML особи для повідомлення {self.message_id} не сформовано"
+            )
+
+        distribution = Distribution(self.request_content_type)
+        conformantTo = IsConformantTo(self.CONFORMANT_TO_URL)     # NOSONAR
+        usingAuthority = IssuingAuthority(self.ISSUING_AUTHORITY_SCHEME, self.ISSUING_AUTHORITY_ID)     # NOSONAR
+        usingAuthority.name(lang='UA', name=self.ISSUING_AUTHORITY_NAME)
+        about = IsAbout(person_tree)
+
+        metadata = EMetadata()
+
+        if main_evidence:
+            about_tree = about.xml_tree
+            conformant_tree = conformantTo.xml_tree
+            distribution_tree = distribution.xml_tree
+            authority_tree = usingAuthority.xml_tree
+            assert about_tree is not None
+            assert conformant_tree is not None
+            assert distribution_tree is not None
+            assert authority_tree is not None
+            metadata.isAbout(about_tree)
+            metadata.isConformeant(conformant_tree)
+            metadata.distribution(distribution_tree)
+            metadata.issuingAuthority(authority_tree)
+        else:
+            ...
+
+        return metadata.xml_string
+
+    @property
+    def request_content_type(self):
+        if self.request is None:
+            raise ValueError("Запит не ініціалізовано")
+        if self._request_content_type is None:
+            self._request_content_type = deep_get(
+                self.request.serialize(any_type=True),
+                'query',
+                'EvidenceRequest',
+                'sdg:DataServiceEvidenceType',
+                'sdg:DistributedAs',
+                'sdg:Format'
+            )
+        return self._request_content_type
+
+    async def transform_data(self):
+
+        if self.data is None:
+            raise ValueError(
+                f"Джерело даних для повідомлення {self.message_id} не встановлено: "
+                "задайте self.data перед transform_data()"
+            )
+
+        try:
+            documents = await self.data.generate_data()
+        except Exception as e:
+            raise self._not_found(
+                message="Інформацію про людину не знайдено",
+                detail=str(e),
+            ) from e
+
+        content_type = self.request_content_type
+        _logger.info(f"Тип контенту: {content_type}")
+
+        if not content_type:
+            _logger.error("Тип контенту у запиті не вказаний")
+            raise self._edm_exception(
+                code="EDM:ERR:0003",
+                message="Тип контенту у запиті не вказаний",
+                detail="У запиті відсутній sdg:DistributedAs/sdg:Format",
+            )
+
+        evidences = []
+
+        for doc in documents:
+
+            contents = []
+            extrinsic = ExtrinsicObjectType(
+                classification=Classification(classificationNode='MainEvidence'),
+                EvidenceMetadata=self.generate_metadata(main_evidence=True),
+                RepositoryItemRef=RepositoryItemRef(title="Cerificate of Marriage"),
+            )
+
+            if 'pdf' in content_type:
+                _logger.debug("Перетворення документу у PDF")
+                pdf = doc.get_pdf()
+                extrinsic.content_type = "application/pdf"
+                extrinsic.encoding = 'base64'
+                extrinsic.content = base64.b64encode(pdf).decode("utf-8")
+                contents.append(extrinsic)
+
+            elif 'xml' in content_type:
+                _logger.debug("Перетворення документу у XML")
+                extrinsic.content_type = "application/xml"
+                extrinsic.content = doc.get_xml()
+                contents.append(extrinsic)
+
+            elif 'json' in content_type:
+                _logger.debug("Перетворення документу у JSON")
+                extrinsic.content_type = "application/json"
+                extrinsic.content = doc.get_json()
+                contents.append(extrinsic)
+
+            else:
+                _logger.error(f"Невідомий тип контенту: {content_type}")
+                raise self._edm_exception(
+                    code="EDM:ERR:0006",
+                    message="Невідомий тип контенту",
+                    detail=f"Невідомий тип контенту: {content_type}",
+                )
+            _logger.debug(f"Створено ExtrinsicObjectType: {extrinsic}")
+            # додати інші представлення до contents
+            ...
+            _logger.debug('Додали всі представлення доказу')
+
+            _logger.debug(f"Створюємо RegistryPackageType для документа: {doc}")
+            evidences.append(RegistryPackageType(RegistryPackage=contents))
+
+        _logger.debug(f"Створено всі RegistryPackageType для документів, кількість: {len(evidences)}")
+        evidence = Evidences(
+            title=self.title,
+            PreviewDescription=self.description,
+            preview=self.if_preview,
+            evidences=evidences,
+        )
+        _logger.debug(f'Створили Evidence: {evidence}')
+        self.evidence = evidence