Merge pull request #1128 from userlocalhost/feature/join_attr/expand_supported_types

Update background processing to support any OBJECT attribute types for join_attr

Author: hinashi

CHANGELOG.md

@@ -5,6 +5,9 @@
 ### Added
 
 ### Changed
+* Update background processing to support any OBJECT typed Attribute for join_attr
+  at the advacend serarch processing.
+  Contributed by @userlocalhost
 
 ### Fixed
 

entry/api_v2/views.py

@@ -1,4 +1,5 @@
 import re
+from copy import deepcopy
 from datetime import datetime, timedelta
 from typing import Optional
 
@@ -249,15 +250,30 @@ def _get_joined_resp(prev_results, join_attr):
                 if attr is None:
                     continue
 
-                if attr.type == AttrTypeValue["object"]:
+                if attr.type & AttrType.OBJECT:
                     # set hint Model ID
                     hint_entity_ids += [x.id for x in attr.referral.filter(is_active=True)]
 
                     # set Item name
                     attrinfo = result["attrs"][join_attr["name"]]
-                    if attrinfo["value"]["name"] not in item_names:
+
+                    if attr.type == AttrType.OBJECT and attrinfo["value"]["name"] not in item_names:
                         item_names.append(attrinfo["value"]["name"])
 
+                    if attr.type == AttrType.NAMED_OBJECT:
+                        for co_info in attrinfo["value"].values():
+                            if co_info["name"] not in item_names:
+                                item_names.append(co_info["name"])
+
+                    if attr.type == AttrType.ARRAY_OBJECT:
+                        for r in attrinfo["value"]:
+                            item_names.append(r["name"])
+
+                    if attr.type == AttrType.ARRAY_NAMED_OBJECT:
+                        for r in attrinfo["value"]:
+                            [co_info] = r.values()
+                            item_names.append(co_info["name"])
+
             # set parameters to filter joining search results
             hint_attrs = []
             for attrinfo in join_attr.get("attrinfo", []):
@@ -293,6 +309,26 @@ def _get_joined_resp(prev_results, join_attr):
 
         # === End of Function: _get_joined_resp() ===
 
+        def _get_ref_id_from_es_result(attrinfo):
+            if attrinfo["type"] == AttrType.OBJECT:
+                if attrinfo.get("value") is not None:
+                    return [attrinfo["value"].get("id")]
+
+            if attrinfo["type"] == AttrType.NAMED_OBJECT:
+                if attrinfo.get("value") is not None:
+                    [ref_info] = attrinfo["value"].values()
+                    return [ref_info.get("id")]
+
+            if attrinfo["type"] == AttrType.ARRAY_OBJECT:
+                return [x.get("id") for x in attrinfo["value"]]
+
+            if attrinfo["type"] == AttrType.ARRAY_NAMED_OBJECT:
+                return sum([[y["id"] for y in x.values()] for x in attrinfo["value"]], [])
+
+            return []
+
+        # === End of Function: _get_ref_id_from_es_result() ===
+
         if not has_referral:
             hint_referral = None
 
@@ -340,7 +376,6 @@ def _get_joined_resp(prev_results, join_attr):
             (will_filter_by_joined_attr, joined_resp) = _get_joined_resp(
                 resp["ret_values"], join_attr
             )
-
             # This is needed to set result as blank value
             blank_joining_info = {
                 "%s.%s" % (join_attr["name"], k["name"]): {
@@ -363,37 +398,39 @@ def _get_joined_resp(prev_results, join_attr):
 
             # this inserts result to previous search result
             new_ret_values = []
+            joined_ret_values = []
             for resp_result in resp["ret_values"]:
+                # joining search result to original one
                 ref_info = resp_result["attrs"].get(join_attr["name"])
-                if (
-                    # ignore no joined data
-                    ref_info is None
-                    or
-                    # ignore unexpected typed attributes
-                    ref_info["type"] != AttrType.OBJECT
-                    or
-                    # ignore when original result doesn't refer any item
-                    ref_info["value"].get("id") is None
-                ):
-                    # join EMPTY value
-                    resp_result["attrs"] |= blank_joining_info  # type: ignore
 
-                # joining search result to original one
-                ref_id = ref_info["value"].get("id") if "value" in ref_info is not None else None  # type: ignore
-                if ref_id and ref_id in joined_resp_info:  # type: ignore
-                    # join valid value
-                    resp_result["attrs"] |= joined_resp_info[ref_id]
+                # This get referral Item-ID from joined search result
+                ref_list = _get_ref_id_from_es_result(ref_info)
+                for ref_id in ref_list:
+                    if ref_id and ref_id in joined_resp_info:  # type: ignore
+                        # join valid value
+                        resp_result["attrs"] |= joined_resp_info[ref_id]
 
-                    # collect only the result that matches with keyword of joined_attr parameter
-                    new_ret_values.append(resp_result)
+                        # collect only the result that matches with keyword of joined_attr parameter
+                        copied_result = deepcopy(resp_result)
+                        new_ret_values.append(copied_result)
+                        joined_ret_values.append(copied_result)
 
-                else:
+                    else:
+                        # join EMPTY value
+                        resp_result["attrs"] |= blank_joining_info  # type: ignore
+                        joined_ret_values.append(deepcopy(resp_result))
+
+                if len(ref_list) == 0:
                     # join EMPTY value
                     resp_result["attrs"] |= blank_joining_info  # type: ignore
+                    joined_ret_values.append(deepcopy(resp_result))
 
             if will_filter_by_joined_attr:
                 resp["ret_values"] = new_ret_values
                 resp["ret_count"] = len(new_ret_values)
+            else:
+                resp["ret_values"] = joined_ret_values
+                resp["ret_count"] = len(joined_ret_values)
 
         # convert field values to fit entry retrieve API data type, as a workaround.
         # FIXME should be replaced with DRF serializer etc

entry/tests/test_api_v2.py

@@ -10,7 +10,6 @@
 from rest_framework import status
 from rest_framework.exceptions import ValidationError
 
-from airone.lib.elasticsearch import FilterKey
 from airone.lib.log import Logger
 from airone.lib.test import AironeViewTest
 from airone.lib.types import (
@@ -36,27 +35,9 @@
 from user.models import User
 
 
-class ViewTest(AironeViewTest):
-    def _create_user(
-        self,
-        name,
-        email="email",
-        is_superuser=False,
-        authenticate_type=User.AuthenticateType.AUTH_TYPE_LOCAL,
-    ):
-        user = User(
-            username=name,
-            email=email,
-            is_superuser=is_superuser,
-            authenticate_type=authenticate_type,
-        )
-        user.set_password(name)
-        user.save()
-
-        return user
-
+class BaseViewTest(AironeViewTest):
     def setUp(self):
-        super(ViewTest, self).setUp()
+        super(BaseViewTest, self).setUp()
 
         self.user: User = self.guest_login()
 
@@ -87,6 +68,26 @@ def setUp(self):
             }
         )
 
+
+class ViewTest(BaseViewTest):
+    def _create_user(
+        self,
+        name,
+        email="email",
+        is_superuser=False,
+        authenticate_type=User.AuthenticateType.AUTH_TYPE_LOCAL,
+    ):
+        user = User(
+            username=name,
+            email=email,
+            is_superuser=is_superuser,
+            authenticate_type=authenticate_type,
+        )
+        user.set_password(name)
+        user.save()
+
+        return user
+
     def test_retrieve_entry(self):
         entry: Entry = self.add_entry(
             self.user,
@@ -3155,189 +3156,6 @@ def test_advanced_search(self):
             },
         )
 
-    def test_advanced_search_with_join_attrs(self):
-        # create Items to be search by join_attrs parameter
-        ref_entries = [
-            self.add_entry(
-                self.user,
-                "RefEntry-%s" % i,
-                self.ref_entity,
-                values={
-                    "val": "hoge-%s" % i if i % 2 == 0 else "",
-                    "ref": self.ref_entry.id,
-                    "name": {"name": "abcd-%s" % i, "id": self.ref_entry.id},
-                },
-            )
-            for i in range(2)
-        ]
-
-        # create Items that are search by ordinary processing
-        for index, (val, ref_id) in enumerate(
-            [
-                ("foo", ref_entries[0].id),
-                ("bar", ref_entries[0].id),
-                ("baz", ref_entries[1].id),
-                ("qux", None),
-            ]
-        ):
-            self.add_entry(
-                self.user,
-                "Entry%s" % index,
-                self.entity,
-                values={
-                    "val": val,
-                    "ref": ref_id,
-                    "name": {"name": "fuga", "id": ref_id},
-                },
-            )
-
-        # send request to search Entries with join_attrs
-        params = {
-            "entities": [self.entity.id],
-            "attrinfo": [
-                {"name": "val"},
-                {"name": "ref"},
-                {"name": "name"},
-            ],
-            "join_attrs": [
-                {
-                    "name": "ref",
-                    "attrinfo": [
-                        {"name": "val"},
-                        {"name": "ref"},
-                        {"name": "name"},
-                    ],
-                },
-            ],
-        }
-        resp = self.client.post(
-            "/entry/api/v2/advanced_search/", json.dumps(params), "application/json"
-        )
-        self.assertEqual(resp.status_code, 200)
-
-        # prepare comparison data with returned result
-        REF_DATA = {"id": self.ref_entry.id, "name": self.ref_entry.name}
-        expected_results = [
-            (
-                "Entry0",
-                {
-                    "ref.val": {"as_string": "hoge-0"},
-                    "ref.ref": {"as_object": REF_DATA},
-                    "ref.name": {"as_named_object": {"name": "abcd-0", "object": REF_DATA}},
-                },
-            ),
-            (
-                "Entry1",
-                {
-                    "ref.val": {"as_string": "hoge-0"},
-                    "ref.ref": {"as_object": REF_DATA},
-                    "ref.name": {"as_named_object": {"name": "abcd-0", "object": REF_DATA}},
-                },
-            ),
-            (
-                "Entry2",
-                {
-                    "ref.val": {"as_string": ""},
-                    "ref.ref": {"as_object": REF_DATA},
-                    "ref.name": {"as_named_object": {"name": "abcd-1", "object": REF_DATA}},
-                },
-            ),
-            (
-                "Entry3",
-                {
-                    "ref.val": {"as_string": ""},
-                    "ref.ref": {"as_string": ""},
-                    "ref.name": {"as_string": ""},
-                },
-            ),
-        ]
-
-        # check returned processing has expected values
-        for index, result in enumerate(resp.json()["values"]):
-            (e_name, e_attrinfo) = expected_results[index]
-            self.assertEqual(result["entry"]["name"], e_name)
-
-            for attrname, attrvalue in e_attrinfo.items():
-                self.assertEqual(result["attrs"][attrname]["value"], attrvalue)
-
-        # This sends request with keyword in join_attrs parameter and
-        # confirms filter processing works with its filter parameter of attrinfo
-        params = {
-            "entities": [self.entity.id],
-            "attrinfo": [
-                {"name": "val", "keyword": "bar"},
-                {"name": "ref"},
-            ],
-            "join_attrs": [
-                {
-                    "name": "ref",
-                    "attrinfo": [
-                        {"name": "val", "keyword": "hoge-0"},
-                    ],
-                },
-            ],
-        }
-        resp = self.client.post(
-            "/entry/api/v2/advanced_search/", json.dumps(params), "application/json"
-        )
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual([x["entry"]["name"] for x in resp.json()["values"]], ["Entry1"])
-
-        # This sends request with join_attrs that have filter_key to get empty Items
-        params = {
-            "entities": [self.entity.id],
-            "attrinfo": [],
-            "join_attrs": [
-                {
-                    "name": "ref",
-                    "attrinfo": [
-                        {"name": "val", "filter_key": FilterKey.EMPTY},
-                    ],
-                },
-            ],
-        }
-        resp = self.client.post(
-            "/entry/api/v2/advanced_search/", json.dumps(params), "application/json"
-        )
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual([x["entry"]["name"] for x in resp.json()["values"]], ["Entry2"])
-        self.assertEqual(
-            [x["attrs"]["ref.val"]["value"] for x in resp.json()["values"]], [{"as_string": ""}]
-        )
-
-        # This sends request with join_attrs that have filter_key to get non-empty Items
-        params = {
-            "entities": [self.entity.id],
-            "attrinfo": [],
-            "join_attrs": [
-                {
-                    "name": "ref",
-                    "attrinfo": [
-                        {"name": "val", "filter_key": FilterKey.NON_EMPTY},
-                    ],
-                },
-            ],
-        }
-        resp = self.client.post(
-            "/entry/api/v2/advanced_search/", json.dumps(params), "application/json"
-        )
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual([x["entry"]["name"] for x in resp.json()["values"]], ["Entry0", "Entry1"])
-        self.assertEqual(
-            [x["attrs"]["ref.val"]["value"] for x in resp.json()["values"]],
-            [
-                {"as_string": "hoge-0"},
-                {"as_string": "hoge-0"},
-            ],
-        )
-
-    def test_advanced_search_with_join_attrs_that_have_filter_key1(self):
-        """
-        Test advanced_search APIv2 with join_attrs parameter that have
-        valid filter_key attribute.
-        """
-        pass
-
     def test_advanced_search_all_entities(self):
         params = {
             "entities": [],