Merge pull request #5292 from Jakoma02/adminchannelviewset-submission-fields

Community library submission fields and filters in AdminChannelViewSet

Author: AlexVelezLl

contentcuration/contentcuration/tests/helpers.py

@@ -1,7 +1,9 @@
 from importlib import import_module
+from urllib.parse import urlencode
 
 import mock
 from celery import states
+from django.urls import reverse
 from django_celery_results.models import TaskResult
 from search.models import ContentNodeFullTextSearch
 
@@ -53,3 +55,19 @@ def __new__(cls, *args, **kwargs):
             return mock.Mock(spec_set=cls)
 
     return MockClass()
+
+
+def reverse_with_query(
+    viewname, urlconf=None, args=None, kwargs=None, current_app=None, query=None
+):
+    """
+    This helper wraps the Django `reverse` function to support the `query` argument.
+    This argument is supported natively since Django 5.2, so when Django is updated
+    above this version, this helper can be removed.
+    """
+    url = reverse(
+        viewname, urlconf=urlconf, args=args, kwargs=kwargs, current_app=current_app
+    )
+    if query:
+        return f"{url}?{urlencode(query)}"
+    return url

contentcuration/contentcuration/tests/viewsets/test_channel.py

@@ -19,6 +19,7 @@
 from contentcuration.tasks import apply_channel_changes_task
 from contentcuration.tests import testdata
 from contentcuration.tests.base import StudioAPITestCase
+from contentcuration.tests.helpers import reverse_with_query
 from contentcuration.tests.viewsets.base import generate_create_event
 from contentcuration.tests.viewsets.base import generate_delete_event
 from contentcuration.tests.viewsets.base import generate_deploy_channel_event
@@ -673,6 +674,168 @@ def test_fetch_admin_channels_invalid_filter(self):
         )
         self.assertEqual(response.status_code, 200, response.content)
 
