elody 0.0.156__py3-none-any.whl → 0.0.158__py3-none-any.whl

elody/csv.py

@@ -188,9 +188,7 @@ class CSVMultiObject(CSVParser):
             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()
-            ]
+            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)

elody/object_configurations/base_object_configuration.py

@@ -10,20 +10,24 @@ class BaseObjectConfiguration(ABC):
     @abstractmethod
     def crud(self):
         return {
-            "collection": "entities",
-            "collection_history": "history",
             "creator": lambda post_body, **kwargs: post_body,
+            "document_content_patcher": lambda *, document, content, overwrite=False, **kwargs: self._document_content_patcher(
+                document=document,
+                content=content,
+                overwrite=overwrite,
+                **kwargs,
+            ),
             "nested_matcher_builder": lambda object_lists, keys_info, value: self.__build_nested_matcher(
                 object_lists, keys_info, value
             ),
             "post_crud_hook": lambda **kwargs: None,
-            "pre_crud_hook": lambda **kwargs: None,
+            "pre_crud_hook": lambda *, document, **kwargs: document,
             "storage_type": "db",
         }
 
     @abstractmethod
     def document_info(self):
-        return {"object_lists": {"metadata": "key", "relations": "type"}}
+        return {}
 
     @abstractmethod
     def logging(self, flat_document, **kwargs):
@@ -33,7 +37,9 @@ class BaseObjectConfiguration(ABC):
             "schema": f"{flat_document.get('schema.type')}:{flat_document.get('schema.version')}",
         }
         try:
-            user_context = kwargs.get("get_user_context")()  # pyright: ignore
+            from policy_factory import get_user_context  # pyright: ignore
+
+            user_context = get_user_context()
             info_labels["http_method"] = user_context.bag.get("http_method")
             info_labels["requested_endpoint"] = user_context.bag.get(
                 "requested_endpoint"
@@ -65,20 +71,50 @@ class BaseObjectConfiguration(ABC):
 
         return "function", validator
 
-    def _get_merged_post_body(self, post_body, document_defaults, object_list_name):
-        key = self.document_info()["object_lists"][object_list_name]
-        post_body[object_list_name] = self.__merge_object_lists(
-            document_defaults.get(object_list_name, []),
-            post_body.get(object_list_name, []),
-            key,
+    def _document_content_patcher(
+        self, *, document, content, overwrite=False, **kwargs
+    ):
+        raise NotImplementedError(
+            "Provide concrete implementation in child object configuration"
         )
-        return post_body
 
-    def _sanitize_document(self, document, object_list_name, value_field_name):
-        object_list = deepcopy(document[object_list_name])
-        for element in object_list:
-            if not element[value_field_name]:
-                document[object_list_name].remove(element)
+    def _merge_object_lists(self, source, target, object_list_key):
+        for target_item in target:
+            for source_item in source:
+                if source_item[object_list_key] == target_item[object_list_key]:
+                    source.remove(source_item)
+        return [*source, *target]
+
+    def _get_user_context_id(self):
+        try:
+            from policy_factory import get_user_context  # pyright: ignore
+
+            return get_user_context().id
+        except Exception:
+            return None
+
+    def _sanitize_document(self, *, document, **kwargs):
+        sanitized_document = {}
+        document_deepcopy = deepcopy(document)
+        for key, value in document_deepcopy.items():
+            if isinstance(value, dict):
+                sanitized_value = BaseObjectConfiguration._sanitize_document(
+                    self, document=value
+                )
+                if sanitized_value:
+                    sanitized_document[key] = sanitized_value
+            elif value:
+                sanitized_document[key] = value
+        return sanitized_document
+
+    def _should_create_history_object(self):
+        try:
+            from policy_factory import get_user_context  # pyright: ignore
+
+            get_user_context()
+            return bool(self.crud().get("collection_history"))
+        except Exception:
+            return False
 
     def _sort_document_keys(self, document):
         def sort_keys(data):
@@ -98,12 +134,13 @@ class BaseObjectConfiguration(ABC):
             else:
                 return data
 
-        for key, value in self.document_info()["object_lists"].items():
+        for key, value in self.document_info().get("object_lists", {}).items():
             if document.get(key):
                 document[key] = sorted(
                     document[key], key=lambda property: property[value]
                 )
         sort_keys(document)
+        return document
 
     def __build_nested_matcher(self, object_lists, keys_info, value, index=0):
         if index == 0 and not any(info["object_list"] for info in keys_info):
@@ -135,10 +172,3 @@ class BaseObjectConfiguration(ABC):
             return elem_match if index > 0 else {info["key"]: {"$all": [elem_match]}}
 
         raise Exception(f"Unable to build nested matcher. See keys_info: {keys_info}")
-
-    def __merge_object_lists(self, source, target, key):
-        for target_item in target:
-            for source_item in source:
-                if source_item[key] == target_item[key]:
-                    source.remove(source_item)
-        return [*source, *target]

elody/object_configurations/elody_configuration.py

@@ -12,6 +12,8 @@ class ElodyConfiguration(BaseObjectConfiguration):
 
     def crud(self):
         crud = {
+            "collection": "entities",
+            "collection_history": "history",
             "creator": lambda post_body, **kwargs: self._creator(post_body, **kwargs),
             "post_crud_hook": lambda **kwargs: self._post_crud_hook(**kwargs),
             "pre_crud_hook": lambda **kwargs: self._pre_crud_hook(**kwargs),
@@ -37,7 +39,6 @@ class ElodyConfiguration(BaseObjectConfiguration):
         self,
         post_body,
         *,
-        get_user_context,
         flat_post_body={},
         document_defaults={},
     ):
@@ -65,36 +66,79 @@ class ElodyConfiguration(BaseObjectConfiguration):
             "relations": [],
             "schema": {"type": self.SCHEMA_TYPE, "version": self.SCHEMA_VERSION},
         }
-        if email := self.__get_email(get_user_context):
-            template["computed_values"]["created_by"] = email
-
-        for key in self.document_info()["object_lists"].keys():
-            post_body = self._get_merged_post_body(post_body, document_defaults, key)
+        if user_context_id := self._get_user_context_id():
+            template["computed_values"]["created_by"] = user_context_id
+
+        for key, object_list_key in self.document_info()["object_lists"].items():
+            if not key.startswith("lookup.virtual_relations"):
+                post_body[key] = self._merge_object_lists(
+                    document_defaults.get(key, []),
+                    post_body.get(key, []),
+                    object_list_key,
+                )
         document = {**template, **document_defaults, **post_body}
 
-        self._sanitize_document(document, "metadata", "value")
-        self._sort_document_keys(document)
+        document = self._sanitize_document(
+            document=document,
+            object_list_name="metadata",
+            object_list_value_field_name="value",
+        )
+        document = self._sort_document_keys(document)
+        return document
+
+    def _document_content_patcher(
+        self, *, document, content, overwrite=False, **kwargs
+    ):
+        object_lists = self.document_info().get("object_lists", {})
+        if overwrite:
+            document = content
+        else:
+            for key, value in content.items():
+                if key in object_lists:
+                    if key != "relations":
+                        for value_element in value:
+                            for item_element in document[key]:
+                                if (
+                                    item_element[object_lists[key]]
+                                    == value_element[object_lists[key]]
+                                ):
+                                    document[key].remove(item_element)
+                                    break
+                    document[key].extend(value)
+                else:
+                    document[key] = value
+
         return document
 
-    def _post_crud_hook(self, **_):
+    def _post_crud_hook(self, **kwargs):
         pass
 
-    def _pre_crud_hook(self, *, crud, document={}, get_user_context=None, **_):
+    def _pre_crud_hook(self, *, crud, document={}, **kwargs):
         if document:
-            self._sanitize_document(document, "metadata", "value")
-            self.__patch_document_computed_values(
-                crud, document, get_user_context=get_user_context
+            document = self._sanitize_document(
+                document=document,
+                object_list_name="metadata",
+                object_list_value_field_name="value",
             )
-            self._sort_document_keys(document)
-
-    def __get_email(self, get_user_context):
-        try:
-            return get_user_context().email
-        except Exception:
-            return None
+            document = self.__patch_document_computed_values(crud, document)
+            document = self._sort_document_keys(document)
+        return document
 
-    def __patch_document_computed_values(self, crud, document, **kwargs):
+    def _sanitize_document(
+        self, *, document, object_list_name, object_list_value_field_name, **kwargs
+    ):
+        sanitized_document = super()._sanitize_document(document=document)
+        object_list = document[object_list_name]
+        for element in object_list:
+            if not element[object_list_value_field_name]:
+                sanitized_document[object_list_name].remove(element)
+        return sanitized_document
+
+    def __patch_document_computed_values(self, crud, document):
+        if not document.get("computed_values"):
+            document["computed_values"] = {}
         document["computed_values"].update({"event": crud})
         document["computed_values"].update({"modified_at": datetime.now(timezone.utc)})
-        if email := self.__get_email(kwargs.get("get_user_context")):
+        if email := self._get_user_context_id():
             document["computed_values"].update({"modified_by": email})
+        return document

elody/object_configurations/job_configuration.py

@@ -16,8 +16,8 @@ class JobConfiguration(ElodyConfiguration):
     def document_info(self):
         return super().document_info()
 
-    def logging(self, flat_item, **kwargs):
-        return super().logging(flat_item, **kwargs)
+    def logging(self, flat_document, **kwargs):
+        return super().logging(flat_document, **kwargs)
 
     def migration(self):
         return super().migration()
@@ -28,6 +28,12 @@ class JobConfiguration(ElodyConfiguration):
     def validation(self):
         return super().validation()
 
+    def _creator(self, post_body, *, get_user_context={}, **_):
+        document = super()._creator(post_body)
+        if email := get_user_context().email:
+            document["computed_values"]["created_by"] = email
+        return document
+
     def _post_crud_hook(self, *, crud, document, get_rabbit, **kwargs):
         if crud == "create":
             send_cloudevent(

elody/policies/permission_handler.py

@@ -21,9 +21,10 @@ def set_permissions(permissions: dict, placeholders: list[str] = []):
 def get_permissions(role: str, user_context: UserContext):
     permissions = deepcopy(_permissions)
 
-    for placeholder in _placeholders:
+    for placeholder_key in _placeholders:
+        placeholder_value = user_context.bag.get(placeholder_key.lower())
         permissions = __replace_permission_placeholders(
-            permissions, placeholder, user_context.bag[placeholder.lower()]
+            permissions, placeholder_key, placeholder_value
         )
     return permissions.get(role, {})  # pyright: ignore
 
@@ -84,8 +85,8 @@ def handle_single_item_request(
 
 def mask_protected_content_post_request_hook(user_context: UserContext, permissions):
     def __post_request_hook(response):
-        items = response["results"]
-        for item in items:
+        items = []
+        for item in response["results"]:
             try:
                 (
                     item_in_storage_format,
@@ -104,6 +105,7 @@ def mask_protected_content_post_request_hook(user_context: UserContext, permissi
                     "read",
                     object_lists,
                 )
+                items.append(user_context.bag["requested_item"])
             except Exception as exception:
                 log.debug(
                     f"{exception.__class__.__name__}: {str(exception)}",
@@ -111,6 +113,7 @@ def mask_protected_content_post_request_hook(user_context: UserContext, permissi
                 )
                 raise exception
 
+        response["results"] = items
         return response
 
     return __post_request_hook
@@ -122,7 +125,7 @@ def __prepare_item_for_permission_check(item, permissions, crud):
         return item, None, None, None
 
     config = get_object_configuration_mapper().get(item["type"])
-    object_lists = config.document_info()["object_lists"]
+    object_lists = config.document_info().get("object_lists", {})
     flat_item = flatten_dict(object_lists, item)
 
     return (
@@ -188,16 +191,23 @@ def __is_allowed_to_crud_item_keys(
         if condition_match:
             if crud == "read":
                 keys_info = interpret_flat_key(restricted_key, object_lists)
-                element = item_in_storage_format
                 for info in keys_info:
                     if info["object_list"]:
                         element = __get_element_from_object_list_of_item(
-                            element,
+                            item_in_storage_format,
                             info["key"],
                             info["object_key"],
                             object_lists,
                         )
-                element[info["key"]] = "[protected content]"  # pyright: ignore
+                        item_in_storage_format[info["key"]].remove(element)
+                        break
+                else:
+                    try:
+                        del item_in_storage_format[keys_info[0]["key"]][
+                            keys_info[1]["key"]
+                        ]
+                    except KeyError:
+                        pass
             else:
                 if flat_request_body.get(restricted_key):
                     user_context.bag["restricted_keys"].append(restricted_key)

{elody-0.0.156.dist-info → elody-0.0.158.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elody
-Version: 0.0.156
+Version: 0.0.158
 Summary: elody SDK for Python
 Author-email: Inuits <developers@inuits.eu>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -362,7 +362,7 @@ Requires-Dist: urllib3>=1.26.16
 Provides-Extra: loader
 Requires-Dist: APScheduler>=3.10.4; extra == "loader"
 Requires-Dist: cloudevents>=1.9.0; extra == "loader"
-Requires-Dist: inuits-policy-based-auth>=9.6.0; extra == "loader"
+Requires-Dist: inuits-policy-based-auth>=10.0.1; extra == "loader"
 Requires-Dist: pytz>=2024.1; extra == "loader"
 Requires-Dist: six>=1.16.0; extra == "loader"
 Requires-Dist: tzlocal>=5.2; extra == "loader"

{elody-0.0.156.dist-info → elody-0.0.158.dist-info}/RECORD

@@ -1,7 +1,7 @@
 __init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/__init__.py,sha256=d0Q6Fn44e7wFfLabDOBxpcJ1DPKWlFunGYDUBmO-4hA,22
 elody/client.py,sha256=Es0iloHq9aOiMgXfwssEiV1Nqvvd6Z3RfsyoJvIZ48I,8280
-elody/csv.py,sha256=AsBOsJRC_9OsYDboqvtkMGDIvvhAgXAyMV_jPMCd-Bw,13245
+elody/csv.py,sha256=Ui9p3N-N9jQFvWTVecuUqqTfiN1HdpGmFGEqQK2g7OY,13215
 elody/error_codes.py,sha256=OBHvsKLRN5XU1Ro8Y5dwXWPE8zsiTBPwdoMPs-nL2Z4,3906
 elody/exceptions.py,sha256=5KSw2sPCZz3lDIJX4LiR2iL9n4m4KIil04D1d3X5rd0,968
 elody/job.py,sha256=QnN6Q45yqRimziqJX9SHrTVFVvky5mAc1WEza9ia8_w,2811
@@ -12,12 +12,12 @@ elody/validator.py,sha256=G7Ya538EJHCFzOxEri2OcFMabfLBCtTKxuf4os_KuNw,260
 elody/migration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/migration/base_object_migrator.py,sha256=n8uvgGfjEUy60G47RD7Y-oxp1vHLOauwPMDl87LcxtU,436
 elody/object_configurations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-elody/object_configurations/base_object_configuration.py,sha256=A54UJt9_K9KPpNK9AZ5FfLY_1IthGNyPW9y8y-xbI6c,5641
-elody/object_configurations/elody_configuration.py,sha256=P4wxLjBcvVHTcVaak8EgPIg2Rg_gVQkETkfspghvu4I,3522
-elody/object_configurations/job_configuration.py,sha256=RffbWIpA8gvf6SD3hcwR_GEXyUO15XIPFqre4QCPIqI,1805
+elody/object_configurations/base_object_configuration.py,sha256=L8K2AW-A3Bo4_Q_jl3S4hnwEGuZo3XmJH5Izditf6CM,6538
+elody/object_configurations/elody_configuration.py,sha256=Bp3OSHBHuyPs-ubIULzl9wqZd3akYD2idh3mhYo7zu0,5339
+elody/object_configurations/job_configuration.py,sha256=simi4TBiZ5cQePlzFHAd-C-khViWN9VUbAOKq9FYwk8,2057
 elody/policies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/policies/helpers.py,sha256=AV3wtvthJafW6ueEYGxggB5kk5knWTWzh3zq29Y1-ws,1434
-elody/policies/permission_handler.py,sha256=lsCAPBlpBUhL3z-AtV3xbwWqG9zv38Uar1C6ArcERmY,9085
+elody/policies/permission_handler.py,sha256=1aXA_xfRxdTfHZY5xRwQqJp5pjSzBrhko4eGRT38WLQ,9505
 elody/policies/tenant_id_resolver.py,sha256=BIl6lr9AH6Q_aZSsxF24B7ramkIZH-R-8bpLrTvYLtM,13796
 elody/policies/authentication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/policies/authentication/base_user_tenant_validation_policy.py,sha256=fxvrB4iG6fehBh6b4XS8AWewtNsCABgSooma5ljjZk4,5144
@@ -37,9 +37,9 @@ tests/__init_.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/data.py,sha256=Q3oxduf-E3m-Z5G_p3fcs8jVy6g10I7zXKL1m94UVMI,2906
 tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit/test_csv.py,sha256=NQaOhehfQ4GuXku0Y1SA8DYjJeqqidbF50zEHAi8RZA,15923
-tests/unit/test_utils.py,sha256=V-lKHaJH1Os1td6ZoubRU-5S2TOAepNsE3n-tO93ctQ,8781
-elody-0.0.156.dist-info/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
-elody-0.0.156.dist-info/METADATA,sha256=5zqAlM8G8rLhk78qvd55bkt9r-KojjxAZWazXe0tROw,23282
-elody-0.0.156.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-elody-0.0.156.dist-info/top_level.txt,sha256=E0mImupLj0KmtUUCXRYEoLDRaSkuiGaOIIseAa0oQ-M,21
-elody-0.0.156.dist-info/RECORD,,
+tests/unit/test_utils.py,sha256=g63szcEZyHhCOtrW4BnNbcgVca3oYPIOLjBdIzNwwN0,8784
+elody-0.0.158.dist-info/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+elody-0.0.158.dist-info/METADATA,sha256=aGFDMi4tnUeUA1bh3x1xuUgLQEHM5hSl240-xroWCng,23283
+elody-0.0.158.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+elody-0.0.158.dist-info/top_level.txt,sha256=E0mImupLj0KmtUUCXRYEoLDRaSkuiGaOIIseAa0oQ-M,21
+elody-0.0.158.dist-info/RECORD,,

tests/unit/test_utils.py

@@ -11,7 +11,7 @@ from elody.util import (
     mediafile_is_public,
     read_json_as_dict,
     parse_url_unfriendly_string,
-    CustomJSONEncoder
+    CustomJSONEncoder,
 )
 from data import mediafile1, mediafile2
 from datetime import datetime, timezone
@@ -24,12 +24,14 @@ def test_default_method_with_datetime():
     result = encoder.default(dt)
     assert result == "2023-10-01T12:00:00+00:00"
 
+
 def test_default_method_with_naive_datetime():
     encoder = CustomJSONEncoder()
     dt = datetime(2023, 10, 1, 12, 0, 0)
     result = encoder.default(dt)
     assert result == "2023-10-01T10:00:00+00:00"
 
+
 def test_encode_method_with_non_datetime():
     encoder = CustomJSONEncoder()
     obj = {"key": "value"}