Fix star/bookmarking feature in Content Library

contentcuration/contentcuration/frontend/channelList/vuex/channelList/actions.js

@@ -28,7 +28,6 @@ export function searchCatalog(context, params) {
       .sort()
       .map(key => `${key}=${search[key]}`)
       .join('&');
-
     const trackingData = {
       total: pageData.count,
       matched: pageData.results.map(c => `${c.id} ${c.name}`),

contentcuration/contentcuration/tests/viewsets/test_channel.py

@@ -241,6 +241,100 @@ def test_viewer_cannot_update_some_channels(self):
         self.assertEqual(models.Channel.objects.get(id=channel1.id).name, new_name)
         self.assertNotEqual(models.Channel.objects.get(id=channel2.id).name, new_name)
 
+    def test_editor_can_bookmark_channel(self):
+        user = testdata.user()
+        channel = models.Channel.objects.create(**self.channel_metadata)
+        channel.editors.add(user)
+
+        self.client.force_authenticate(user=user)
+        with self.settings(TEST_ENV=False):
+            # Override test env here to check what will happen in production
+            response = self.client.post(
+                self.sync_url,
+                [generate_update_event(channel.id, CHANNEL, {"bookmark": True})],
+                format="json",
+            )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertTrue(user.bookmarked_channels.filter(id=channel.id).exists())
+
+    def test_viewer_can_bookmark_channel(self):
+        user = testdata.user()
+        channel = models.Channel.objects.create(**self.channel_metadata)
+        channel.viewers.add(user)
+
+        self.client.force_authenticate(user=user)
+        with self.settings(TEST_ENV=False):
+            # Override test env here to check what will happen in production
+            response = self.client.post(
+                self.sync_url,
+                [generate_update_event(channel.id, CHANNEL, {"bookmark": True})],
+                format="json",
+            )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertTrue(user.bookmarked_channels.filter(id=channel.id).exists())
+
+    def test_viewer_can_bookmark_public_channel(self):
+        user = testdata.user()
+        channel = models.Channel.objects.create(**self.channel_metadata)
+        channel.viewers.add(user)
+        channel.public = True
+        channel.save()
+
+        self.client.force_authenticate(user=user)
+        with self.settings(TEST_ENV=False):
+            # Override test env here to check what will happen in production
+            response = self.client.post(
+                self.sync_url,
+                [generate_update_event(channel.id, CHANNEL, {
+                    "bookmark": True,
+                })],
+                format="json",
+            )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertTrue(user.bookmarked_channels.filter(id=channel.id).exists())
+
+    def test_anyone_can_bookmark_public_channel(self):
+        user = testdata.user()
+        channel = models.Channel.objects.create(**self.channel_metadata)
+        channel.public = True
+        channel.save()
+
+        self.client.force_authenticate(user=user)
+        with self.settings(TEST_ENV=False):
+            # Override test env here to check what will happen in production
+            response = self.client.post(
+                self.sync_url,
+                [generate_update_event(channel.id, CHANNEL, {
+                    "bookmark": True,
+                })],
+                format="json",
+            )
+        self.assertEqual(response.status_code, 200, response.content)
+        self.assertTrue(user.bookmarked_channels.filter(id=channel.id).exists())
+
+    def test_viewer_cannot_edit_public_bookmarked_channel(self):
+        user = testdata.user()
+        new_name = "This is not the old name"
+        channel = models.Channel.objects.create(**self.channel_metadata)
+        channel.viewers.add(user)
+        channel.public = True
+        channel.save()
+
+        self.client.force_authenticate(user=user)
+        with self.settings(TEST_ENV=False):
+            # Override test env here to check what will happen in production
+            response = self.client.post(
+                self.sync_url,
+                [generate_update_event(channel.id, CHANNEL, {
+                    "bookmark": True,
+                    "name": new_name
+                })],
+                format="json",
+            )
+        self.assertEqual(response.status_code, 400, response.content)
+        self.assertTrue(user.bookmarked_channels.filter(id=channel.id).exists())
+        self.assertNotEqual(models.Channel.objects.get(id=channel.id).name, new_name)
+
     def test_delete_channel(self):
         user = testdata.user()
         channel = models.Channel.objects.create(**self.channel_metadata)

contentcuration/contentcuration/viewsets/channel.py

@@ -18,6 +18,7 @@
 from rest_framework import serializers
 from rest_framework.decorators import detail_route
 from rest_framework.exceptions import ValidationError
+from rest_framework.pagination import PageNumberPagination
 from rest_framework.permissions import AllowAny
 from rest_framework.permissions import IsAdminUser
 from rest_framework.permissions import IsAuthenticated
@@ -41,7 +42,6 @@
 from contentcuration.viewsets.base import ReadOnlyValuesViewset
 from contentcuration.viewsets.base import RequiredFilterSet
 from contentcuration.viewsets.base import ValuesViewset
-from contentcuration.viewsets.common import CatalogPaginator
 from contentcuration.viewsets.common import ChangeEventMixin
 from contentcuration.viewsets.common import ContentDefaultsSerializer
 from contentcuration.viewsets.common import JSONFieldDictSerializer
@@ -52,11 +52,16 @@
 from contentcuration.viewsets.sync.utils import generate_update_event
 
 
+class ChannelListPagination(PageNumberPagination):
+    page_size = None
+    page_size_query_param = "page_size"
+    max_page_size = 1000
+
+
 class CatalogListPagination(CachedListPagination):
     page_size = None
     page_size_query_param = "page_size"
     max_page_size = 1000
-    django_paginator_class = CatalogPaginator
 
 
 primary_token_subquery = Subquery(
@@ -315,7 +320,6 @@ def update(self, instance, validated_data):
                 instance.bookmarked_by.add(user_id)
             elif bookmark is not None:
                 instance.bookmarked_by.remove(user_id)
-
         return super(ChannelSerializer, self).update(instance, validated_data)
 
 
@@ -384,7 +388,7 @@ class ChannelViewSet(ChangeEventMixin, ValuesViewset):
     permission_classes = [IsAuthenticated]
     serializer_class = ChannelSerializer
     filter_backends = (DjangoFilterBackend,)
-    pagination_class = CatalogListPagination
+    pagination_class = ChannelListPagination
     filter_class = ChannelFilter
 
     field_map = channel_field_map
@@ -424,6 +428,31 @@ def annotate_queryset(self, queryset):
         )
         return queryset
 
+    def update_from_changes(self, changes):
+        """
+        If a channel can be bookmarked, changes from bookmarking are addressed in this
+        method before the `update_from_changes` method in `UpdateModelMixin`.
+        """
+        for change in changes:
+            if 'bookmark' in change["mods"].keys():
+                keys = [change["key"] for change in changes]
+                queryset = self.filter_queryset_from_keys(
+                    self.get_queryset(), keys
+                ).order_by()
+                instance = queryset.get(**dict(self.values_from_key(change["key"])))
+                bookmark = {k: v for k, v in change['mods'].items() if k == 'bookmark'}
+                other_mods = {k: v for k, v in change['mods'].items() if k != 'bookmark'}
+                change["mods"] = bookmark
+                serializer = self.get_serializer(
+                    instance, data=self._map_update_change(change), partial=True
+                )
+                if serializer.is_valid():
+                    self.perform_update(serializer)
+                    change["mods"] = other_mods
+
+        changes = [change for change in changes if change['mods']]
+        return super(ChannelViewSet, self).update_from_changes(changes)
+
     @detail_route(methods=["post"])
     def publish(self, request, pk=None):
         if not pk: