Add a public filter to the kolibri-public's ChannelMetadata viewset (#5486)

taoerman · pre-commit-ci-lite[bot] · web-flow · commit 3918b3ac4410 · 2025-10-24T09:05:23.000-05:00
* Add a public filter to the kolibri-public's ChannelMetadata viewset

* [pre-commit.ci lite] apply automatic fixes

* fix test_channelmetadata_viewset.py

* [pre-commit.ci lite] apply automatic fixes

* fix code according to comments

* [pre-commit.ci lite] apply automatic fixes

* fix linting

* fix linting

* [pre-commit.ci lite] apply automatic fixes

---------

Co-authored-by: pre-commit-ci-lite[bot] &lt;117423508+pre-commit-ci-lite[bot]@users.noreply.github.com&gt;
diff --git a/contentcuration/kolibri_public/tests/test_channelmetadata_viewset.py b/contentcuration/kolibri_public/tests/test_channelmetadata_viewset.py
@@ -1,6 +1,5 @@
 from uuid import UUID
 
-from django.urls import reverse
 from kolibri_public.models import ChannelMetadata
 from kolibri_public.tests.utils.mixer import KolibriPublicMixer
 from le_utils.constants.labels.subjects import SUBJECTSLIST
@@ -19,12 +18,20 @@ def test_annotate_countries(self):
         country2 = mixer.blend(Country, code="C2")
         country3 = mixer.blend(Country, code="C3")
 
-        channel = mixer.blend(ChannelMetadata, countries=[country1, country2, country3])
+        channel = mixer.blend(
+            ChannelMetadata, countries=[country1, country2, country3], public=False
+        )
 
         user = testdata.user("any@user.com")
         self.client.force_authenticate(user)
 
-        response = self.client.get(reverse("publicchannel-detail", args=[channel.id]))
+        response = self.client.get(
+            reverse_with_query(
+                "publicchannel-detail",
+                args=[channel.id],
+                query={"public": "false"},
+            ),
+        )
 
         self.assertEqual(response.status_code, 200, response.content)
         self.assertCountEqual(response.data["countries"], ["C1", "C2", "C3"])
@@ -64,6 +71,7 @@ def setUp(self):
                 | self.category_bitmasks[3]
             ),
             countries=["C1", "C3"],
+            public=False,
         )
         self.metadata2 = mixer.blend(
             ChannelMetadata,
@@ -73,6 +81,7 @@ def setUp(self):
                 | self.category_bitmasks[3]
             ),
             countries=["C1", "C2", "C3"],
+            public=False,
         )
         self.metadata3 = mixer.blend(
             ChannelMetadata,
@@ -82,12 +91,16 @@ def setUp(self):
                 | self.category_bitmasks[2]
             ),
             countries=["C3"],
+            public=False,
         )
 
     def test_filter_by_categories_bitmask__provided(self):
         self.client.force_authenticate(self.user)
 
