Release v0.17.x into develop

kolibri/core/__init__.py

@@ -1,5 +0,0 @@
-"""TODO: Write something about this module (everything in the docstring
-enters the docs)
-
-"""
-default_app_config = "kolibri.core.apps.KolibriCoreConfig"

kolibri/core/assets/src/views/sync/SelectDeviceModalGroup/SelectDeviceForm.vue

@@ -139,6 +139,7 @@
   import UiAlert from 'kolibri-design-system/lib/keen/UiAlert';
   import commonCoreStrings from 'kolibri.coreVue.mixins.commonCoreStrings';
   import commonSyncElements from 'kolibri.coreVue.mixins.commonSyncElements';
+  import pickBy from 'lodash/pickBy';
   import { UnreachableConnectionStatuses } from './constants';
   import useDeviceDeletion from './useDeviceDeletion.js';
   import {
@@ -163,19 +164,22 @@
         deviceFilters.push(useDeviceChannelFilter({ id: props.filterByChannelId }));
       }
 
-      if (
-        props.filterByFacilityId !== null ||
-        props.filterByFacilityCanSignUp !== null ||
-        props.filterByOnMyOwnFacility !== null
-      ) {
+      const pickNotNull = v => v !== null;
+      // Either we build a facility filter or an empty object.
+      // Passing the empty object to useDeviceFacilityFilter is asking "are there ANY facilities?"
+      const facilityFilter = pickBy(
+        {
+          id: props.filterByFacilityId,
+          learner_can_sign_up: props.filterByFacilityCanSignUp,
+          on_my_own_setup: props.filterByOnMyOwnFacility,
+        },
+        pickNotNull,
+      );
+
+      // If we're filtering a particular facility
+      if (Object.keys(facilityFilter).length > 0 || props.filterByHasFacilities) {
         apiParams.subset_of_users_device = false;
-        deviceFilters.push(
-          useDeviceFacilityFilter({
-            id: props.filterByFacilityId,
-            learner_can_sign_up: props.filterByFacilityCanSignUp,
-            on_my_own_setup: props.filterByOnMyOwnFacility,
-          }),
-        );
+        deviceFilters.push(useDeviceFacilityFilter(facilityFilter));
       }
 
       if (props.filterLODAvailable) {
@@ -254,6 +258,12 @@
         type: Boolean,
         default: null,
       },
+      // In the setup wizard, to exclude devices that do not have a facility
+      // eslint-disable-next-line kolibri/vue-no-unused-properties
+      filterByHasFacilities: {
+        type: Boolean,
+        default: null,
+      },
       // If an ID is provided, that device's radio button will be automatically selected
       selectedId: {
         type: String,

kolibri/core/assets/src/views/sync/SelectDeviceModalGroup/api.js

@@ -28,6 +28,7 @@ export function fetchDevices(params = {}) {
  * @typedef {Object} FacilityFilter
  * @property {string} [id]
  * @property {boolean} [learner_can_sign_up]
+ * @property {boolean} [on_my_own_setup]
  */
 
 /**

kolibri/core/assets/src/views/sync/SelectDeviceModalGroup/index.vue

@@ -13,6 +13,7 @@
       :filterLODAvailable="filterLODAvailable"
       :filterByFacilityCanSignUp="filterByFacilityCanSignUp"
       :filterByOnMyOwnFacility="filterByOnMyOwnFacility"
+      :filterByHasFacilities="filterByHasFacilities"
       :selectedId="addedAddressId"
       :formDisabled="$attrs.selectAddressDisabled"
       @click_add_address="goToAddAddress"
@@ -56,6 +57,10 @@
         type: Boolean,
         default: null,
       },
+      filterByHasFacilities: {
+        type: Boolean,
+        default: null,
+      },
       // When looking for facilities to import in the setup wizard
       filterByOnMyOwnFacility: {
         type: Boolean,

kolibri/core/assets/src/views/sync/SelectDeviceModalGroup/useDevices.js

@@ -195,10 +195,6 @@ export function useDeviceFacilityFilter({
     filters.on_my_own_setup = on_my_own_setup;
   }
 
-  if (Object.keys(filters).length === 0) {
-    return () => Promise.resolve(true);
-  }
-
   return useAsyncDeviceFilter(function deviceFacilityFilter(device) {
     return deviceHasMatchingFacility(device, filters);
   });

kolibri/core/auth/api.py

@@ -493,7 +493,7 @@ def post(self, request):
 
 class FacilityUsernameViewSet(ReadOnlyValuesViewset):
     filter_backends = (DjangoFilterBackend, filters.SearchFilter)
-    filter_fields = ("facility",)
+    filterset_fields = ("facility",)
     search_fields = ("^username",)
 
     values = ("username",)
@@ -527,7 +527,7 @@ class MembershipViewSet(BulkDeleteMixin, BulkCreateMixin, viewsets.ModelViewSet)
     queryset = Membership.objects.all()
     serializer_class = MembershipSerializer
     filterset_class = MembershipFilter
-    filter_fields = ["user", "collection", "user_ids"]
+    filterset_fields = ["user", "collection", "user_ids"]
 
 
 class RoleFilter(FilterSet):
@@ -547,7 +547,7 @@ class RoleViewSet(BulkDeleteMixin, BulkCreateMixin, viewsets.ModelViewSet):
     queryset = Role.objects.all()
     serializer_class = RoleSerializer
     filterset_class = RoleFilter
-    filter_fields = ["user", "collection", "kind", "user_ids"]
+    filterset_fields = ["user", "collection", "kind", "user_ids"]
 
 
 dataset_keys = [
@@ -771,7 +771,7 @@ class LearnerGroupViewSet(ValuesViewset):
     queryset = LearnerGroup.objects.all()
     serializer_class = LearnerGroupSerializer
 
-    filter_fields = ("parent",)
+    filterset_fields = ("parent",)
 
     values = ("id", "name", "parent", "user_ids")
 

kolibri/core/auth/test/test_bulk_export.py

@@ -15,11 +15,21 @@
 @override_settings(LANGUAGE_CODE="en")
 class UserExportTestCase(TestCase):
     @classmethod
-    def setUpTestData(cls):
+    def setUpClass(cls):
         # Import inside the settings decorator to ensure that the locale is controlled
+        # Do this inside setUpClass rather than setUpTestData as setUpTestData requires
+        # assigned objects to be compatible with copy.deepcopy - we do not need to copy
+        # the management commands as they will not be modified by the tests, unlike the
+        # models.
         from ..management.commands import bulkexportusers as b
 
         cls.b = b
+        # Run it before setUpClass super call, because this will then execute setUpTestData
+        # which requires cls.b to be defined.
+        super().setUpClass()
+
+    @classmethod
+    def setUpTestData(cls):
         cls.data = create_dummy_facility_data(
             classroom_count=CLASSROOMS, learnergroup_count=1
         )
@@ -28,7 +38,7 @@ def setUpTestData(cls):
         _, cls.filepath = tempfile.mkstemp(suffix=".csv")
 
         cls.csv_rows = []
-        for row in b.csv_file_generator(cls.facility, cls.filepath, True):
+        for row in cls.b.csv_file_generator(cls.facility, cls.filepath, True):
             cls.csv_rows.append(row)
 
     def test_not_specified(self):

kolibri/core/bookmarks/api.py

@@ -44,4 +44,4 @@ class BookmarksViewSet(ValuesViewset):
         KolibriAuthPermissionsFilter,
         DjangoFilterBackend,
     )
-    filter_fields = ("contentnode_id",)
+    filterset_fields = ("contentnode_id",)

kolibri/core/content/__init__.py

@@ -2,9 +2,6 @@
 import os
 
 
-default_app_config = "kolibri.core.content.apps.KolibriContentConfig"
-
-
 # Do this to prevent import of broken Windows filetype registry that makes guesstype not work.
 # https://www.thecodingforums.com/threads/mimetypes-guess_type-broken-in-windows-on-py2-7-and-python-3-x.952693/
 mimetypes.init(

kolibri/core/content/api.py

@@ -1,6 +1,7 @@
 import hashlib
 import logging
 import re
+from base64 import urlsafe_b64decode
 from collections import OrderedDict
 from functools import reduce
 from random import sample
@@ -14,11 +15,14 @@
 from django.db.models import Subquery
 from django.db.models.aggregates import Count
 from django.http import Http404
+from django.http import HttpResponse
+from django.urls import reverse
 from django.utils.cache import add_never_cache_headers
 from django.utils.decorators import method_decorator
 from django.utils.encoding import force_bytes
 from django.utils.encoding import iri_to_uri
 from django.utils.translation import gettext as _
+from django.views import View
 from django.views.decorators.cache import cache_page
 from django.views.decorators.cache import never_cache
 from django.views.decorators.http import etag
@@ -291,6 +295,18 @@ def filter_available(self, queryset, name, value):
         return queryset.filter(root__available=value)
 
 
+class ChannelThumbnailView(View):
+    def get(self, request, channel_id):
+        channel = get_object_or_404(models.ChannelMetadata, id=channel_id)
+        try:
+            header, b_64_thumbnail = channel.thumbnail.split(",", 1)
+            mimetype = header.split(":")[1].split(";")[0]
+        except ValueError:
+            raise Http404("No thumbnail available")
+        thumbnail = urlsafe_b64decode(b_64_thumbnail)
+        return HttpResponse(thumbnail, content_type=mimetype)
+
+
 class BaseChannelMetadataMixin(object):
     filter_backends = (DjangoFilterBackend,)
     filterset_class = ChannelMetadataFilter
@@ -373,9 +389,21 @@ def filter_options(self, request, **kwargs):
         return Response(data)
 
 
+def _create_channel_thumbnail_url(item):
+    return (
+        reverse("kolibri:core:channel-thumbnail", args=[item["id"]])
+        if item["thumbnail"]
+        else ""
+    )
+
+
 @method_decorator(remote_metadata_cache, name="dispatch")
 class ChannelMetadataViewSet(BaseChannelMetadataMixin, RemoteViewSet):
-    pass
+    field_map = {
+        "thumbnail": _create_channel_thumbnail_url,
+    }
+
+    field_map.update(BaseChannelMetadataMixin.field_map)
 
 
 MODALITIES = set(["QUIZ"])

kolibri/core/content/api_urls.py

@@ -1,8 +1,10 @@
 from django.urls import include
+from django.urls import path
 from django.urls import re_path
 from rest_framework import routers
 
 from .api import ChannelMetadataViewSet
+from .api import ChannelThumbnailView
 from .api import ContentNodeBookmarksViewset
 from .api import ContentNodeGranularViewset
 from .api import ContentNodeProgressViewset
@@ -46,4 +48,11 @@
 )
 router.register(r"remotechannel", RemoteChannelViewSet, basename="remotechannel")
 
-urlpatterns = [re_path(r"^", include(router.urls))]
+urlpatterns = [
+    path(
+        "channel-thumbnail/<channel_id>/",
+        ChannelThumbnailView.as_view(),
+        name="channel-thumbnail",
+    ),
+    re_path(r"^", include(router.urls)),
+]

kolibri/core/content/test/test_content_app.py

@@ -5,6 +5,7 @@
 import time
 import unittest
 import uuid
+from base64 import urlsafe_b64decode
 
 import mock
 import requests
@@ -1998,3 +1999,43 @@ class PrefixedProxyContentMetadataTestCase(ProxyContentMetadataTestCase):
     @property
     def baseurl(self):
         return self.live_server_url + "/test/"
+
+
+class ChannelThumbnailViewTestCase(APITestCase):
+    def setUp(self):
+        self.content_node = content.ContentNode.objects.create(
+            pk="6a406ac66b224106aa2e93f73a94333d",
+            channel_id="f8ec4a5d14cd4716890999da596032d2",
+            content_id="ded4a083e75f4689b386fd2b706e792a",
+        )
+        self.thumbnail = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABjElEQVR42mNk"
+        self.channel_metadata = content.ChannelMetadata.objects.create(
+            id="63acff41781543828861ade41dbdd7ff",
+            name="no exercise channel metadata",
+            thumbnail=self.thumbnail,
+            root=self.content_node,
+        )
+
+    def test_channel_thumbnail_view(self):
+        response = self.client.get(
+            reverse("kolibri:core:channel-thumbnail", args=[self.channel_metadata.id])
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response["Content-Type"], "image/png")
+        self.assertEqual(
+            response.content, urlsafe_b64decode(self.thumbnail.split(",")[1])
+        )
+
+    def test_channel_thumbnail_view_not_found(self):
+        response = self.client.get(
+            reverse("kolibri:core:channel-thumbnail", args=["deadpool"])
+        )
+        self.assertEqual(response.status_code, 404)
+
+    def test_channel_thumbnail_view_no_thumbnail(self):
+        self.channel_metadata.thumbnail = ""
+        self.channel_metadata.save()
+        response = self.client.get(
+            reverse("kolibri:core:channel-thumbnail", args=[self.channel_metadata.id])
+        )
+        self.assertEqual(response.status_code, 404)

kolibri/core/content/utils/content_manifest.py

@@ -231,7 +231,8 @@ def _get_channel_data(self, channel_id, channel_version):
         return channel_data
 
     def _set_channel_data(self, channel_data):
-        assert isinstance(channel_data, ContentManifestChannelData)
+        if not isinstance(channel_data, ContentManifestChannelData):
+            raise TypeError("channel_data must be a ContentManifestChannelData")
         self._channels_dict.setdefault(channel_data.channel_id, {})[
             channel_data.channel_version
         ] = channel_data

kolibri/core/device/__init__.py

@@ -1 +0,0 @@
-default_app_config = "kolibri.core.device.apps.KolibriDeviceAppConfig"

kolibri/core/discovery/api.py

@@ -28,7 +28,7 @@ class NetworkLocationViewSet(viewsets.ModelViewSet):
     serializer_class = NetworkLocationSerializer
     queryset = NetworkLocation.objects.exclude(location_type=LocationTypes.Reserved)
     filter_backends = [DjangoFilterBackend]
-    filter_fields = [
+    filterset_fields = [
         "id",
         "subset_of_users_device",
         "instance_id",

kolibri/core/exams/api.py

@@ -116,14 +116,14 @@ def filter_querysets(self, exam_queryset, draft_queryset):
             exam_queryset = instantiated_backend.filter_queryset(
                 self.request, exam_queryset, self
             )
-            # Do some special handling if the backend has a get_filter_class method
-            # this is required, as the get_filter_class makes an assertion based on
+            # Do some special handling if the backend has a get_filterset_class method
+            # this is required, as the get_filterset_class makes an assertion based on
             # the model Meta of the FilterSet - which is set to Exam, so this will
             # fail if we try to use the ExamFilter on the DraftExam queryset
             # This is a workaround to allow the DraftExam queryset to be filtered
-            if hasattr(instantiated_backend, "get_filter_class"):
+            if hasattr(instantiated_backend, "get_filterset_class"):
                 # First get the filter class using the exam queryset
-                filter_class = instantiated_backend.get_filter_class(
+                filter_class = instantiated_backend.get_filterset_class(
                     self, exam_queryset
                 )
                 # If the filter class is not None, then we can use it to filter the draft_queryset
@@ -136,7 +136,7 @@ def filter_querysets(self, exam_queryset, draft_queryset):
                         request=self.request,
                     ).qs
             else:
-                # If the backend doesn't have a get_filter_class method, then we can just
+                # If the backend doesn't have a get_filterset_class method, then we can just
                 # filter the draft_queryset as normal
                 draft_queryset = instantiated_backend.filter_queryset(
                     self.request, draft_queryset, self

kolibri/core/lessons/viewsets.py

@@ -46,7 +46,7 @@ def _map_lesson_classroom(item):
 class LessonViewset(ValuesViewset):
     serializer_class = LessonSerializer
     filter_backends = (KolibriAuthPermissionsFilter, DjangoFilterBackend)
-    filter_fields = ("collection", "id")
+    filterset_fields = ("collection", "id")
     permission_classes = (LessonPermissions,)
     queryset = Lesson.objects.all().order_by("-date_created")
 

kolibri/core/logger/__init__.py

@@ -1 +0,0 @@
-default_app_config = "kolibri.core.logger.apps.KolibriLoggerConfig"

kolibri/core/mixins.py

@@ -36,7 +36,7 @@ def allow_bulk_destroy(self, qs, filtered):
         """
         # Only let a bulk destroy if the queryset is being filtered by a valid filter_field parameter
         return any(
-            key in self.filter_fields for key in self.request.query_params.keys()
+            key in self.filterset_fields for key in self.request.query_params.keys()
         )
 
     def bulk_destroy(self, request, *args, **kwargs):