+    def test_admin_channel_detail__latest_community_library_submission__exists(self):
+        older_submission = testdata.community_library_submission()
+        older_submission.channel.version = 2
+        older_submission.channel_version = 1
+        older_submission.status = community_library_submission.STATUS_LIVE
+        older_submission.channel.save()
+        older_submission.save()
+
+        latest_submission = CommunityLibrarySubmission.objects.create(
+            channel=older_submission.channel,
+            channel_version=2,
+            author=older_submission.author,
+        )
+
+        self.client.force_authenticate(self.admin_user)
+        response = self.client.get(
+            reverse(
+                "admin-channels-detail", kwargs={"pk": older_submission.channel.id}
+            ),
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertEqual(
+            response.data["latest_community_library_submission_id"],
+            latest_submission.id,
+        )
+        self.assertEqual(
+            response.data["latest_community_library_submission_status"],
+            community_library_submission.STATUS_PENDING,
+        )
+        self.assertTrue(response.data["has_any_live_community_library_submission"])
+
+    def test_admin_channel_detail__latest_community_library_submission__none_exist(
+        self,
+    ):
+        channel = testdata.channel()
+
+        self.client.force_authenticate(self.admin_user)
+        response = self.client.get(
+            reverse("admin-channels-detail", kwargs={"pk": channel.id}),
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertIsNone(response.data["latest_community_library_submission_id"])
+        self.assertIsNone(response.data["latest_community_library_submission_status"])
+        self.assertFalse(response.data["has_any_live_community_library_submission"])
+
+    def test_admin_channel_filter__latest_community_library_submission_status__any(
+        self,
+    ):
+        self.client.force_authenticate(user=self.admin_user)
+
+        submission = testdata.community_library_submission()
+
+        response = self.client.get(
+            reverse_with_query(
+                "admin-channels-list",
+                query={
+                    "id__in": submission.channel.id,
+                },
+            ),
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertEqual(len(response.data), 1)
+
+    def test_admin_channel_filter__latest_community_library_submission_status__multiple(
+        self,
+    ):
+        self.client.force_authenticate(user=self.admin_user)
+
+        submission1 = testdata.community_library_submission()
+        submission1.status = community_library_submission.STATUS_LIVE
+        submission1.save()
+
+        submission2 = testdata.community_library_submission()
+        submission2.status = community_library_submission.STATUS_PENDING
+        submission2.save()
+
+        submission3 = testdata.community_library_submission()
+        submission3.status = community_library_submission.STATUS_APPROVED
+        submission3.save()
+
+        response = self.client.get(
+            reverse_with_query(
+                "admin-channels-list",
+                query=[
+                    (
+                        "latest_community_library_submission_status",
+                        community_library_submission.STATUS_LIVE,
+                    ),
+                    (
+                        "latest_community_library_submission_status",
+                        community_library_submission.STATUS_PENDING,
+                    ),
+                ],
+            ),
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertCountEqual(
+            [ch["id"] for ch in response.data],
+            [
+                submission1.channel.id,
+                submission2.channel.id,
+            ],
+        )
+
+    def test_admin_channel_filter__community_library_live(self):
+        self.client.force_authenticate(user=self.admin_user)
+
+        submission1 = testdata.community_library_submission()
+        submission1.channel.version = 2
+        submission1.channel.save()
+        submission1.status = community_library_submission.STATUS_LIVE
+        submission1.channel_version = 1
+        submission1.save()
+
+        CommunityLibrarySubmission.objects.create(
+            channel=submission1.channel,
+            channel_version=2,
+            author=submission1.author,
+            status=community_library_submission.STATUS_PENDING,
+        )
+
+        other_channel_submission = testdata.community_library_submission()
+        other_channel_submission.status = community_library_submission.STATUS_PENDING
+        other_channel_submission.save()
+
+        response = self.client.get(
+            reverse_with_query(
+                "admin-channels-list",
+                query={"community_library_live": True},
+            ),
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertCountEqual(
+            [ch["id"] for ch in response.data],
+            [submission1.channel.id],
+        )
+
+    def test_admin_channel_filter__has_community_library_submission(self):
+        self.client.force_authenticate(user=self.admin_user)
+
+        submission = testdata.community_library_submission()
+
+        testdata.channel()  # Another channel without submission
+
+        response = self.client.get(
+            reverse_with_query(
+                "admin-channels-list",
+                query={"has_community_library_submission": True},
+            ),
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertCountEqual(
+            [ch["id"] for ch in response.data],
+            [submission.channel.id],
+        )
+
     def test_create_channel(self):
         user = testdata.user()
         self.client.force_authenticate(user=user)

contentcuration/contentcuration/tests/viewsets/test_community_library_submission.py

@@ -1,6 +1,5 @@
 import datetime
 from unittest import mock
-from urllib.parse import urlencode
 
 import pytz
 from django.urls import reverse
@@ -12,25 +11,10 @@
 from contentcuration.models import CommunityLibrarySubmission
 from contentcuration.tests import testdata
 from contentcuration.tests.base import StudioAPITestCase
+from contentcuration.tests.helpers import reverse_with_query
 from contentcuration.viewsets.sync.constants import ADDED_TO_COMMUNITY_LIBRARY
 
 
-def reverse_with_query(
-    viewname, urlconf=None, args=None, kwargs=None, current_app=None, query=None
-):
-    """
-    This helper wraps the Django `reverse` function to support the `query` argument.
-    This argument is supported natively since Django 5.2, so when Django is updated
-    above this version, this helper can be removed.
-    """
-    url = reverse(
-        viewname, urlconf=urlconf, args=args, kwargs=kwargs, current_app=current_app
-    )
-    if query:
-        return f"{url}?{urlencode(query)}"
-    return url
-
-
 class CRUDTestCase(StudioAPITestCase):
     @property
     def new_submission_metadata(self):

contentcuration/contentcuration/viewsets/channel.py

@@ -8,6 +8,7 @@
 from django.conf import settings
 from django.db import IntegrityError
 from django.db.models import Exists
+from django.db.models import FilteredRelation
 from django.db.models import OuterRef
 from django.db.models import Q
 from django.db.models import Subquery
@@ -1049,6 +1050,16 @@ def annotate_queryset(self, queryset):
 
 
 class AdminChannelFilter(BaseChannelFilter):
+    latest_community_library_submission_status = CharFilter(
+        method="filter_latest_community_library_submission_status"
+    )
+    community_library_live = BooleanFilter(
+        method="filter_community_library_live",
+    )
+    has_community_library_submission = BooleanFilter(
+        method="filter_has_community_library_submission",
+    )
+
     def filter_keywords(self, queryset, name, value):
         keywords = value.split(" ")
         editors_first_name = reduce(
@@ -1066,6 +1077,20 @@ def filter_keywords(self, queryset, name, value):
             | editors_email
         )
 
+    def filter_latest_community_library_submission_status(self, queryset, name, value):
+        values = self.request.query_params.getlist(name)
+        if values:
+            return queryset.filter(
+                latest_community_library_submission__status__in=values
+            )
+        return queryset
+
+    def filter_community_library_live(self, queryset, name, value):
+        return queryset.filter(has_any_live_community_library_submission=True)
+
+    def filter_has_community_library_submission(self, queryset, name, value):
+        return queryset.filter(latest_community_library_submission__isnull=False)
+
 
 class AdminChannelSerializer(ChannelSerializer):
     """
@@ -1097,6 +1122,8 @@ class AdminChannelViewSet(ChannelViewSet, RESTUpdateModelMixin, RESTDestroyModel
         "created": "main_tree__created",
         "source_url": format_source_url,
         "demo_server_url": format_demo_server_url,
+        "latest_community_library_submission_id": "latest_community_library_submission__id",
+        "latest_community_library_submission_status": "latest_community_library_submission__status",
     }
 
     values = (
@@ -1116,6 +1143,9 @@ class AdminChannelViewSet(ChannelViewSet, RESTUpdateModelMixin, RESTDestroyModel
         "source_url",
         "demo_server_url",
         "primary_token",
+        "latest_community_library_submission__id",
+        "latest_community_library_submission__status",
+        "has_any_live_community_library_submission",
     )
 
     def perform_destroy(self, instance):
@@ -1145,11 +1175,28 @@ def get_queryset(self):
         channel_main_tree_nodes = ContentNode.objects.filter(
             tree_id=OuterRef("main_tree__tree_id")
         )
+        latest_community_library_submission_id = Subquery(
+            CommunityLibrarySubmission.objects.filter(channel_id=OuterRef("id"))
+            .order_by("-date_created")
+            .values("id")[:1]
+        )
         queryset = Channel.objects.all().annotate(
             modified=Subquery(
                 channel_main_tree_nodes.values("modified").order_by("-modified")[:1]
             ),
             primary_token=primary_token_subquery,
+            latest_community_library_submission=FilteredRelation(
+                "community_library_submissions",
+                condition=Q(
+                    community_library_submissions__id=latest_community_library_submission_id,
+                ),
+            ),
+            has_any_live_community_library_submission=Exists(
+                CommunityLibrarySubmission.objects.filter(
+                    channel_id=OuterRef("id"),
+                    status=community_library_submission_constants.STATUS_LIVE,
+                )
+            ),
         )
         return queryset