[Fixes GeoNode#11853] Implement the Group facet API (GeoNode#11893)

* initial commit for group facet api
* query updated to include the number of resources of the groupprofile
* test case added for groupfacet
* updated test and group facet
* removed comments, updated testcase
* set param to users on views
* changed parameter to user=req.user from **kwargs
* black,flake8 code formatting
* removed logs set to warning, refactored groupfacet test
* Update .clabot
* updated test_count0 for multiple param
* changed resource counts caused by insertion of new resources
* removed creation of new resourses
* refactor of testcase and removal of hardcoded ids

Author: RegisSinjari

.clabot

@@ -75,6 +75,7 @@
     "EHJ-52n",
     "MartinPontius",
     "ahmdthr",
-    "fvicent"
+    "fvicent",
+    "RegisSinjari"
   ]
 }

geonode/facets/models.py

@@ -30,6 +30,7 @@
 FACET_TYPE_CATEGORY = "category"
 FACET_TYPE_BASE = "base"
 FACET_TYPE_KEYWORD = "keyword"
+FACET_TYPE_GROUP = "group"
 
 logger = logging.getLogger(__name__)
 

geonode/facets/providers/group.py

@@ -0,0 +1,106 @@
+#########################################################################
+#
+# Copyright (C) 2023 Open Source Geospatial Foundation - all rights reserved
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#########################################################################
+
+
+import logging
+
+from django.db.models import Count
+from geonode.facets.models import FacetProvider, DEFAULT_FACET_PAGE_SIZE, FACET_TYPE_GROUP
+from geonode.groups.models import GroupProfile
+from geonode.security.utils import get_user_visible_groups
+
+logger = logging.getLogger(__name__)
+
+
+class GroupFacetProvider(FacetProvider):
+    """
+    Implements faceting for resource's group
+    """
+
+    @property
+    def name(self) -> str:
+        return "group"
+
+    def get_info(self, lang="en", **kwargs) -> dict:
+        return {
+            "name": self.name,
+            "filter": "filter{group.in}",
+            "label": "Group",
+            "type": FACET_TYPE_GROUP,
+        }
+
+    def get_facet_items(
+        self,
+        queryset,
+        start: int = 0,
+        end: int = DEFAULT_FACET_PAGE_SIZE,
+        lang="en",
+        topic_contains: str = None,
+        keys: set = {},
+        **kwargs,
+    ) -> (int, list):
+        logger.debug("Retrieving facets for %s", self.name)
+
+        filters = dict()
+        if keys:
+            logger.debug("Filtering by keys %r", keys)
+            filters["group__id__in"] = keys
+
+        visible_groups = get_user_visible_groups(user=kwargs["user"])
+
+        q = (
+            queryset.values("group__name", "group__id")
+            .annotate(count=Count("group__id"))
+            .filter(**filters)
+            .filter(group__id__in=[group.group_id for group in visible_groups])
+            .order_by("-count")
+        )
+
+        logger.debug(" PREFILTERED QUERY  ---> %s\n\n", queryset.query)
+        logger.debug(" ADDITIONAL FILTERS ---> %s\n\n", filters)
+        logger.debug(" FINAL QUERY        ---> %s\n\n", q.query)
+
+        cnt = q.count()
+        logger.debug(f" q.count()  {q.count()}")
+        logger.info("Found %d facets for %s", cnt, self.name)
+        logger.debug(" ---> %s\n\n", q.query)
+        logger.debug(" ---> %r\n\n", q.all())
+
+        topics = [
+            {
+                "key": r["group__id"],
+                "label": r["group__name"],
+                "count": r["count"],
+            }
+            for r in q[start:end].all()
+        ]
+
+        return cnt, topics
+
+    def get_topics(self, keys: list, lang="en", **kwargs) -> list:
+        q = GroupProfile.objects.filter(group__id__in=keys)
+
+        logger.debug(" ---> %s\n\n", q.query)
+        logger.debug(" ---> %r\n\n", q.all())
+
+        return [{"key": r.group_id, "label": r.slug, "count": len(list(r.resources()))} for r in q.all()]
+
+    @classmethod
+    def register(cls, registry, **kwargs) -> None:
+        registry.register_facet_provider(GroupFacetProvider(**kwargs))

