Merge pull request #1106 from userlocalhost/feature/advanced_search/join_attrs

Added new feature that user can get referred Item's contents that an Item of advanced search result refers to from advanced search result page.

Author: hinashi

CHANGELOG.md

@@ -3,6 +3,9 @@
 ## In development
 
 ### Added
+* Added new feature that user can get referred Item's contents that an Item
+  of advanced search result refers to from advanced search result page.
+  Contributed by @userlocalhost, @hinashi
 
 ### Changed
 

apiclient/typescript-fetch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dmm-com/airone-apiclient-typescript-fetch",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "AirOne APIv2 client in TypeScript",
   "main": "src/autogenerated/index.ts",
   "scripts": {

entity/api_v2/serializers.py

@@ -194,7 +194,7 @@ class EntityAttrSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = EntityAttr
-        fields = ("id", "name", "type")
+        fields = ("id", "name", "type", "referral")
 
 
 class EntitySerializer(serializers.ModelSerializer):
@@ -649,4 +649,4 @@ def _do_import(resource, iter_data: Any):
 
 
 class EntityAttrNameSerializer(serializers.ListSerializer):
-    child = serializers.CharField()
+    child = EntityAttrSerializer()

entity/api_v2/views.py

@@ -1,4 +1,5 @@
 from distutils.util import strtobool
+from typing import Dict, List
 
 from django.db.models import Count, F
 from django.http import Http404
@@ -271,29 +272,35 @@ def get_queryset(self):
         entity_ids = list(filter(None, self.request.query_params.get("entity_ids", "").split(",")))
 
         if len(entity_ids) == 0:
-            return (
-                EntityAttr.objects.filter(is_active=True)
-                .values_list("name", flat=True)
-                .order_by("name")
-                .distinct()
-            )
+            return EntityAttr.objects.filter(is_active=True)
+
         else:
             entities = Entity.objects.filter(id__in=entity_ids, is_active=True)
             if len(entity_ids) != len(entities):
                 # the case invalid entity-id was specified
                 raise ValidationError("Target Entity doesn't exist")
             else:
-                return (
-                    # filter only names appear in all specified entities
-                    EntityAttr.objects.filter(parent_entity__in=entities, is_active=True)
-                    .values("name")
-                    .annotate(count=Count("name"))
-                    .filter(count=len(entity_ids))
-                    .values_list("name", flat=True)
-                    .order_by("name")
-                )
+                # filter only names appear in all specified entities
+                return EntityAttr.objects.filter(parent_entity__in=entities, is_active=True)
 
     def get(self, request: Request) -> Response:
         queryset = self.get_queryset()
+
+        entity_ids: List[int] = list(
+            filter(None, self.request.query_params.get("entity_ids", "").split(","))
+        )
+        names_query = queryset.values("name")
+        if len(entity_ids) > 0:
+            names_query = names_query.annotate(count=Count("name")).filter(count=len(entity_ids))
+
+        # Compile each attribute of referrals by attribute name
         serializer: Serializer = self.get_serializer(queryset)
-        return Response(serializer.data)
+        results: Dict[str, Dict] = {}
+        for attrname in names_query.values_list("name", flat=True):
+            for attrinfo in [x for x in serializer.data if x["name"] == attrname]:
+                if attrname in results:
+                    results[attrname]["referral"] += attrinfo["referral"]
+                else:
+                    results[attrname] = attrinfo
+
+        return Response(results.values())

entity/tests/test_api_v2.py

@@ -13,7 +13,7 @@
 from airone.lib import types as atype
 from airone.lib.log import Logger
 from airone.lib.test import AironeViewTest
-from airone.lib.types import AttrTypeArrStr, AttrTypeStr, AttrTypeText, AttrTypeValue
+from airone.lib.types import AttrType, AttrTypeArrStr, AttrTypeStr, AttrTypeText, AttrTypeValue
 from entity import tasks
 from entity.models import Entity, EntityAttr
 from entry.models import Entry
@@ -3465,18 +3465,23 @@ def test_get_entity_attr_names(self):
             "test_entity1": ["foo", "bar", "fuga"],
             "test_entity2": ["bar", "hoge", "fuga"],
         }
-        for entity_name, attrnames in entity_info.items():
+        for i, (entity_name, attrnames) in enumerate(entity_info.items()):
             entity = Entity.objects.create(name=entity_name, created_user=user)
 
-            for attrname in attrnames:
-                entity.attrs.add(
-                    EntityAttr.objects.create(
-                        name=attrname,
-                        type=AttrTypeValue["string"],
-                        created_user=user,
-                        parent_entity=entity,
-                    )
+            for j, attrname in enumerate(attrnames):
+                is_object = attrname == "bar"
+                attrtype = AttrType.OBJECT if is_object else AttrType.STRING
+
+                attr = EntityAttr.objects.create(
+                    name=attrname,
+                    type=attrtype.value,
+                    created_user=user,
+                    parent_entity=entity,
                 )
+                if is_object:
+                    attr.referral.add(entity)
+
+                entity.attrs.add(attr)
 
         self.ref_entity.delete()
         self.entity.attrs.all().delete()
@@ -3488,12 +3493,16 @@ def test_get_entity_attr_names(self):
             "/entity/api/v2/attrs?entity_ids=%s" % ",".join([str(x.id) for x in entities])
         )
         self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.json(), sorted(["bar", "fuga"]))
+        self.assertEqual([x["name"] for x in resp.json()], sorted(["bar", "fuga"]))
+        self.assertEqual(
+            [x["referral"] for x in resp.json() if x["type"] == AttrType.OBJECT.value][0],
+            list(entities.values_list("id", flat=True)),
+        )
 
-        # get all
+        # get all attribute infomations are returned collectly
         resp = self.client.get("/entity/api/v2/attrs")
         self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.json(), sorted(["foo", "bar", "hoge", "fuga"]))
+        self.assertEqual([x["name"] for x in resp.json()], ["foo", "bar", "fuga", "hoge"])
 
         # invalid entity_id(s)
         resp = self.client.get("/entity/api/v2/attrs?entity_ids=9999")

entry/api_v2/serializers.py

@@ -1100,10 +1100,17 @@ def validate_filter_key(self, filter_key: int):
         return filter_key
 
 
+class AdvancedSearchJoinAttrInfoSerializer(serializers.Serializer):
+    name = serializers.CharField()
+    offset = serializers.IntegerField(default=0)
+    attrinfo = AdvancedSearchResultAttrInfoSerializer(many=True)
+
+
 class AdvancedSearchSerializer(serializers.Serializer):
     entities = serializers.ListField(child=serializers.IntegerField())
     entry_name = serializers.CharField(allow_blank=True, default="")
     attrinfo = AdvancedSearchResultAttrInfoSerializer(many=True)
+    join_attrs = AdvancedSearchJoinAttrInfoSerializer(many=True, required=False)
     has_referral = serializers.BooleanField(default=False)
     referral_name = serializers.CharField(required=False, allow_blank=True)
     is_output_all = serializers.BooleanField(default=True)

entry/api_v2/views.py

@@ -22,7 +22,7 @@
     RequiredParameterError,
     YAMLParser,
 )
-from airone.lib.types import AttrTypeValue
+from airone.lib.types import AttrType, AttrTypeValue
 from entity.models import Entity, EntityAttr
 from entry.api_v2.pagination import EntryReferralPagination
 from entry.api_v2.serializers import (
@@ -229,6 +229,69 @@ def post(self, request: Request) -> Response:
         is_all_entities = serializer.validated_data["is_all_entities"]
         entry_limit = serializer.validated_data["entry_limit"]
         entry_offset = serializer.validated_data["entry_offset"]
+        join_attrs = serializer.validated_data.get("join_attrs", [])
+
+        def _get_joined_resp(prev_results, join_attr):
+            """
+            This is a helper method for join_attrs that will get specified attr values
+            that prev_result's ones refer to.
+            """
+            # set hint_entity_ids for joining Items search and get item names
+            # that specified attribute refers
+            item_names = []
+            hint_entity_ids = []
+            for result in prev_results:
+                entity = Entity.objects.filter(id=result["entity"]["id"]).last()
+                if entity is None:
+                    continue
+
+                attr = entity.attrs.filter(name=join_attr["name"], is_active=True).last()
+                if attr is None:
+                    continue
+
+                if attr.type == AttrTypeValue["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:
+                        item_names.append(attrinfo["value"]["name"])
+
+            # set parameters to filter joining search results
+            hint_attrs = []
+            for attrinfo in join_attr.get("attrinfo", []):
+                hint_attrs.append(
+                    {
+                        "name": attrinfo["name"],
+                        "keyword": attrinfo.get("keyword"),
+                        "filter_key": attrinfo.get("filter_key"),
+                    }
+                )
+
+            # search Items from elasticsearch to join
+            return (
+                # This represents whether user want to narrow down results by keyword of joined attr
+                any(
+                    [
+                        x.get("keyword") or x.get("filter_key", 0) > 0
+                        for x in join_attr.get("attrinfo", [])
+                    ]
+                ),
+                Entry.search_entries(
+                    request.user,
+                    hint_entity_ids=list(set(hint_entity_ids)),  # this removes depulicated IDs
+                    hint_attrs=hint_attrs,
+                    limit=entry_limit,
+                    entry_name="|".join(item_names),
+                    hint_referral=None,
+                    is_output_all=is_output_all,
+                    hint_referral_entity_id=None,
+                    offset=join_attr.get("offset", 0),
+                ),
+            )
+
+        # === End of Function: _get_joined_resp() ===
 
         if not has_referral:
             hint_referral = None
@@ -273,6 +336,65 @@ def post(self, request: Request) -> Response:
             offset=entry_offset,
         )
 
+        for join_attr in join_attrs:
+            (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"]): {
+                    "is_readable": True,
+                    "type": AttrType.STRING.value,
+                    "value": "",
+                }
+                for k in join_attr["attrinfo"]
+            }
+
+            # convert search result to dict to be able to handle it without loop
+            joined_resp_info = {
+                x["entry"]["id"]: {
+                    "%s.%s" % (join_attr["name"], k): v
+                    for k, v in x["attrs"].items()
+                    if any(_x["name"] == k for _x in join_attr["attrinfo"])
+                }
+                for x in joined_resp["ret_values"]
+            }
+
+            # this inserts result to previous search result
+            new_ret_values = []
+            for resp_result in resp["ret_values"]:
+                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.value
+                    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]
+
+                    # collect only the result that matches with keyword of joined_attr parameter
+                    new_ret_values.append(resp_result)
+
+                else:
+                    # join EMPTY value
+                    resp_result["attrs"] |= blank_joining_info  # type: ignore
+
+            if will_filter_by_joined_attr:
+                resp["ret_values"] = new_ret_values
+                resp["ret_count"] = len(new_ret_values)
+
         # convert field values to fit entry retrieve API data type, as a workaround.
         # FIXME should be replaced with DRF serializer etc
         for entry in resp["ret_values"]: