elody 0.0.226__py3-none-any.whl → 0.0.228__py3-none-any.whl

elody/job.py

@@ -66,6 +66,12 @@ def finish_job(
     )
 
 
+def finish_job_with_warning(id, *, get_rabbit, info_message=None):
+    _config.crud()["finish_job_with_warning"](
+        id=id, get_rabbit=get_rabbit, info_message=info_message
+    )
+
+
 def soft_finish_job(
     id,
     *,

elody/object_configurations/job_configuration.py

@@ -193,7 +193,7 @@ class JobConfiguration(ElodyConfiguration):
             "id": id,
             "patch": {
                 "metadata": [
-                    {"key": "status", "value": Status.FINISHED.value},
+                    {"key": "status", "value": Status.WARNING.value},
                     {"key": "info", "value": info_message},
                 ],
             },

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/permission_handler.py

@@ -2,7 +2,11 @@ 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
@@ -51,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,
@@ -234,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:
@@ -277,6 +388,34 @@ def __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.226.dist-info → elody-0.0.228.dist-info}/METADATA

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

{elody-0.0.226.dist-info → elody-0.0.228.dist-info}/RECORD

@@ -4,7 +4,7 @@ elody/client.py,sha256=15SBfnLHJXXY5Vf5BnkWdjtvkH21E_AsWTzm2-zcbf0,8799
 elody/csv.py,sha256=f8HphE-KC2OqKFzV0HiifWBgMHb3g0EA_Y82o_6JEiE,16761
 elody/error_codes.py,sha256=127_NuFIdVYFkc3NiSrBSKGPv2ABjP4zwzffvwoahsU,4393
 elody/exceptions.py,sha256=5KSw2sPCZz3lDIJX4LiR2iL9n4m4KIil04D1d3X5rd0,968
-elody/job.py,sha256=EGfYozNxyx2iLC-j_L5XLzV3hUAOM9UIFuYzyqKpS1w,1908
+elody/job.py,sha256=q_rcVoC2bTQG9VlNzaG10l0m2k7zjT6PWj_PORzM6_M,2094
 elody/loader.py,sha256=xm7BsuZB3VAETMKze4_JRWC3Kyejk-gGDL_wc9jZeio,5500
 elody/schemas.py,sha256=WtKdZEAX-PtEuAaRohyS3Md8H4-8yKVXMkHfCQ2SDR4,4676
 elody/util.py,sha256=Qcoe49DsoJwXLFNevR67U_04iuJkmX4Pl0bcJ0Alrh0,9325
@@ -14,18 +14,18 @@ elody/migration/base_object_migrator.py,sha256=n8uvgGfjEUy60G47RD7Y-oxp1vHLOauwP
 elody/object_configurations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 elody/object_configurations/base_object_configuration.py,sha256=4lk6BmhRSYxwuD2qqGfE8d9H9ak7iwoOM5gqw7EntTI,7905
 elody/object_configurations/elody_configuration.py,sha256=Bchwd1roBnrMDTdFkJUlUTS_FkrzhAq2kVdphLCdu2M,10621
-elody/object_configurations/job_configuration.py,sha256=T6QI2wE-u7ZcNpYE5XjmrCzIJglyKUGJsifaTn0WGyg,7512
+elody/object_configurations/job_configuration.py,sha256=-wZi9bM3jEgyrfuBfMalrsMovb3_zx14rZFW3htGLPs,7511
 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=G9B7IHO1h-dNtAPsRtmHN-wYat7F-1ryk32mcCetsgI,2505
-elody/policies/permission_handler.py,sha256=9ZzSMoD9Qxkl9CGJoe-MPlxjKEEgPhtTfXuAQbgQfTc,10598
+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.226.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+elody-0.0.228.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.226.dist-info/METADATA,sha256=yu7c8AtqEMv0n9QVlcIQvRakIMvO2-F1Eyrf99MJuPE,23358
-elody-0.0.226.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-elody-0.0.226.dist-info/top_level.txt,sha256=E0mImupLj0KmtUUCXRYEoLDRaSkuiGaOIIseAa0oQ-M,21
-elody-0.0.226.dist-info/RECORD,,
+elody-0.0.228.dist-info/METADATA,sha256=pksqE3dsVyXDCBOkhxQo8AmV4-mP1ZKpdAelsEE7Ka0,23358
+elody-0.0.228.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+elody-0.0.228.dist-info/top_level.txt,sha256=E0mImupLj0KmtUUCXRYEoLDRaSkuiGaOIIseAa0oQ-M,21
+elody-0.0.228.dist-info/RECORD,,