geonode/facets/tests.py

@@ -36,15 +36,17 @@
     Region,
     TopicCategory,
     HierarchicalKeyword,
+    GroupProfile,
 )
 from geonode.facets.models import facet_registry
 from geonode.facets.providers.baseinfo import FeaturedFacetProvider
 from geonode.facets.providers.category import CategoryFacetProvider
+from geonode.facets.providers.group import GroupFacetProvider
 from geonode.facets.providers.keyword import KeywordFacetProvider
 from geonode.facets.providers.region import RegionFacetProvider
 from geonode.facets.views import ListFacetsView, GetFacetView
 from geonode.tests.base import GeoNodeBaseTestSupport
-
+from django.contrib.auth.models import Group
 
 logger = logging.getLogger(__name__)
 
@@ -61,6 +63,7 @@ def setUpClass(cls):
         cls._create_regions()
         cls._create_categories()
         cls._create_keywords()
+        cls._create_groups()
         cls._create_resources()
         cls.rf = RequestFactory()
 
@@ -123,6 +126,17 @@ def _create_categories(cls):
         ):
             cls.cats[code] = TopicCategory.objects.create(identifier=code, description=name, gn_description=name)
 
+    @classmethod
+    def _create_groups(cls):
+        cls.group_admin = Group.objects.create(name="UserAdmin")
+        cls.group_common = Group.objects.create(name="UserCommon")
+        cls.group_profile_admin = GroupProfile.objects.create(
+            group_id=cls.group_admin, title="UserAdmin", slug="UserAdmin"
+        )
+        cls.group_profile_common = GroupProfile.objects.create(
+            group_id=cls.group_common, title="UserCommon", slug="UserCommon"
+        )
+
     @classmethod
     def _create_keywords(cls):
         cls.kw = {}
@@ -138,7 +152,6 @@ def _create_keywords(cls):
     @classmethod
     def _create_resources(self):
         public_perm_spec = {"users": {"AnonymousUser": ["view_resourcebase"]}, "groups": []}
