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

elody/policies/tenant_id_resolver.py

@@ -0,0 +1,375 @@
+import re as regex
+
+from elody.error_codes import ErrorCode, get_error_code, get_read, get_write
+from flask import Request
+from flask_restful import abort
+from storage.storagemanager import StorageManager  # pyright: ignore
+from elody.util import get_item_metadata_value
+from elody.exceptions import NotFoundException, NoTenantException
+
+
+class TenantIdResolver:
+    def resolve(self, request, user):
+        endpoints = [
+            EntityGetRequest,
+            EntityPostRequest,
+            EntityDetailGetRequest,
+            EntityDetailUpdateRequest,
+            EntityDetailDeleteRequest,
+            EntityDetailGetRelationsRequest,
+            EntityDetailUpdateRelationsRequest,
+            EntityDetailCreateRelationsRequest,
+            EntityDetailDeleteRelationsRequest,
+            EntityDetailGetMetadataRequest,
+            EntityDetailUpdateMetadataRequest,
+            EntityDetailCreateMetadataRequest,
+            EntityDetailGetMediafilesRequest,
+            EntityDetailCreateMediafilesRequest,
+            MediafileGetRequest,
+            MediafilePostRequest,
+            MediafileDetailGetRequest,
+            MediafileDetailUpdateRequest,
+            MediafileDetailDeleteRequest,
+            MediafileDetailGetDerivativesRequest,
+            MediafileDetailCreateDerivativesRequest,
+            MediafileDetailDeleteDerivativesRequest,
+        ]
+
+        for endpoint in endpoints:
+            tenant_id = endpoint().get_tenant_id(request)
+            if tenant_id != None:
+                relations = user.get("relations", [])
+                if len(relations) < 1:
+                    raise NoTenantException(f"User is not attached to a tenant")
+                has_tenant_relation = any(
+                    relation.get("type") == "hasTenant"
+                    and relation.get("key") == tenant_id
+                    for relation in relations
+                )
+                if has_tenant_relation:
+                    return tenant_id
+                elif len(relations) == 1 and relations[0].get("key") == "tenant:super":
+                    return "tenant:super"
+                else:
+                    return relations[0].get("key")
+        return "tenant:super"
+
+
+class BaseRequest:
+    def __init__(self) -> None:
+        self.storage = StorageManager().get_db_engine()
+        self.super_tenant_id = "tenant:super"
+        # TODO refactor this in a more generic way
+        self.global_types = [
+            "language",
+            "type",
+            "collectionForm",
+            "institution",
+            "tag",
+            "triple",
+            "person",
+            "externalRecord",
+            "verzameling",
+            "arches_record",
+            "manufacturer",
+            "photographer",
+            "creator",
+            "assetPart",
+            "set",
+            "download",
+            "license",
+            "share_link"
+            # TODO Mediafile should have a link to an asset
+            "mediafile",
+            "savedSearch",
+            "original_data",
+            "user",
+        ]
+
+    def _get_tenant_id_from_entity(self, entity_id):
+        entity_relations = self.storage.get_collection_item_relations(
+            "entities", entity_id
+        )
+        entity = self.storage.get_item_from_collection_by_id("entities", entity_id)
+        if not entity:
+            abort(
+                404,
+                message=f"{get_error_code(ErrorCode.ITEM_NOT_FOUND, get_read())} | id:{entity_id} - Item with id {entity_id} doesn't exist",
+            )
+        type = entity.get("type")
+        if type in self.global_types:
+            return "tenant:super"
+        if entity_relations:
+            for entity_relation in entity_relations:
+                if entity_relation.get("type") == "isIn":
+                    tenant = self.storage.get_item_from_collection_by_id(
+                        "entities", entity_relation.get("key")
+                    )
+                    return tenant["_id"]
+                if entity_relation.get("type") == "hasInstitution":
+                    instution_relations = self.storage.get_collection_item_relations(
+                        "entities", entity_relation.get("key")
+                    )
+                    for institution_relation in instution_relations:
+                        if institution_relation.get("type") == "defines":
+                            return institution_relation.get("key")
+
+        if entity and get_item_metadata_value(entity, "institution"):
+            return f"tenant:{get_item_metadata_value(entity, 'institution')}"
+        abort(
+            400,
+            message=f"{get_error_code(ErrorCode.ENTITY_HAS_NO_TENANT, get_read())} - Entity has no tenant, and is suppose to have one.",
+        )
+
+    def _get_tenant_id_from_mediafile(self, mediafile_id):
+        mediafile_relations = self.storage.get_collection_item_relations(
+            "mediafiles", mediafile_id
+        )
+
+        for relation in mediafile_relations:
+            if relation.get("type") == "belongsTo":
+                return self._get_tenant_id_from_entity(relation.get("key"))
+
+    # TODO Mediafile should have a link to an asset
+    def _get_tenant_id_from_body(self, item, soft_call=False):
+        if soft_call:
+            return "tenant:super"
+        if item.get("type") in self.global_types or item.get("type") == "institution":
+            return "tenant:super"
+        if item.get("type") == "asset":
+            for relation in item.get("relations", []):
+                if relation.get("type") in [
+                    "hasArchesLink",
+                    "hasAdlibLink",
+                    "hasBrocadeLink",
+                ]:
+                    return "tenant:super"
+        institution_id = get_item_metadata_value(item, "institution")
+        if not institution_id:
+            for relation in item.get("relations", []):
+                if relation.get("type") == "hasInstitution":
+                    institution_id = relation.get("key")
+        if institution_id:
+            return f"tenant:{institution_id}"
+        abort(
+            400,
+            message=f"{get_error_code(ErrorCode.ENTITY_HAS_NO_TENANT, get_read())} - Item in body doesn't have an institution.",
+        )
+
+
+class EntityGetRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities(?:\?(.*))?$", request.path)
+            and request.method == "GET"
+        ):
+            return self.super_tenant_id
+        return None
+
+
+class EntityPostRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities(?:\?(.*))?$", request.path)
+            and request.method == "POST"
+        ):
+            is_soft_call = request.args.get("soft") is not None
+            return self._get_tenant_id_from_body(request.json, soft_call=is_soft_call)
+        return None
+
+
+class EntityDetailGetRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if regex.match(r"/entities/(.+)$", request.path) and request.method == "GET":
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailUpdateRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if regex.match(r"^/entities/(.+)$", request.path) and request.method in [
+            "PUT",
+            "PATCH",
+        ]:
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailDeleteRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/([^/]+)$", request.path)
+            and request.method == "DELETE"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailGetRelationsRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/relations$", request.path)
+            and request.method == "GET"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailUpdateRelationsRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if regex.match(
+            r"^/entities/(.+)/relations$", request.path
+        ) and request.method in ["PUT", "PATCH"]:
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailCreateRelationsRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/relations$", request.path)
+            and request.method == "POST"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailDeleteRelationsRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/relations$", request.path)
+            and request.method == "DELETE"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailGetMetadataRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/metadata$", request.path)
+            and request.method == "GET"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailUpdateMetadataRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if regex.match(
+            r"^/entities/(.+)/metadata$", request.path
+        ) and request.method in ["PUT", "PATCH"]:
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailCreateMetadataRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/metadata$", request.path)
+            and request.method == "POST"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailGetMediafilesRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/mediafiles$", request.path)
+            and request.method == "GET"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+class EntityDetailCreateMediafilesRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/entities/(.+)/mediafiles$", request.path)
+            and request.method == "POST"
+        ):
+            return self._get_tenant_id_from_entity(request.view_args.get("id"))
+        return None
+
+
+# Mediafiles
+class MediafileGetRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles(?:\?(.*))?$", request.path)
+            and request.method == "GET"
+        ):
+            return self.super_tenant_id
+        return None
+
+
+class MediafilePostRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles(?:\?(.*))?$", request.path)
+            and request.method == "POST"
+        ):
+            is_soft_call = request.args.get("soft") is not None
+            return self._get_tenant_id_from_body(request.json, soft_call=is_soft_call)
+        return None
+
+
+class MediafileDetailGetRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles/([^/]+)$", request.path)
+            and request.method == "GET"
+        ):
+            return self.super_tenant_id
+        return None
+
+
+class MediafileDetailUpdateRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if regex.match(r"^/mediafiles/(.+)$", request.path) and request.method in [
+            "PUT",
+            "PATCH",
+        ]:
+            return self._get_tenant_id_from_mediafile(request.view_args.get("id"))
+        return None
+
+
+class MediafileDetailDeleteRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles/(.+)$", request.path)
+            and request.method == "DELETE"
+        ):
+            return self._get_tenant_id_from_mediafile(request.view_args.get("id"))
+        return None
+
+
+class MediafileDetailGetDerivativesRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles/(.+)/derivatives$", request.path)
+            and request.method == "GET"
+        ):
+            return self.super_tenant_id
+        return None
+
+
+class MediafileDetailCreateDerivativesRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles/(.+)/derivatives$", request.path)
+            and request.method == "POST"
+        ):
+            return self._get_tenant_id_from_mediafile(request.view_args.get("id"))
+        return None
+
+
+class MediafileDetailDeleteDerivativesRequest(BaseRequest):
+    def get_tenant_id(self, request: Request) -> str | None:
+        if (
+            regex.match(r"^/mediafiles/(.+)/derivatives$", request.path)
+            and request.method == "DELETE"
+        ):
+            return self._get_tenant_id_from_mediafile(request.view_args.get("id"))
+        return None