-        filter_query = {"categories": f"{self.categories[0]},{self.categories[1]}"}
+        filter_query = {
+            "categories": f"{self.categories[0]},{self.categories[1]}",
+            "public": "false",
+        }
 
         response = self.client.get(
             reverse_with_query(
@@ -105,7 +118,10 @@ def test_filter_by_categories_bitmask__not_provided(self):
         self.client.force_authenticate(self.user)
 
         response = self.client.get(
-            reverse("publicchannel-list"),
+            reverse_with_query(
+                "publicchannel-list",
+                query={"public": "false"},
+            ),
         )
         self.assertEqual(response.status_code, 200, response.content)
         self.assertCountEqual(
@@ -116,7 +132,7 @@ def test_filter_by_categories_bitmask__not_provided(self):
     def test_filter_by_countries(self):
         self.client.force_authenticate(self.user)
 
-        filter_query = {"countries": "C1,C2"}
+        filter_query = {"countries": "C1,C2", "public": "false"}
 
         response = self.client.get(
             reverse_with_query(
diff --git a/contentcuration/kolibri_public/tests/test_content_app.py b/contentcuration/kolibri_public/tests/test_content_app.py
@@ -500,6 +500,114 @@ def test_channelmetadata_has_exercises_filter(self):
             with_filter_response.data[0]["name"], self.channel_data["name"]
         )
 
+    def test_channelmetadata_public_filter_default_true(self):
+        community_channel = models.ContentNode.objects.create(
+            pk=uuid.uuid4().hex,
+            channel_id=uuid.uuid4().hex,
+            content_id=uuid.uuid4().hex,
+            kind="topic",
+            title="community channel",
+        )
+        models.ChannelMetadata.objects.create(
+            id=uuid.uuid4().hex,
+            name="community channel metadata",
+            root=community_channel,
+            # community channel
+            public=False,
+        )
+
+        # By default, only public channels should be returned
+        response = self.client.get(reverse("publicchannel-list"))
+        self.assertEqual(len(response.data), 1)
+        self.assertEqual(response.data[0]["name"], self.channel_data["name"])
+        self.assertTrue(response.data[0]["public"])
+
+    def test_channelmetadata_public_filter_explicit_true(self):
+        community_channel = models.ContentNode.objects.create(
+            pk=uuid.uuid4().hex,
+            channel_id=uuid.uuid4().hex,
+            content_id=uuid.uuid4().hex,
+            kind="topic",
+            title="community channel 2",
+        )
+        models.ChannelMetadata.objects.create(
+            id=uuid.uuid4().hex,
+            name="community channel metadata 2",
+            root=community_channel,
+            public=False,
+        )
+
+        # Explicitly request only public channels
+        response = self.client.get(reverse("publicchannel-list"), {"public": True})
+        self.assertEqual(len(response.data), 1)
+        self.assertEqual(response.data[0]["name"], self.channel_data["name"])
+        self.assertTrue(response.data[0]["public"])
+
+    def test_channelmetadata_public_filter_explicit_false(self):
+        community_channel = models.ContentNode.objects.create(
+            pk=uuid.uuid4().hex,
+            channel_id=uuid.uuid4().hex,
+            content_id=uuid.uuid4().hex,
+            kind="topic",
+            title="community channel 3",
+        )
+        community_metadata = models.ChannelMetadata.objects.create(
+            id=uuid.uuid4().hex,
+            name="community channel metadata 3",
+            root=community_channel,
+            public=False,
+        )
+
+        # Explicitly request only community channels
+        response = self.client.get(reverse("publicchannel-list"), {"public": False})
+        self.assertEqual(len(response.data), 1)
+        self.assertEqual(response.data[0]["name"], community_metadata.name)
+        self.assertFalse(response.data[0]["public"])
+
+    def test_channelmetadata_public_filter_mixed_channels(self):
+        community_channel1 = models.ContentNode.objects.create(
+            pk=uuid.uuid4().hex,
+            channel_id=uuid.uuid4().hex,
+            content_id=uuid.uuid4().hex,
+            kind="topic",
+            title="community channel 4",
+        )
+        models.ChannelMetadata.objects.create(
+            id=uuid.uuid4().hex,
+            name="community channel metadata 4",
+            root=community_channel1,
+            public=False,
+        )
+
+        community_channel2 = models.ContentNode.objects.create(
+            pk=uuid.uuid4().hex,
+            channel_id=uuid.uuid4().hex,
+            content_id=uuid.uuid4().hex,
+            kind="topic",
+            title="community channel 5",
+        )
+        models.ChannelMetadata.objects.create(
+            id=uuid.uuid4().hex,
+            name="community channel metadata 5",
+            root=community_channel2,
+            public=False,
+        )
+
+        # Test public filter
+        public_response = self.client.get(
+            reverse("publicchannel-list"), {"public": True}
+        )
+        self.assertEqual(len(public_response.data), 1)
+        self.assertTrue(public_response.data[0]["public"])
+
+        # Test community filter
+        community_response = self.client.get(
+            reverse("publicchannel-list"), {"public": False}
+        )
+        self.assertEqual(len(community_response.data), 2)
+        for channel in community_response.data:
+            self.assertFalse(channel["public"])
+
     def test_filtering_coach_content_anon(self):
         response = self.client.get(
             reverse("publiccontentnode-list"),
diff --git a/contentcuration/kolibri_public/views.py b/contentcuration/kolibri_public/views.py
@@ -100,14 +100,26 @@ class CharInFilter(BaseInFilter, CharFilter):
 
 
 class ChannelMetadataFilter(FilterSet):
+    def __init__(self, data=None, *args, **kwargs):
+        # if filterset is bound, use initial values as defaults
+        if data is not None:
+            data = data.copy()
+            for name, f in self.base_filters.items():
+                initial = f.extra.get("initial")
+                # filter param is either missing or empty, use initial as default
+                if not data.get(name) and initial:
+                    data[name] = initial
+        super().__init__(data, *args, **kwargs)
+
     available = BooleanFilter(method="filter_available", label="Available")
     has_exercise = BooleanFilter(method="filter_has_exercise", label="Has exercises")
     categories = CharFilter(method=bitmask_contains_and, label="Categories")
     countries = CharInFilter(field_name="countries", label="Countries")
+    public = BooleanFilter(field_name="public", label="Public", initial=True)
 
     class Meta:
         model = models.ChannelMetadata
-        fields = ("available", "has_exercise", "categories", "countries")
+        fields = ("available", "has_exercise", "categories", "countries", "public")
 
     def filter_has_exercise(self, queryset, name, value):
         queryset = queryset.annotate(
