elody 0.0.225__py3-none-any.whl → 0.0.227__py3-none-any.whl

elody/error_codes.py

@@ -76,7 +76,7 @@ class ErrorCode(Enum):
     INVALID_VALUE = ("5016", ["value", "options", "line_number"])
     ITEM_WITH_VALUE_FOR_KEY_NOT_FOUND = ("5017", ["key", "value", "line_number"])
     ITEM_WITH_VALUE_FOR_KEY_NOT_UNIQUE = ("5018", ["key", "value", "line_number"])
-    DUPLICATE_ENTRY_LINKED_ENTITIES = ("W5018", ["entity_type", "duplicate_entry"])
+    DUPLICATE_ENTRY_LINKED_ENTITIES = ("5018", ["entity_type", "duplicate_entry"])
 
     # Filter error codes
     NO_MATCHER_FOR_FILTER_REQUEST = ("6001", [])

elody/policies/authorization/filter_generic_objects_policy_v2.py

@@ -1,9 +1,9 @@
 import re as regex
 
 from copy import deepcopy
-from elody.policies.helpers import generate_filter_key_and_lookup_from_restricted_key
 from elody.policies.permission_handler import (
     get_permissions,
+    handle_item_overview_request,
     mask_protected_content_post_request_hook,
 )
 from flask import g, Request  # pyright: ignore
@@ -108,58 +108,11 @@ class PostRequestRules:
                 type_filter_values.remove(type_filter_value)
                 continue
 
-            restrictions_grouped_by_index = {}
             schemas = permissions["read"][type_filter_value]
-            for schema in schemas.keys():
-                restrictions = schemas[schema].get("object_restrictions", {})
-                for restricted_key, restricting_value in restrictions.items():
-                    index, restricted_key = restricted_key.split(":")
-                    restricted_key, lookup = (
-                        generate_filter_key_and_lookup_from_restricted_key(
-                            restricted_key
-                        )
-                    )
-                    key = f"{schema}|{restricted_key}"
-                    if group := restrictions_grouped_by_index.get(index):
-                        group["key"].append(key)
-                    else:
-                        restrictions_grouped_by_index.update(
-                            {
-                                index: {
-                                    "lookup": lookup,
-                                    "key": [key],
-                                    "value": restricting_value,
-                                }
-                            }
-                        )
-
-            # support false soft call read responses
-            for filter in filters:
-                key = filter.get("key", "")
-                if isinstance(key, list):
-                    key = ",".join(key)
-                for restriction in restrictions_grouped_by_index.values():
-                    if key not in ",".join(restriction["key"]):
-                        continue
-                    values = (
-                        filter["value"]
-                        if isinstance(filter["value"], list)
-                        else [filter["value"]]
-                    )
-                    for value in values:
-                        if value not in restriction["value"] and value not in ["", "*"]:
-                            return False
-
-            for restriction in restrictions_grouped_by_index.values():
-                user_context.access_restrictions.filters.append(  # pyright: ignore
-                    {
-                        "lookup": restriction["lookup"],
-                        "type": "selection",
-                        "key": restriction["key"],
-                        "value": restriction["value"],
-                        "match_exact": True,
-                    }
-                )
+            result = handle_item_overview_request(schemas, filters)
+            if not isinstance(result, list):
+                return result
+            user_context.access_restrictions.filters.extend(result)  # pyright: ignore
 
         if len(type_filter_values) == 0:
             return False

elody/policies/helpers.py

@@ -9,18 +9,18 @@ def generate_filter_key_and_lookup_from_restricted_key(key):
     if (keys := key.split("@", 1)) and len(keys) == 1:
         return key, {}
 
-    local_field = keys[0]
     document_type, key = keys[1].split("-", 1)
     collection = (
         get_object_configuration_mapper().get(document_type).crud()["collection"]
     )
+    local_field, lookup_prefix = parse_optional_filter_key(keys[0])
     lookup = {
         "from": collection,
         "local_field": local_field,
         "foreign_field": "identifiers",
         "as": f"__lookup.virtual_relations.{document_type}",
     }
-    return f"{lookup['as']}.{key}", lookup
+    return f"{lookup_prefix}{lookup['as']}.{key}", lookup
 
 
 def get_content(item, request, content):
@@ -62,3 +62,14 @@ def get_item(storage_manager, user_context_bag, view_args) -> dict:
     raise NotFound(
         f"{get_error_code(ErrorCode.ITEM_NOT_FOUND, get_read())} | id:{id} - Item with id {id} does not exist."
     )
+
+
+def parse_optional_filter_key(key):
+    prefix = ""
+    if key[0] == "!":
+        key = key[1:]
+        prefix += "!"
+    if key[0] == "?":
+        key = key[1:]
+        prefix += "?"
+    return key, prefix

elody/policies/permission_handler.py

@@ -2,11 +2,17 @@ import re as regex
 
 from copy import deepcopy
 from elody.error_codes import ErrorCode, get_error_code, get_read
-from elody.policies.helpers import get_flat_item_and_object_lists, get_item
+from elody.policies.helpers import (
+    generate_filter_key_and_lookup_from_restricted_key,
+    get_flat_item_and_object_lists,
+    get_item,
+)
 from elody.util import flatten_dict, interpret_flat_key
+from flask import g
 from inuits_policy_based_auth.contexts.user_context import UserContext
 from logging_elody.log import log  # pyright: ignore
 from storage.storagemanager import StorageManager  # pyright: ignore
+from werkzeug.exceptions import NotFound
 
 
 _permissions = {}
@@ -49,6 +55,109 @@ def __replace_permission_placeholders(data, placeholder_key, placeholder_value):
     return data
 
 
+def handle_item_overview_request(schemas, filters):
+    restrictions_grouped_by_index = __group_restrictions_by_index(schemas)
+    short_circuit = __short_circuit_item_overview_soft_call(
+        filters, restrictions_grouped_by_index
+    )
+    if short_circuit is not None:
+        return short_circuit
+    return __generate_restriction_filters(restrictions_grouped_by_index)
+
+
+def __group_restrictions_by_index(schemas):
+    restrictions_grouped_by_index = {}
+    for schema in schemas.keys():
+        restrictions = schemas[schema].get("object_restrictions", {})
+        for restricted_key, restricting_value in restrictions.items():
+            index, restricted_key = restricted_key.split(":")
+            restricted_key, lookup = generate_filter_key_and_lookup_from_restricted_key(
+                restricted_key
+            )
+            key = f"{schema}|{restricted_key}"
+            if group := restrictions_grouped_by_index.get(index):
+                group["key"].append(key)
+            else:
+                restrictions_grouped_by_index.update(
+                    {
+                        index: {
+                            "lookup": lookup,
+                            "key": [key],
+                            "value": restricting_value,
+                        }
+                    }
+                )
+    return restrictions_grouped_by_index
+
+
+def __short_circuit_item_overview_soft_call(filters, restrictions_grouped_by_index):
+    for filter in filters:
+        key = filter.get("key", "")
+        if isinstance(key, list):
+            key = ",".join(key)
+        for restriction in restrictions_grouped_by_index.values():
+            if key not in ",".join(restriction["key"]):
+                continue
+            values = (
+                filter["value"]
+                if isinstance(filter["value"], list)
+                else [filter["value"]]
+            )
+            for value in values:
+                if value not in restriction["value"] and value not in ["", "*"]:
+                    return False
+    return None
+
+
+def __generate_restriction_filters(restrictions_grouped_by_index):
+    filters = []
+    for restriction in restrictions_grouped_by_index.values():
+        try:
+            combined_restrictions = [
+                value for value in restriction["value"] if isinstance(value, list)
+            ][0]
+        except IndexError:
+            combined_restrictions = []
+
+        filter = {
+            "lookup": restriction["lookup"],
+            "type": "selection",
+            "key": restriction["key"],
+            "value": [
+                value for value in restriction["value"] if not isinstance(value, list)
+            ],
+            "match_exact": True,
+            "or": [],
+        }
+
+        for combined_restriction in combined_restrictions:
+            combination = []
+            for value, combinations in combined_restriction.items():
+                combination.append(
+                    {
+                        "type": "selection",
+                        "key": restriction["key"],
+                        "value": [value],
+                        "match_exact": True,
+                    }
+                )
+                for key, value in combinations.items():
+                    key = [f"{restriction['key'][0].split('|')[0]}|{key}"]
+                    combination.append(
+                        {
+                            "lookup": restriction["lookup"],
+                            "type": "selection",
+                            "key": key,
+                            "value": value,
+                            "match_exact": True,
+                        }
+                    )
+            filter["or"].append(combination)
+
+        filters.append(filter)
+    return filters
+
+
 def handle_single_item_request(
     user_context: UserContext,
     item,
@@ -232,20 +341,24 @@ def __is_allowed_to_crud_item_keys(
 def __item_value_in_values(
     flat_item, key, values: list, flat_request_body, user_context: UserContext
 ):
+    if __matches_combined_expected_values(
+        flat_item, key, values, flat_request_body, user_context
+    ):
+        return True
+
     negate_condition = False
     is_optional = False
-
+    key_of_relation = None
     if key[0] == "!":
         key = key[1:]
         negate_condition = True
     if key[0] == "?":
         key = key[1:]
         is_optional = True
-
-    key_of_relation = None
     if (keys := key.split("@", 1)) and len(keys) == 2:
         key = keys[0]
         key_of_relation = keys[1].split("-", 1)[1]
+
     try:
         item_value = flat_request_body.get(key, flat_item[key])
         if is_optional:
@@ -260,16 +373,49 @@ def __item_value_in_values(
         if key_of_relation:
             if isinstance(item_value, list):
                 item_value = item_value[0]
-            item = get_item(
-                StorageManager(),
-                user_context.bag,
-                {"type": keys[1].split("-", 1)[0], "id": item_value},
-            )
+            try:
+                item = get_item(
+                    StorageManager(),
+                    user_context.bag,
+                    {"type": keys[1].split("-", 1)[0], "id": item_value},
+                )
+            except NotFound as exception:
+                if g.get("dry_run") or is_optional:
+                    return True
+                raise exception
             flat_item, _ = get_flat_item_and_object_lists(item)
             return __item_value_in_values(
                 flat_item, key_of_relation, values, flat_request_body, user_context
             )
 
+    return __matches_expected_values(flat_item, item_value, values, negate_condition)
+
+
+def __matches_combined_expected_values(
+    flat_item, key, values, flat_request_body, user_context
+):
+    values_deepcopy = deepcopy(values)
+    for value_from_values in values_deepcopy:
+        if not isinstance(value_from_values, list):
+            continue
+        for combined_restriction in value_from_values:
+            for value, combinations in combined_restriction.items():
+                if __item_value_in_values(
+                    flat_item, key, [value], flat_request_body, user_context
+                ):
+                    for combination_key, value in combinations.items():
+                        if __item_value_in_values(
+                            flat_item,
+                            combination_key,
+                            value,
+                            flat_request_body,
+                            user_context,
+                        ):
+                            return True
+        values.remove(value_from_values)
+
+
+def __matches_expected_values(flat_item, item_value, values, negate_condition):
     expected_values = []
     for value in values:
         if flat_item_key_value := flat_item.get(value):

{elody-0.0.225.dist-info → elody-0.0.227.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elody
-Version: 0.0.225
+Version: 0.0.227
 Summary: elody SDK for Python
 Author-email: Inuits <developers@inuits.eu>
 License:                     GNU GENERAL PUBLIC LICENSE

{elody-0.0.225.dist-info → elody-0.0.227.dist-info}/RECORD

@@ -2,7 +2,7 @@ __init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/__init__.py,sha256=d0Q6Fn44e7wFfLabDOBxpcJ1DPKWlFunGYDUBmO-4hA,22
 elody/client.py,sha256=15SBfnLHJXXY5Vf5BnkWdjtvkH21E_AsWTzm2-zcbf0,8799
 elody/csv.py,sha256=f8HphE-KC2OqKFzV0HiifWBgMHb3g0EA_Y82o_6JEiE,16761
-elody/error_codes.py,sha256=_RkqOZodUlqHPIpZzD5AHuzTuxQPsOTMO4YxX3iSJ3w,4394
+elody/error_codes.py,sha256=127_NuFIdVYFkc3NiSrBSKGPv2ABjP4zwzffvwoahsU,4393
 elody/exceptions.py,sha256=5KSw2sPCZz3lDIJX4LiR2iL9n4m4KIil04D1d3X5rd0,968
 elody/job.py,sha256=EGfYozNxyx2iLC-j_L5XLzV3hUAOM9UIFuYzyqKpS1w,1908
 elody/loader.py,sha256=xm7BsuZB3VAETMKze4_JRWC3Kyejk-gGDL_wc9jZeio,5500
@@ -17,15 +17,15 @@ elody/object_configurations/elody_configuration.py,sha256=Bchwd1roBnrMDTdFkJUlUT
 elody/object_configurations/job_configuration.py,sha256=T6QI2wE-u7ZcNpYE5XjmrCzIJglyKUGJsifaTn0WGyg,7512
 elody/object_configurations/saved_search_configuration.py,sha256=ddOry4EqYOeEKRF7q2M_fHoqZv8DXpQjFq8VaZ7jhVI,732
 elody/policies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-elody/policies/helpers.py,sha256=0mlTd-hu2TKwVNH3ov4yCEV-P_f2k7XFJ7XYUtGTjXk,2239
-elody/policies/permission_handler.py,sha256=9vxiYjkPrnqIxWi8X9qoGwb09SQaZmQeF4f_9LSQRDs,10342
+elody/policies/helpers.py,sha256=G9B7IHO1h-dNtAPsRtmHN-wYat7F-1ryk32mcCetsgI,2505
+elody/policies/permission_handler.py,sha256=Ok5ojzwuLVe6H3wDusVeihSG2o4_HF9__1qlX01tdAU,15705
 elody/policies/authentication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/policies/authentication/base_user_tenant_validation_policy.py,sha256=p7draxPCqly1vy7vnJX-gpmRfDeyaTxt9Cf0YpH9PZI,5829
 elody/policies/authentication/multi_tenant_policy.py,sha256=g4ZYUQMmCjgLg09wj0-0lGKsJsRt7h4ppI25o1VdZHw,4039
 elody/policies/authentication/x_user_headers_policy.py,sha256=AoOZH7cbVI9X7JTWmbH3HdXV2UUf0NJpAiuSI0qnQCI,1350
 elody/policies/authorization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/policies/authorization/filter_generic_objects_policy.py,sha256=mF32moh8hRetBgG8vQW-rz4xjoRQD2yOxdI740SFSUo,6522
-elody/policies/authorization/filter_generic_objects_policy_v2.py,sha256=2IkESYMfne1bX1I8Yvn3yoNmlfn_Jm6zVlVBknoW1_c,6412
+elody/policies/authorization/filter_generic_objects_policy_v2.py,sha256=wEQTjXpJ1r5srnpl7Z-3PtEN0CsDUiQbOlVOWqJjUk0,4235
 elody/policies/authorization/generic_object_detail_policy.py,sha256=y6g1i3vdKMKY4xS4H2m0e1DRztrivMEomx6NkDqA0Pk,3672
 elody/policies/authorization/generic_object_mediafiles_policy.py,sha256=1-DMsV-FDkcrQCE4KL-SGlVHjTZSMPwYq1bWln2nXE4,2887
 elody/policies/authorization/generic_object_metadata_policy.py,sha256=0r_DrNBBi4Bh6lMOXB9VqHDtQ9WEVRONigGG2fBFzDw,2882
@@ -36,13 +36,13 @@ elody/policies/authorization/mediafile_derivatives_policy.py,sha256=OwNpbS8i7-Lz
 elody/policies/authorization/mediafile_download_policy.py,sha256=XMsKavBucmTh4W1kWOzpFWxJ_ZXgHVK1RS7JB4HjtQo,1979
 elody/policies/authorization/multi_tenant_policy.py,sha256=SA9H7SBjzuh8mY3gYN7pDG8TV7hdI3GEUtNeiZeNL3M,3164
 elody/policies/authorization/tenant_request_policy.py,sha256=dEgblwRAqwWVcE-O7Jn8hVL3OnwDlQhDEOcPlcElBrk,1185
-elody-0.0.225.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+elody-0.0.227.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
 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=g63szcEZyHhCOtrW4BnNbcgVca3oYPIOLjBdIzNwwN0,8784
-elody-0.0.225.dist-info/METADATA,sha256=clNua9X1ftnhm20euo7Pj1DqrmDCy6CR22AxRuS3Csc,23358
-elody-0.0.225.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-elody-0.0.225.dist-info/top_level.txt,sha256=E0mImupLj0KmtUUCXRYEoLDRaSkuiGaOIIseAa0oQ-M,21
-elody-0.0.225.dist-info/RECORD,,
+elody-0.0.227.dist-info/METADATA,sha256=2DMnYmhSe3FZdq7pD9IYNADfse8_TmcnTPTj0HKLoYI,23358
+elody-0.0.227.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+elody-0.0.227.dist-info/top_level.txt,sha256=E0mImupLj0KmtUUCXRYEoLDRaSkuiGaOIIseAa0oQ-M,21
+elody-0.0.227.dist-info/RECORD,,