-
         for x in range(20):
             d: ResourceBase = ResourceBase.objects.create(
                 title=f"dataset_{x:02}",
@@ -152,16 +165,16 @@ def _create_resources(self):
 
             # These are the assigned keywords to the Resources
 
-            # RB00 ->           T1K0      R0,R1    FEAT  K0      C0
-            # RB01 -> T0K0      T1K0      R0       FEAT    K1
-            # RB02 ->           T1K0         R1    FEAT      K2  C0
-            # RB03 -> T0K0      T1K0                     K0
-            # RB04 ->           T1K0                     K0K1    C0
-            # RB05 -> T0K0      T1K0                     K0  K2  C1
-            # RB06 ->           T1K0               FEAT
-            # RB07 -> T0K0      T1K0            R2 FEAT      K3  C3
-            # RB08 ->           T1K0 T1K1    R1,R2 FEAT      K3  C3
-            # RB09 -> T0K0      T1K0 T1K1       R2           K3  C3
+            # RB00 ->           T1K0      R0,R1    FEAT  K0      C0  group_admin
+            # RB01 -> T0K0      T1K0      R0       FEAT    K1        group_admin
+            # RB02 ->           T1K0         R1    FEAT      K2  C0  group_admin
+            # RB03 -> T0K0      T1K0                     K0          group_admin
+            # RB04 ->           T1K0                     K0K1    C0  group_admin
+            # RB05 -> T0K0      T1K0                     K0  K2  C1  group_admin
+            # RB06 ->           T1K0               FEAT              group_admin
+            # RB07 -> T0K0      T1K0            R2 FEAT      K3  C3  group_common
+            # RB08 ->           T1K0 T1K1    R1,R2 FEAT      K3  C3  group_common
+            # RB09 -> T0K0      T1K0 T1K1       R2           K3  C3  group_common
             # RB10 ->                T1K1       R2           K3  C3
             # RB11 -> T0K0 T0K1      T1K1
             # RB12 ->                T1K1          FEAT
@@ -173,6 +186,14 @@ def _create_resources(self):
             # RB18 ->                              FEAT          C2
             # RB19 -> T0K0 T0K1                    FEAT          C2
 
+            if x < 7:
+                logger.debug(f"ASSIGNING GROUP {self.group_admin.name} TO RB {d}")
+                d.group = self.group_admin
+
+            if 7 <= x < 10:
+                logger.debug(f"ASSIGNING GROUP {self.group_common.name} TO RB {d}")
+                d.group = self.group_common
+
             if x % 2 == 1:
                 logger.debug(f"ADDING KEYWORDS {self.thesauri_k['0_0']} to RB {d}")
                 d.tkeywords.add(self.thesauri_k["0_0"])
@@ -227,9 +248,9 @@ def test_facets_base(self):
         obj = json.loads(res.content)
         self.assertIn("facets", obj)
         facets_list = obj["facets"]
-        self.assertEqual(8, len(facets_list))
+        self.assertEqual(9, len(facets_list))
         fmap = self._facets_to_map(facets_list)
-        for name in ("category", "owner", "t_0", "t_1", "featured", "resourcetype", "keyword"):
+        for name in ("group", "category", "owner", "t_0", "t_1", "featured", "resourcetype", "keyword"):
             self.assertIn(name, fmap)
 
     def test_facets_rich(self):
@@ -247,7 +268,7 @@ def test_facets_rich(self):
         obj = json.loads(res.content)
 
         facets_list = obj["facets"]
-        self.assertEqual(8, len(facets_list))
+        self.assertEqual(9, len(facets_list))
         fmap = self._facets_to_map(facets_list)
         for expected in (  # fmt: skip
             {
@@ -496,6 +517,12 @@ def test_count0(self):
         kwflt = kwinfo["filter"]
         kwname = kwinfo["name"]
 
+        groupinfo = GroupFacetProvider().get_info()
+        grflt = groupinfo["filter"]
+        grname = groupinfo["name"]
+        g_admin_id = self.group_admin.id
+        g_comm_id = self.group_common.id
+
         t0flt = facet_registry.get_provider("t_0").get_info()["filter"]
         t1flt = facet_registry.get_provider("t_1").get_info()["filter"]
 
@@ -525,6 +552,13 @@ def t(tk):
             (regname, {t1flt: [t("1_1"), t("1_0")]}, {"R0": 2, "R1": 3, "R2": 4}),
             (regname, {t1flt: t("1_1"), "key": ["R0", "R1"]}, {"R1": 1, "R0": None}),
             (regname, {t1flt: t("1_1"), "key": ["R0"]}, {"R0": None}),
+            # groups
+            (grname, {grflt: [g_admin_id, g_comm_id], "key": [g_admin_id, g_comm_id]}, {g_admin_id: 7, g_comm_id: 3}),
+            (grname, {grflt: [g_admin_id], "key": [g_admin_id]}, {g_admin_id: 7}),
+            (grname, {catflt: ["C0"], grflt: [g_comm_id]}, {}),
+            (grname, {catflt: ["C1"], grflt: [g_admin_id]}, {g_admin_id: 1}),
+            (grname, {catflt: ["C0"], grflt: [g_admin_id]}, {g_admin_id: 3}),
+            (grname, {catflt: ["C0", "C1"], grflt: [g_admin_id, g_comm_id]}, {g_admin_id: 4}),
             # category
             (catname, {t1flt: t("1_0")}, {"C0": 3, "C1": 1, "C3": 3}),
             (catname, {t1flt: t("1_0"), "key": ["C0", "C2"]}, {"C0": 3, "C2": None}),
@@ -564,4 +598,74 @@ def test_thesauri_reloading(self):
         # Thesauri facets are cached.
         # Make sure that when Thesauri or ThesauriLabel change the facets cache is invalidated
         # TODO impl+test
+
         pass
+
+    def test_group_facet_api_call(self):
+        resource_count_admin = 7
+        resource_count_common = 3
+
+        expected_response_base = {
+            "name": "group",
+            "filter": "filter{group.in}",
+            "label": "Group",
+            "type": "group",
+            "topics": {
+                "page": 0,
+                "page_size": 10,
+                "start": 0,
+                "total": 2,
+                "items": [
+                    {
+                        "key": self.group_profile_admin.group_id,
+                        "label": self.group_profile_admin.slug,
+                        "count": resource_count_admin,
+                    },
+                    {
+                        "key": self.group_profile_common.group_id,
+                        "label": self.group_profile_common.slug,
+                        "count": resource_count_common,
+                    },
+                ],
+            },
+        }
+        expected_response_filtered = {
+            "name": "group",
+            "filter": "filter{group.in}",
+            "label": "Group",
+            "type": "group",
+            "topics": {
+                "page": 0,
+                "page_size": 10,
+                "start": 0,
+                "total": 1,
+                "items": [
+                    {
+                        "key": self.group_profile_admin.group_id,
+                        "label": self.group_profile_admin.slug,
+                        "count": resource_count_admin,
+                    }
+                ],
+            },
+        }
+
+        url_filtered = f"{reverse('get_facet',args=['group'])}?filter{{group.in}}={self.group_admin.id}&include_topics=true&key={self.group_admin.id}"
+        url_base = f"{reverse('get_facet',args=['group'])}"
+
+        response_filtered = self.client.get(url_filtered)
+        response_dict_filtered = response_filtered.json()
+
+        response_base = self.client.get(url_base)
+        response_dict_base = response_base.json()
+
+        self.assertEqual(
+            response_filtered.status_code,
+            200,
+            "Unexpected status code, got %s expected 200" % (response_filtered.status_code),
+        )
+        self.assertEqual(
+            response_base.status_code, 200, "Unexpected status code, got %s expected 200" % (response_base.status_code)
+        )
+
+        self.assertDictEqual(expected_response_filtered, response_dict_filtered)
+        self.assertDictEqual(expected_response_base, response_dict_base)

geonode/facets/views.py

@@ -62,7 +62,7 @@ def _get_topics(
         end = start + page_size
 
         cnt, items = provider.get_facet_items(
-            queryset, start=start, end=end, lang=lang, topic_contains=topic_contains, keys=keys
+            queryset, start=start, end=end, lang=lang, topic_contains=topic_contains, keys=keys, **kwargs
         )
 
         if keys:
@@ -86,7 +86,7 @@ def _prefilter_topics(cls, request):
         """
         logger.debug("Filtering by user '%s'", request.user)
         filters = {k: vlist for k, vlist in request.query_params.lists() if k.startswith("filter{")}
-        logger.warning(f"FILTERING BY {filters}")
+        logger.warning(f"FILTERING BY  {filters}")
 
         if filters:
             viewset = ResourceBaseViewSet(request=request, format_kwarg={}, kwargs=filters)
@@ -153,7 +153,7 @@ def get(self, request, *args, **kwargs):
 
             if include_topics:
                 prefiltered = prefiltered or self._prefilter_topics(request)
-                info["topics"] = self._get_topics(provider, queryset=prefiltered, lang=lang)
+                info["topics"] = self._get_topics(provider, queryset=prefiltered, lang=lang, user=request.user)
 
             facets.append(info)
 
@@ -187,7 +187,14 @@ def get(self, request, facet):
 
         qs = self._prefilter_topics(request)
         topics = self._get_topics(
-            provider, queryset=qs, page=page, page_size=page_size, lang=lang, topic_contains=topic_contains, keys=keys
+            provider,
+            queryset=qs,
+            page=page,
+            page_size=page_size,
+            lang=lang,
+            topic_contains=topic_contains,
+            keys=keys,
+            user=request.user,
         )
 
         if add_link:

geonode/settings.py

@@ -2343,6 +2343,7 @@ def get_geonode_catalogue_service():
     {"class": "geonode.facets.providers.keyword.KeywordFacetProvider", "config": {"order": 6, "type": "select"}},
     {"class": "geonode.facets.providers.region.RegionFacetProvider", "config": {"order": 7, "type": "select"}},
     {"class": "geonode.facets.providers.users.OwnerFacetProvider", "config": {"order": 8, "type": "select"}},
+    {"class": "geonode.facets.providers.group.GroupFacetProvider", "config": {"order": 9, "type": "select"}},
     {"class": "geonode.facets.providers.thesaurus.ThesaurusFacetProvider", "config": {"type": "select"}},
 ]