elody 0.0.62__py3-none-any.whl → 0.0.162__py3-none-any.whl

elody/client.py

@@ -5,7 +5,9 @@ from .exceptions import NonUniqueException, NotFoundException
 
 
 class Client:
-    def __init__(self, elody_collection_url=None, static_jwt=None, extra_headers=None):
+    def __init__(
+        self, elody_collection_url=None, static_jwt=None, extra_headers=None, proxy=None
+    ):
         self.elody_collection_url = elody_collection_url or os.environ.get(
             "ELODY_COLLECTION_URL", None
         )
@@ -13,19 +15,30 @@ class Client:
         self.headers = {"Authorization": f"Bearer {self.static_jwt}"}
         if extra_headers:
             self.headers = {**self.headers, **extra_headers}
+        self.proxies = None
+        if proxy:
+            self.proxies = {
+                "https": proxy,
+                "http": proxy,
+            }
 
     def __create_mediafile(self, entity_id, mediafile):
         url = f"{self.elody_collection_url}/entities/{entity_id}/mediafiles"
         headers = {**self.headers, **{"Accept": "text/uri-list"}}
-        response = requests.post(url, json=mediafile, headers=headers)
+        response = requests.post(
+            url, json=mediafile, headers=headers, proxies=self.proxies
+        )
         return self.__handle_response(response, "Failed to create mediafile", "text")
 
-    def create_mediafile_with_filename(self, filename):
-        data = {"filename": filename}
+    def create_mediafile_with_filename(self, filename, institution_id=None):
+        data = {"filename": filename, "type": "mediafile"}
+        if institution_id:
+            data.update({"metadata": [{"key": "institution", "value": institution_id}]})
         req = requests.post(
             f"{self.elody_collection_url}/mediafiles",
             json=data,
             headers=self.headers,
+            proxies=self.proxies,
         )
         if req.status_code != 201:
             raise Exception(req.text.strip())
@@ -36,16 +49,24 @@ class Client:
             f"{self.elody_collection_url}/tickets",
             json={"filename": mediafile_name},
             headers=self.headers,
+            proxies=self.proxies,
         )
         if req.status_code != 201:
             raise Exception(req.text.strip())
         return req.text.strip().replace('"', "")
 
     def __get_upload_location(
-        self, entity_id, filename, is_public=True, identifiers=None
+        self,
+        entity_id,
+        filename,
+        is_public=True,
+        identifiers=None,
+        mediafile_object=None,
     ):
         if not identifiers:
             identifiers = list()
+        if not mediafile_object:
+            mediafile_object = dict()
         metadata = []
         if is_public:
             metadata = [
@@ -55,9 +76,12 @@ class Client:
                 }
             ]
         mediafile = {
-            "filename": filename,
-            "metadata": metadata,
-            "identifiers": identifiers,
+            **{
+                "filename": filename,
+                "metadata": metadata,
+                "identifiers": identifiers,
+            },
+            **mediafile_object,
         }
         return self.__create_mediafile(entity_id, mediafile)
 
@@ -78,38 +102,48 @@ class Client:
 
     def add_entity_mediafiles(self, identifier, payload):
         url = f"{self.elody_collection_url}/entities/{identifier}/mediafiles"
-        response = requests.post(url, json=payload, headers=self.headers)
+        response = requests.post(
+            url, json=payload, headers=self.headers, proxies=self.proxies
+        )
         return self.__handle_response(response, "Failed to add mediafiles")
 
-    def add_object(self, collection, payload):
+    def add_object(self, collection, payload, params=None):
         url = f"{self.elody_collection_url}/{collection}"
-        response = requests.post(url, json=payload, headers=self.headers)
+        response = requests.post(
+            url, json=payload, headers=self.headers, params=params, proxies=self.proxies
+        )
         return self.__handle_response(response, "Failed to add object")
 
     def add_object_metadata(self, collection, identifier, payload):
         if collection == "entities":
             url = f"{self.elody_collection_url}/{collection}/{identifier}/metadata"
             payload = payload if isinstance(payload, list) else [payload]
-            response = requests.patch(url, json=payload, headers=self.headers)
+            response = requests.patch(
+                url, json=payload, headers=self.headers, proxies=self.proxies
+            )
             if response.status_code == 400 and response.json()["message"].endswith(
                 "has no metadata"
             ):
-                response = requests.post(url, json=payload, headers=self.headers)
+                response = requests.post(
+                    url, json=payload, headers=self.headers, proxies=self.proxies
+                )
             return self.__handle_response(response, "Failed to add metadata")
         else:
             url = f"{self.elody_collection_url}/{collection}/{identifier}"
             payload = {"metadata": payload if isinstance(payload, list) else [payload]}
-            response = requests.patch(url, json=payload, headers=self.headers)
+            response = requests.patch(
+                url, json=payload, headers=self.headers, proxies=self.proxies
+            )
             return self.__handle_response(response, "Failed to add metadata")
 
     def delete_object(self, collection, identifier):
         url = f"{self.elody_collection_url}/{collection}/{identifier}"
-        response = requests.delete(url, headers=self.headers)
+        response = requests.delete(url, headers=self.headers, proxies=self.proxies)
         return self.__handle_response(response, "Failed to delete object", "text")
 
     def get_all_objects(self, collection):
         url = f"{self.elody_collection_url}/{collection}"
-        response = requests.get(url, headers=self.headers)
+        response = requests.get(url, headers=self.headers, proxies=self.proxies)
         return self.__handle_response(response, "Failed to get objects")
 
     def get_mediafiles_and_check_existence(self, mediafile_ids):
@@ -121,17 +155,26 @@ class Client:
 
     def get_object(self, collection, identifier):
         url = f"{self.elody_collection_url}/{collection}/{identifier}"
-        response = requests.get(url, headers=self.headers)
+        response = requests.get(url, headers=self.headers, proxies=self.proxies)
         return self.__handle_response(response, "Failed to get object")
 
-    def update_object(self, collection, identifier, payload):
+    def update_object(self, collection, identifier, payload, overwrite=True):
         url = f"{self.elody_collection_url}/{collection}/{identifier}"
-        response = requests.put(url, json=payload, headers=self.headers)
+        if overwrite:
+            response = requests.put(
+                url, json=payload, headers=self.headers, proxies=self.proxies
+            )
+        else:
+            response = requests.patch(
+                url, json=payload, headers=self.headers, proxies=self.proxies
+            )
         return self.__handle_response(response, "Failed to update object")
 
     def update_object_relations(self, collection, identifier, payload):
         url = f"{self.elody_collection_url}/{collection}/{identifier}/relations"
-        response = requests.patch(url, json=payload, headers=self.headers)
+        response = requests.patch(
+            url, json=payload, headers=self.headers, proxies=self.proxies
+        )
         return self.__handle_response(response, "Failed to update object relations")
 
     def upload_file_from_url(
@@ -141,19 +184,23 @@ class Client:
         file_url,
         identifiers=None,
         upload_location_replace_map=None,
+        mediafile_object=None,
     ):
         if not identifiers:
             identifiers = list()
         if not upload_location_replace_map:
             upload_location_replace_map = dict()
         upload_location = self.__get_upload_location(
-            entity_id, filename, True, identifiers
+            entity_id, filename, True, identifiers, mediafile_object
         )
         for current_location, new_location in upload_location_replace_map.items():
             upload_location = upload_location.replace(current_location, new_location)
         print(upload_location)
-        mediafile = requests.get(file_url).content
+        mediafile = requests.get(file_url, proxies=self.proxies).content
         response = requests.post(
-            upload_location, files={"file": mediafile}, headers=self.headers
+            upload_location,
+            files={"file": mediafile},
+            headers=self.headers,
+            proxies=self.proxies,
         )
         return self.__handle_response(response, "Failed to upload mediafile")

elody/csv.py

@@ -6,13 +6,14 @@ from elody.exceptions import (
     ColumnNotFoundException,
     IncorrectTypeException,
     InvalidObjectException,
+    InvalidValueException,
 )
 from elody.validator import validate_json
 from elody.schemas import entity_schema, mediafile_schema
 
 
 class CSVParser:
-    top_level_fields = ["type", "filename"]
+    top_level_fields = ["type", "filename", "file_identifier"]
     identifier_fields = ["identifiers", "identifier", "object_id", "entity_id"]
     schema_mapping = {
         "entity": entity_schema,
@@ -21,9 +22,12 @@ class CSVParser:
         "mediafiles": mediafile_schema,
     }
 
-    def __init__(self, csvstring):
-        self.csvstring = csvstring
-        self.reader = csv.DictReader(self.__csv_string_to_file_object())
+    def __init__(self, csvstring=None, csvfile=None):
+        if csvstring:
+            self.csvstring = csvstring
+            self.reader = self.__get_reader_from_csv(self.__csv_string_to_file_object())
+        elif csvfile:
+            self.reader = self.__get_reader_from_csv(csvfile)
 
     def _get_metadata_object(self, key, value, lang="en"):
         return {
@@ -46,6 +50,11 @@ class CSVParser:
     def __csv_string_to_file_object(self):
         return StringIO(self.csvstring)
 
+    def __get_reader_from_csv(self, csv_file):
+        csv_dialect = csv.Sniffer().sniff(csv_file.read())
+        csv_file.seek(0)
+        return csv.DictReader(csv_file, dialect=csv_dialect)
+
 
 class CSVSingleObject(CSVParser):
     def __init__(self, csvstring, object_type="entity"):
@@ -117,18 +126,33 @@ class CSVMultiObject(CSVParser):
         index_mapping=None,
         object_field_mapping=None,
         required_metadata_values=None,
+        metadata_field_mapping=None,
+        include_indexed_field=False,
+        top_level_fields_mapping=None,
+        external_file_sources=None,
     ):
         super().__init__(csvstring)
-        self.index_mapping = dict()
-        if index_mapping:
-            self.index_mapping = index_mapping
-        self.object_field_mapping = dict()
-        if object_field_mapping:
-            self.object_field_mapping = object_field_mapping
-        self.required_metadata_values = required_metadata_values
+        self.index_mapping = index_mapping if index_mapping else dict()
+        self.object_field_mapping = (
+            object_field_mapping if object_field_mapping else dict()
+        )
+        self.required_metadata_values = (
+            required_metadata_values if required_metadata_values else dict()
+        )
+        self.metadata_field_mapping = (
+            metadata_field_mapping if metadata_field_mapping else dict()
+        )
         self.objects = dict()
         self.errors = dict()
+        self.include_indexed_field = include_indexed_field
+        self.top_level_fields_mapping = (
+            top_level_fields_mapping if top_level_fields_mapping else dict()
+        )
+        self.external_file_sources = (
+            external_file_sources if external_file_sources else []
+        )
         self.__fill_objects_from_csv()
+        self.__rename_top_level_fields()
 
     def get_entities(self):
         return self.objects.get("entities", list())
@@ -136,9 +160,20 @@ class CSVMultiObject(CSVParser):
     def get_errors(self):
         return self.errors
 
+    def get_top_level_fields_mapping(self, type):
+        return self.top_level_fields_mapping.get(type, {})
+
     def get_mediafiles(self):
         return self.objects.get("mediafiles", list())
 
+    def __determine_language(self, row):
+        if "language" in row:
+            return row.get("language")
+        elif "lang" in row:
+            return row.get("lang")
+        else:
+            return "en"
+
     def __field_allowed(self, target_object_type, key, value):
         for object_type, fields in self.object_field_mapping.items():
             for _ in [x for x in fields if x == key]:
@@ -151,13 +186,23 @@ class CSVMultiObject(CSVParser):
 
     def __fill_objects_from_csv(self):
         indexed_dict = dict()
+        external_mediafiles_ids = []
         for row in self.reader:
-            if not all(x in row.keys() for x in self.index_mapping.values()):
-                raise ColumnNotFoundException(
-                    f"Not all identifying columns are present in CSV"
-                )
+            mandatory_columns = [
+                v for k, v in self.index_mapping.items() if not k.startswith("?")
+            ]
+            missing_columns = [x for x in mandatory_columns if x not in row.keys()]
+            if missing_columns:
+                raise ColumnNotFoundException(f"{', '.join(missing_columns)}")
+            lang = self.__determine_language(row)
             previous_id = None
             for type, identifying_column in self.index_mapping.items():
+                is_type_optional = False
+                if type.startswith("?"):
+                    is_type_optional = True
+                    type = type.lstrip("?")
+                if not row.get(identifying_column) and is_type_optional:
+                    continue
                 id = row[identifying_column]
                 if type not in indexed_dict:
                     indexed_dict[type] = dict()
@@ -167,7 +212,23 @@ class CSVMultiObject(CSVParser):
                 if previous_id:
                     indexed_dict[type][id]["matching_id"] = previous_id
                 previous_id = id
+                file_source = None
                 for key, value in row.items():
+                    if not value:
+                        continue
+                    if key == "file_source":
+                        file_source = value
+                    if (
+                        key == "file_identifier"
+                        and file_source in self.external_file_sources
+                    ):
+                        matching_id = indexed_dict[type][id]["matching_id"]
+                        if not any(matching_id in id for id in external_mediafiles_ids):
+                            external_mediafiles_ids.append({matching_id: file_source})
+                        if "entities" not in indexed_dict:
+                            indexed_dict["entities"] = dict()
+                        if id in indexed_dict["entities"]:
+                            indexed_dict["entities"][id]["file_identifier"] = value
                     if self._is_relation_field(key) and self.__field_allowed(
                         type, key, value
                     ):
@@ -187,16 +248,37 @@ class CSVMultiObject(CSVParser):
                         indexed_dict[type][id][key] = value
                     elif (
                         key not in self.index_mapping.values()
-                        and self.__field_allowed(type, key, value)
-                    ):
-                        indexed_dict[type][id].setdefault("metadata", list())
-                        indexed_dict[type][id]["metadata"].append(
-                            self._get_metadata_object(key, value)
-                        )
+                        or self.include_indexed_field
+                    ) and self.__field_allowed(type, key, value):
+                        # Map the metadata field to a unified key if applicable
+                        metadata_info = self.metadata_field_mapping.get(key, {})
+                        if metadata_info.get("target") == type or not metadata_info:
+                            case_insensitive = metadata_info.get("case_insensitive", False)
+                            metadata_key = metadata_info.get("map_to", key)
+                            indexed_dict[type][id].setdefault("metadata", list())
+                            options = metadata_info.get("value_options")
+                            if case_insensitive:
+                                value = value.lower()
+                            if options and value not in options:
+                                raise InvalidValueException(
+                                    f'The value "{value}" is invalid, these are the valid values: {options}'
+                                )
+                            indexed_dict[type][id]["metadata"].append(
+                                self._get_metadata_object(metadata_key, value, lang)
+                            )
         self.__validate_indexed_dict(indexed_dict)
         self.__add_required_fields(indexed_dict)
         for object_type, objects in indexed_dict.items():
             self.objects[object_type] = list(objects.values())
+        if external_mediafiles_ids:
+            for mediafile in self.objects["mediafiles"]:
+                matching_id = mediafile["matching_id"]
+                for entry in external_mediafiles_ids:
+                    if matching_id in entry:
+                        file_source = entry[matching_id]
+                        dynamic_key = f"is_{file_source}_mediafile"
+                        mediafile[dynamic_key] = True
+                        break
 
     def __add_required_fields(self, indexed_dict):
         if not self.required_metadata_values:
@@ -231,3 +313,18 @@ class CSVMultiObject(CSVParser):
                     )
             for error_id in error_ids:
                 del objects[error_id]
+
+    def __rename_top_level_fields(self):
+        def rename_fields(items, mapping):
+            for item in items:
+                for old_key, new_key in mapping.items():
+                    if old_key in item:
+                        item[new_key] = item.pop(old_key)
+
+        mediafiles = self.get_mediafiles()
+        entities = self.get_entities()
+        mediafiles_mapping = self.get_top_level_fields_mapping("mediafiles")
+        entities_mapping = self.get_top_level_fields_mapping("entities")
+
+        rename_fields(mediafiles, mediafiles_mapping)
+        rename_fields(entities, entities_mapping)

elody/error_codes.py

@@ -0,0 +1,112 @@
+from enum import Enum
+
+
+class ErrorCode(Enum):
+    READ = "R"
+    WRITE = "W"
+
+    # General error codes
+    UNKNOWN_ERROR = ("0002", [])
+    COLLECTION_NOT_FOUND = ("0003", ["collection"])
+    ITEM_NOT_FOUND = ("0004", ["id"])
+    HISTORY_ITEM_NOT_FOUND = ("0005", [])
+    CANNOT_SPECIFY_BOTH = ("0006", [])
+    ALREADY_PARENT = ("0007", ["id"])
+    METADATA_KEY_UNDEFINED = ("0008", ["key", "document"])
+    ENTITY_HAS_NO_TENANT = ("0009", ["value", "user"])
+    MEDIAFILE_NOT_FOUND = ("0010", [])
+    ITEM_NOT_FOUND_IN_COLLECTION = ("0011", ["id", "collection"])
+
+    # Auth error codes
+    INVALID_CREDENTIALS = ("1001", [])
+    ACCOUNT_LOCKED = ("1002", [])
+    INSUFFICIENT_PERMISSIONS = ("1003", ["restricted_keys"])
+    NO_PERMISSIONS = ("1004", [])
+    UNDEFINED_COLLECTION_RESOLVER = ("1005", [])
+    TENANT_NOT_FOUND = ("1006", [])
+    XTENANT_HAS_NO_TENANT_DEFENING_ENTITY = ("1007", ["x_tenant_id"])
+    INSUFFICIENT_PERMISSIONS_WITHOUT_VARS = ("1008", [])
+    NO_GLOBAL_ROLES = ("1009", [])
+    NO_PERMISSION_TO_TENANT = ("1010", ["tenant_id"])
+    XTENANT_NOT_FOUND = ("1011", ["x_tenant_id"])
+    NO_DOWNLOAD_PERMISSION = ("1012", [])
+
+    # Database error codes
+    DATABASE_NOT_INITIALIZED = ("2000", [])
+    DATABASE_CONNECTION_FAILED = ("2001", [])
+    QUERY_EXECUTION_FAILED = ("2002", [])
+    DUPLICATE_ENTRY = ("2003", [])
+    DUPLICATE_IDENTIFIERS = ("2004", ["duplicate_keys"])
+
+    # Network error codes
+    NETWORK_UNAVAILABLE = ("3001", [])
+    TIMEOUT = ("3002", [])
+    SERVER_NOT_FOUND = ("3003", [])
+
+    # File handling error codes
+    FILE_NOT_FOUND = ("4001", [])
+    FILE_ACCESS_DENIED = ("4002", [])
+    FILE_CORRUPTED = ("4003", [])
+    NO_FILENAME_SPECIFIED = ("4004", [])
+    NO_TICKET_ID_SPECIFIED = ("4005", [])
+    TICKET_NOT_FOUND = ("4006", [])
+    TICKET_EXPIRED = ("4007", [])
+    PROVIDE_MEDIAFILE_ID_OR_TICKET_ID = ("4008", [])
+    DUPLICATE_FILE = ("4009", [])
+    NO_BUCKET_SPECIFIED = ("4010", [])
+
+    # Validation error codes
+    INVALID_INPUT = ("5001", [])
+    REQUIRED_FIELD_MISSING = ("5002", [])
+    INVALID_FORMAT = ("5003", [])
+    INVALID_TYPE = ("5004", [])
+    COLUMN_NOT_FOUND = ("5005", ["missing_columns"])
+    ONLY_TYPE_CSV_ALLOWED = ("5006", [])
+    NO_METADATA_AVAILABLE = ("5007", [])
+    INVALID_DATETIME = ("5008", ["value"])
+    UNSUPPORTED_TYPE = ("5009", ["type"])
+    CONTENT_NOT_FOUND = ("5010", [])
+    VALIDATION_ERROR = ("5011", [])
+    TENANT_HAS_MISSING_DATA = ("5012", [])
+    INVALID_FORMAT_FOR_TYPE = ("5013", ["type"])
+    NO_METADATA_AVAILABLE_FOR_ITEM = ("5014", ["id"])
+    INVALID_ACCEPT_HEADER = ("5015", [])
+
+    # Filter error codes
+    NO_MATCHER_FOR_FILTER_REQUEST = ("6001", [])
+    UNDEFINED_FILTER_FOR_INPUT_TYPE = ("6002", ["input_type"])
+    UNSUPPORTED_OPERATOR = ("6003", ["operator"])
+
+    # Migration error codes
+    UNABLE_TO_UPDATE_SCHEMA_VERSION = ("7001", ["migrated_item"])
+    LAZY_MIGRATION_SCHEMA_TYPE_MISMATCH = ("7002", [])
+
+    # External Services
+    SERVICE_UNAVAILABLE = ("8001", [])
+
+    # Arches error codes
+    ARCHES_ERROR = ("11000", ["error"])
+    ARCHES_CONNECTION_UNAVAILABLE = ("11001", [])
+    ARCHES_RECORD_NOT_FOUND = ("11002", ["error_message", "arches_id"])
+    ARCHES_RECORD_MISSING_DATA = ("11003", ["arches_id"])
+    ARCHES_RECORD_MISSING_DATA_DC_PUBLISHER = ("11004", ["arches_id"])
+    ARCHES_UNABLE_TO_CREATE_RELATION = ("11005", ["type", "value"])
+
+    # Digipolis error codes
+    NO_PERMISSION_TO_CREATE_INSTIUTION = ("12000", ["institution"])
+    INSTITUTION_HAS_MISSING_DATA = ("12001", ["institution"])
+    INSTITUTION_NOT_FOUND = ("12002", [])
+
+
+def get_error_code(error_code, prefix):
+    if prefix not in [ErrorCode.READ.value, ErrorCode.WRITE.value]:
+        raise ValueError("Prefix must be 'R' for read or 'W' for write.")
+    return f"{prefix}{error_code.value[0]}"
+
+
+def get_read():
+    return ErrorCode.READ.value
+
+
+def get_write():
+    return ErrorCode.WRITE.value

elody/exceptions.py

@@ -1,3 +1,9 @@
+class DuplicateExternalLinkException(Exception):
+    def __init__(self, message, external_id=None):
+        super().__init__(message)
+        self.external_id = external_id
+
+
 class DuplicateFileException(Exception):
     def __init__(self, message, filename=None, md5sum=None):
         super().__init__(message)
@@ -26,6 +32,10 @@ class InvalidObjectException(Exception):
     pass
 
 
+class InvalidValueException(Exception):
+    pass
+
+
 class NoMediafilesException(Exception):
     pass
 
@@ -38,5 +48,9 @@ class NotFoundException(Exception):
     pass
 
 
+class NoTenantException(Exception):
+    pass
+
+
 class UnsupportedVersionException(Exception):
     pass

elody/job.py

@@ -0,0 +1,95 @@
+from elody.object_configurations.job_configuration import JobConfiguration
+
+
+_config = JobConfiguration()
+_create = _config.crud()["creator"]
+_post_crud_hook = _config.crud()["post_crud_hook"]
+
+
+def start_job(
+    name,
+    job_type,
+    *,
+    get_rabbit,
+    get_user_context=None,
+    user_email=None,
+    parent_id=None,
+    id_of_document_job_was_initiated_for=None,
+    type_of_document_job_was_initiated_for=None,
+) -> str:
+    relations = []
+    if parent_id:
+        relations.append({"key": parent_id, "type": "hasParentJob"})
+    if id_of_document_job_was_initiated_for and type_of_document_job_was_initiated_for:
+        relations.append(
+            {"key": id_of_document_job_was_initiated_for, "type": "isJobOf"}
+        )
+
+    job = _create(
+        {
+            "metadata": [
+                {"key": "name", "value": name},
+                {"key": "status", "value": "running"},
+                {"key": "type", "value": job_type},
+            ],
+            "relations": relations,
+            "type": "job",
+        },
+        get_user_context=get_user_context
+        or (lambda: type("UserContext", (object,), {"email": user_email})()),
+    )
+    del job["computed_values"]["created_at"]
+
+    _post_crud_hook(
+        crud="create", document=job, parent_id=parent_id, get_rabbit=get_rabbit
+    )
+    __patch_document_job_was_initiated_for(
+        id_of_document_job_was_initiated_for,
+        type_of_document_job_was_initiated_for,
+        get_rabbit,
+    )
+    return job["_id"]
+
+
+def finish_job(
+    id,
+    id_of_document_job_was_initiated_for=None,
+    type_of_document_job_was_initiated_for=None,
+    *,
+    get_rabbit,
+):
+    document = {
+        "id": id,
+        "patch": {
+            "metadata": [{"key": "status", "value": "finished"}],
+            "relations": ([] if id_of_document_job_was_initiated_for else []),
+        },
+    }
+    _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+    __patch_document_job_was_initiated_for(
+        id_of_document_job_was_initiated_for,
+        type_of_document_job_was_initiated_for,
+        get_rabbit,
+    )
+
+
+def fail_job(id, exception_message, *, get_rabbit):
+    document = {
+        "id": id,
+        "patch": {
+            "metadata": [
+                {"key": "info", "value": exception_message},
+                {"key": "status", "value": "failed"},
+            ]
+        },
+    }
+    _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)
+
+
+def __patch_document_job_was_initiated_for(id, type, get_rabbit):
+    if id and type:
+        document = {
+            "document_info_job_was_initiated_for": {"id": id, "type": type},
+            "patch": {"relations": [{"key": id, "type": "hasJob"}]},
+        }
+        _post_crud_hook(crud="update", document=document, get_rabbit=get_rabbit)