elody/schemas.py

@@ -105,9 +105,6 @@ mediafile_schema = {
     "$schema": "http://json-schema.org/draft-07/schema#",
     "type": "object",
     "default": {},
-    "required": [
-        "filename",
-    ],
     "properties": {
         "filename": {
             "type": "string",

elody/util.py

@@ -1,9 +1,45 @@
 import json
 import mimetypes
+import re as regex
 
 from cloudevents.conversion import to_dict
 from cloudevents.http import CloudEvent
+from collections.abc import MutableMapping, Iterable
+from copy import deepcopy
 from datetime import datetime, timezone
+from os import getenv
+
+
+URL_UNFRIENDLY_CHARS = {
+    " ": "%20",
+    "!": "%21",
+    "'": "%22",
+    "#": "%23",
+    "%": "%25",
+    "&": "%26",
+    '"': "%27",
+    "(": "%28",
+    ")": "%29",
+    "*": "%2A",
+    "+": "%2B",
+    ",": "%2C",
+    "/": "%2F",
+    ";": "%3B",
+    "<": "%3C",
+    "=": "%3D",
+    ">": "%3E",
+    "?": "%3F",
+    "@": "%40",
+    "[": "%5B",
+    "\\": "%5C",
+    "]": "%5D",
+    "^": "%5E",
+    "`": "%60",
+    "{": "%7B",
+    "|": "%7C",
+    "}": "%7D",
+    "~": "%7E",
+}
 
 
 class CustomJSONEncoder(json.JSONEncoder):
@@ -36,10 +72,46 @@ def custom_json_dumps(obj):
     return json.dumps(obj, cls=CustomJSONEncoder)
 
 
-def __send_cloudevent(mq_client, routing_key, data):
-    attributes = {"type": routing_key, "source": "dams"}
-    event = to_dict(CloudEvent(attributes, data))
-    mq_client.send(event, routing_key=routing_key)
+def flatten_dict(object_lists, data: MutableMapping, parent_key=""):
+    if not parent_key:
+        data = deepcopy(data)
+    flat_dict = {}
+    for key, value in __flatten_dict_generator(object_lists, data, parent_key):
+        if key in flat_dict:
+            if not isinstance(flat_dict[key], list):
+                flat_dict[key] = [flat_dict[key]]
+            if isinstance(value, list):
+                flat_dict[key].extend(value)
+            else:
+                flat_dict[key].append(value)
+        else:
+            flat_dict[key] = value
+    return flat_dict
+
+
+def __flatten_dict_generator(object_lists, data: MutableMapping, parent_key):
+    for key, value in data.items():
+        flattened_key = f"{parent_key}.{key}" if parent_key else key
+        if isinstance(value, MutableMapping):
+            yield from flatten_dict(object_lists, value, flattened_key).items()
+        elif isinstance(value, Iterable) and not isinstance(value, (str, bytes)):
+            if all(isinstance(item, MutableMapping) for item in value):
+                item_key = None
+                for item in value:
+                    item_key = item.get(object_lists.get(key))
+                    if item_key:
+                        if isinstance(item, MutableMapping):
+                            yield from flatten_dict(
+                                object_lists, item, f"{flattened_key}.{item_key}"
+                            ).items()
+                        else:
+                            yield f"{flattened_key}.{item_key}", item["value"]
+                if not item_key:
+                    yield flattened_key, value
+            else:
+                yield flattened_key, value
+        else:
+            yield flattened_key, value
 
 
 def get_raw_id(item):
@@ -58,6 +130,35 @@ def get_mimetype_from_filename(filename):
     return mime if mime else "application/octet-stream"
 
 
+def interpret_flat_key(flat_key: str, object_lists):
+    keys_info = []
+    index = 0
+
+    flat_key_parts = regex.split(r"\.(?=(?:[^`]*`[^`]*`)*[^`]*$)", flat_key)
+    while index < len(flat_key_parts):
+        info = {
+            "key": flat_key_parts[index],
+            "object_list": (
+                flat_key_parts[index]
+                if flat_key_parts[index] in object_lists.keys()
+                else ""
+            ),
+        }
+
+        if info["object_list"]:
+            combined_key = "".join(
+                [f"{info['key']}." for info in keys_info if not info["object_list"]]
+            )
+            info["key"] = f"{combined_key}{info['key']}"
+            info["object_key"] = flat_key_parts[index + 1]
+            keys_info = [info for info in keys_info if info["object_list"]]
+
+        keys_info.append(info)
+        index += 2 if info["object_list"] else 1
+
+    return keys_info
+
+
 def mediafile_is_public(mediafile):
     publication_status = get_item_metadata_value(mediafile, "publication_status")
     copyright_color = get_item_metadata_value(mediafile, "copyright_color")
@@ -68,6 +169,16 @@ def mediafile_is_public(mediafile):
     ] or copyright_color.lower() in ["green", "groen"]
 
 
+def parse_string_to_bool(value):
+    if isinstance(value, str):
+        value_lower = value.strip().lower()
+        if value_lower in ["true", "yes", "1", "y"]:
+            return True
+        elif value_lower in ["false", "no", "0", "n"]:
+            return False
+    return value
+
+
 def read_json_as_dict(filename, logger):
     try:
         with open(filename) as file:
@@ -77,16 +188,39 @@ def read_json_as_dict(filename, logger):
     return {}
 
 
+def parse_url_unfriendly_string(
+    input: str, *, replace_char=None, return_unfriendly_chars=False
+):
+    unfriendly_chars = []
+    result = input
+    for char, encoded in URL_UNFRIENDLY_CHARS.items():
+        if char in input:
+            unfriendly_chars.append(char)
+            replacement = encoded if replace_char is None else replace_char
+            result = result.replace(char, replacement)
+    if return_unfriendly_chars:
+        return result, unfriendly_chars
+    return result
+
+
+def send_cloudevent(mq_client, source, routing_key, data, exchange_name=None):
+    event = to_dict(CloudEvent({"source": source, "type": routing_key}, data))
+    if getenv("AMQP_MANAGER", "amqpstorm_flask") in ["amqpstorm_flask"]:
+        mq_client.send(event, routing_key=routing_key, exchange_name=exchange_name)
+    else:
+        mq_client.send(event, routing_key=routing_key)
+
+
 def signal_child_relation_changed(mq_client, collection, id):
     data = {"parent_id": id, "collection": collection}
-    __send_cloudevent(mq_client, "dams.child_relation_changed", data)
+    send_cloudevent(mq_client, "dams", "dams.child_relation_changed", data)
 
 
 def signal_edge_changed(mq_client, parent_ids_from_changed_edges):
     data = {
         "location": f'/entities?ids={",".join(parent_ids_from_changed_edges)}&skip_relations=1'
     }
-    __send_cloudevent(mq_client, "dams.edge_changed", data)
+    send_cloudevent(mq_client, "dams", "dams.edge_changed", data)
 
 
 def signal_entity_changed(mq_client, entity):
@@ -94,24 +228,44 @@ def signal_entity_changed(mq_client, entity):
         "location": f"/entities/{get_raw_id(entity)}",
         "type": entity.get("type", "unspecified"),
     }
-    __send_cloudevent(mq_client, "dams.entity_changed", data)
+    send_cloudevent(mq_client, "dams", "dams.entity_changed", data)
 
 
 def signal_entity_deleted(mq_client, entity):
     data = {"_id": get_raw_id(entity), "type": entity.get("type", "unspecified")}
-    __send_cloudevent(mq_client, "dams.entity_deleted", data)
+    send_cloudevent(mq_client, "dams", "dams.entity_deleted", data)
 
 
 def signal_mediafiles_added_for_entity(mq_client, entity, mediafiles):
     data = {"entity": entity, "mediafiles": mediafiles}
-    __send_cloudevent(mq_client, "dams.mediafiles_added_for_entity", data)
+    send_cloudevent(mq_client, "dams", "dams.mediafiles_added_for_entity", data)
+
+
+def signal_relations_deleted_for_entity(mq_client, entity, relations):
+    data = {"entity": entity, "relations": relations}
+    send_cloudevent(mq_client, "dams", "dams.relations_deleted_for_entity", data)
 
 
 def signal_mediafile_changed(mq_client, old_mediafile, mediafile):
     data = {"old_mediafile": old_mediafile, "mediafile": mediafile}
-    __send_cloudevent(mq_client, "dams.mediafile_changed", data)
+    send_cloudevent(mq_client, "dams", "dams.mediafile_changed", data)
 
 
 def signal_mediafile_deleted(mq_client, mediafile, linked_entities):
     data = {"mediafile": mediafile, "linked_entities": linked_entities}
-    __send_cloudevent(mq_client, "dams.mediafile_deleted", data)
+    send_cloudevent(mq_client, "dams", "dams.mediafile_deleted", data)
+
+
+def signal_update_copyright_color_entity(mq_client, entity_id):
+    data = {"_id": entity_id}
+    send_cloudevent(mq_client, "dams", "dams.update_copyright_color_entity", data)
+
+
+def signal_update_copyright_color_mediafile(mq_client, mediafile_id):
+    data = {"_id": mediafile_id}
+    send_cloudevent(mq_client, "dams", "dams.update_copyright_color_mediafile", data)
+
+
+def signal_upload_file(mq_client, upload_links, selected_folder):
+    data = {"upload_links": upload_links, "selected_folder": selected_folder}
+    send_cloudevent(mq_client, "dams", "dams.upload_file", data)

{elody-0.0.63.dist-info → elody-0.0.162.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: elody
-Version: 0.0.63
+Version: 0.0.162
 Summary: elody SDK for Python
 Author-email: Inuits <developers@inuits.eu>
-License: GNU GENERAL PUBLIC LICENSE
+License:                     GNU GENERAL PUBLIC LICENSE
                                Version 2, June 1991
         
          Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
@@ -354,16 +354,21 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: certifi >=2023.5.7
-Requires-Dist: charset-normalizer >=3.2.0
-Requires-Dist: idna >=3.4
-Requires-Dist: requests >=2.31.0
-Requires-Dist: urllib3 >=1.26.16
+Requires-Dist: certifi>=2023.5.7
+Requires-Dist: charset-normalizer>=3.2.0
+Requires-Dist: idna>=3.4
+Requires-Dist: requests>=2.31.0
+Requires-Dist: urllib3>=1.26.16
 Provides-Extra: loader
-Requires-Dist: cloudevents >=1.9.0 ; extra == 'loader'
-Requires-Dist: inuits-policy-based-auth >=9.6.0 ; extra == 'loader'
+Requires-Dist: APScheduler>=3.10.4; extra == "loader"
+Requires-Dist: cloudevents>=1.9.0; extra == "loader"
+Requires-Dist: inuits-policy-based-auth>=10.0.1; extra == "loader"
+Requires-Dist: jsonschema>=4.23.0; extra == "loader"
+Requires-Dist: pytz>=2024.1; extra == "loader"
+Requires-Dist: six>=1.16.0; extra == "loader"
+Requires-Dist: tzlocal>=5.2; extra == "loader"
 Provides-Extra: util
-Requires-Dist: cloudevents >=1.9.0 ; extra == 'util'
+Requires-Dist: cloudevents>=1.9.0; extra == "util"
 
 # elody SDK for Python