Search updates

kolibri/core/assets/src/mixins/commonCoreStrings.js

@@ -1048,6 +1048,9 @@ const nonconformingKeys = {
   MATERIALS: 'NeedsMaterials',
   FOR_BEGINNERS: 'ForBeginners',
   digitalLiteracy: 'digitialLiteracy',
+  BASIC_SKILLS: 'allLevelsBasicSkills',
+  FOUNDATIONS: 'basicSkills',
+  FOUNDATIONS_LOGIC_AND_CRITICAL_THINKING: 'logicAndCriticalThinking',
 };
 
 /**
@@ -1080,8 +1083,8 @@ export default {
      * string mapping to the values to be passed for those arguments.
      */
     coreString(key, args) {
-      if (key === 'None of the above') {
-        return noneOfTheAboveTranslator.$tr(key, args);
+      if (key === 'None of the above' || key === METADATA.NoCategories) {
+        return noneOfTheAboveTranslator.$tr('None of the above', args);
       }
 
       const metadataKey = get(MetadataLookup, key, null);

kolibri/core/content/api.py

@@ -24,6 +24,7 @@
 from django_filters.rest_framework import ChoiceFilter
 from django_filters.rest_framework import DjangoFilterBackend
 from django_filters.rest_framework import FilterSet
+from django_filters.rest_framework import NumberFilter
 from django_filters.rest_framework import UUIDFilter
 from le_utils.constants import content_kinds
 from le_utils.constants import languages
@@ -185,6 +186,8 @@ class ContentNodeFilter(IdFilter):
     channels = UUIDInFilter(name="channel_id")
     languages = CharInFilter(name="lang_id")
     categories__isnull = BooleanFilter(field_name="categories", lookup_expr="isnull")
+    lft__gt = NumberFilter(field_name="lft", lookup_expr="gt")
+    rght__lt = NumberFilter(field_name="rght", lookup_expr="lt")
 
     class Meta:
         model = models.ContentNode
@@ -211,6 +214,9 @@ class Meta:
             "keywords",
             "channels",
             "languages",
+            "tree_id",
+            "lft__gt",
+            "rght__lt",
         ]
 
     def filter_kind(self, queryset, name, value):

kolibri/core/package.json

@@ -18,7 +18,7 @@
     "hammerjs": "^2.0.8",
     "intl": "^1.2.4",
     "knuth-shuffle-seeded": "^1.0.6",
-    "kolibri-constants": "^0.1.32-beta1",
+    "kolibri-constants": "^0.1.34",
     "kolibri-design-system": "git://github.com/learningequality/kolibri-design-system#632240f0b11f37c8b18de5ed930a4bf66b7c3678",
     "lockr": "0.8.4",
     "lodash": "^4.17.21",

kolibri/core/webpack/hooks.py

@@ -22,6 +22,7 @@
 from django.conf import settings
 from django.contrib.staticfiles.finders import find as find_staticfiles
 from django.contrib.staticfiles.storage import staticfiles_storage
+from django.core.serializers.json import DjangoJSONEncoder
 from django.utils.functional import cached_property
 from django.utils.safestring import mark_safe
 from django.utils.six.moves.urllib.request import url2pathname
@@ -276,7 +277,10 @@ def plugin_data_tag(self):
                     bundle=self.unique_id,
                     plugin_data=json.dumps(
                         json.dumps(
-                            self.plugin_data, separators=(",", ":"), ensure_ascii=False
+                            self.plugin_data,
+                            separators=(",", ":"),
+                            ensure_ascii=False,
+                            cls=DjangoJSONEncoder,
                         )
                     ),
                 )

kolibri/plugins/learn/assets/src/composables/__mocks__/useChannels.js

@@ -33,7 +33,7 @@
 
 const MOCK_DEFAULTS = {
   channels: [],
-  fetchChannels: jest.fn(),
+  channelsMap: {},
 };
 
 export function useChannelsMock(overrides = {}) {

kolibri/plugins/learn/assets/src/composables/useChannels.js

@@ -3,30 +3,22 @@
  */
 
 import { ref } from 'kolibri.lib.vueCompositionApi';
-import { set } from '@vueuse/core';
-import { ChannelResource } from 'kolibri.resources';
+import plugin_data from 'plugin_data';
+
+const channelsArray = plugin_data.channels ? plugin_data.channels : [];
+const chanMap = {};
+
+for (let channel of channelsArray) {
+  chanMap[channel.id] = channel;
+}
 
 // The refs are defined in the outer scope so they can be used as a shared store
-const channels = ref([]);
+const channels = ref(channelsArray);
+const channelsMap = ref(chanMap);
 
 export default function useChannels() {
-  /**
-   * Fetches channels and saves data to this composable's store
-   *
-   * @param {Boolean} available only get the channels that are "available"
-   *                            (i.e. with resources on device) when `true`
-   * @returns {Promise}
-   * @public
-   */
-  function fetchChannels({ available = true } = {}) {
-    return ChannelResource.fetchCollection({ getParams: { available } }).then(collection => {
-      set(channels, collection);
-      return collection;
-    });
-  }
-
   return {
     channels,
-    fetchChannels,
+    channelsMap,
   };
 }

kolibri/plugins/learn/assets/src/composables/useLanguages.js

@@ -0,0 +1,26 @@
+/**
+ * A composable function containing logic related to languages
+ */
+
+import sortBy from 'lodash/sortBy';
+import { computed, ref } from 'kolibri.lib.vueCompositionApi';
+import { get } from '@vueuse/core';
+import plugin_data from 'plugin_data';
+
+const langArray = plugin_data.languages ? plugin_data.languages : [];
+const langMap = {};
+
+for (let lang of langArray) {
+  langMap[lang.id] = lang;
+}
+
+// The refs are defined in the outer scope so they can be used as a shared store
+const languagesMap = ref(langMap);
+
+export default function useLanguages() {
+  const languages = computed(() => sortBy(Object.values(get(languagesMap)), 'id'));
+  return {
+    languages,
+    languagesMap,
+  };
+}

kolibri/plugins/learn/assets/src/composables/useSearch.js

@@ -0,0 +1,184 @@
+import { get, set } from '@vueuse/core';
+import { computed, ref, watch } from 'kolibri.lib.vueCompositionApi';
+import { ContentNodeResource } from 'kolibri.resources';
+import { AllCategories, NoCategories } from 'kolibri.coreVue.vuex.constants';
+import router from 'kolibri.coreVue.router';
+import store from 'kolibri.coreVue.vuex.store';
+import { normalizeContentNode } from '../modules/coreLearn/utils';
+
+const searchKeys = [
+  'learning_activities',
+  'categories',
+  'learner_needs',
+  'channels',
+  'accessibility_labels',
+  'languages',
+  'grade_levels',
+];
+
+export default function useSearch() {
+  const route = computed(() => store.state.route);
+
+  const searchLoading = ref(true);
+  const moreLoading = ref(false);
+  const results = ref([]);
+  const more = ref(null);
+  const labels = ref(null);
+
+  let descendant;
+
+  function setSearchWithinDescendant(d) {
+    descendant = d;
+  }
+
+  const searchTerms = computed({
+    get() {
+      const searchTerms = {};
+      const query = get(route).query;
+      for (let key of searchKeys) {
+        const obj = {};
+        if (query[key]) {
+          for (let value of query[key].split(',')) {
+            obj[value] = true;
+          }
+        }
+        searchTerms[key] = obj;
+      }
+      if (query.keywords) {
+        searchTerms.keywords = query.keywords;
+      }
+      return searchTerms;
+    },
+    set(value) {
+      const query = { ...get(route).query };
+      for (let key of searchKeys) {
+        const val = Object.keys(value[key] || {})
+          .filter(Boolean)
+          .join(',');
+        if (val.length) {
+          query[key] = Object.keys(value[key]).join(',');
+        } else {
+          delete query[key];
+        }
+      }
+      if (value.keywords && value.keywords.length) {
+        query.keywords = value.keywords;
+      } else {
+        delete query.keywords;
+      }
+      // Just catch an error from making a redundant navigation rather
+      // than try to precalculate this.
+      router.push({ ...get(route), query }).catch(() => {});
+    },
+  });
+
+  const displayingSearchResults = computed(() =>
+    Object.values(get(searchTerms)).some(v => Object.keys(v).length)
+  );
+
+  function search() {
+    const getParams = {};
+    if (descendant) {
+      getParams.tree_id = descendant.tree_id;
+      getParams.lft__gt = descendant.lft;
+      getParams.rght__lt = descendant.rght;
+    }
+    if (get(displayingSearchResults)) {
+      getParams.max_results = 25;
+      const terms = get(searchTerms);
+      set(searchLoading, true);
+      for (let key of searchKeys) {
+        if (key === 'categories') {
+          if (terms[key][AllCategories]) {
+            getParams['categories__isnull'] = false;
+            continue;
+          } else if (terms[key][NoCategories]) {
+            getParams['categories__isnull'] = true;
+            continue;
+          }
+          if (key === 'channels' && descendant) {
+            continue;
+          }
+        }
+        const keys = Object.keys(terms[key]);
+        if (keys.length) {
+          getParams[key] = keys;
+        }
+      }
+      if (terms.keywords) {
+        getParams.keywords = terms.keywords;
+      }
+      ContentNodeResource.fetchCollection({ getParams }).then(data => {
+        set(results, data.results.map(normalizeContentNode));
+        set(more, data.more);
+        set(labels, data.labels);
+        set(searchLoading, false);
+      });
+    } else if (descendant) {
+      getParams.max_results = 1;
+      ContentNodeResource.fetchCollection({ getParams }).then(data => {
+        set(labels, data.labels);
+        set(more, null);
+      });
+    } else {
+      // Clear labels if no search results displaying
+      // and we're not gathering labels from the descendant
+      set(more, null);
+      set(labels, null);
+    }
+  }
+
+  function searchMore() {
+    if (get(displayingSearchResults) && get(more) && !get(moreLoading)) {
+      set(moreLoading, true);
+      ContentNodeResource.fetchCollection({ getParams: get(more) }).then(data => {
+        set(results, [...get(results), ...data.results.map(normalizeContentNode)]);
+        set(more, data.more);
+        set(labels, data.labels);
+        set(moreLoading, false);
+      });
+    }
+  }
+
+  function removeFilterTag({ value, key }) {
+    if (key === 'keywords') {
+      set(searchTerms, {
+        ...get(searchTerms),
+        [key]: '',
+      });
+    } else {
+      const keyObject = get(searchTerms)[key];
+      delete keyObject[value];
+      set(searchTerms, {
+        ...get(searchTerms),
+        [key]: keyObject,
+      });
+    }
+  }
+
+  function clearSearch() {
+    set(searchTerms, {});
+  }
+
+  function setCategory(category) {
+    set(searchTerms, { ...this.searchTerms, categories: { [category]: true } });
+  }
+
+  watch(searchTerms, search);
+
+  return {
+    searchTerms,
+    displayingSearchResults,
+    searchLoading,
+    moreLoading,
+    results,
+    more,
+    labels,
+    search,
+    searchMore,
+    removeFilterTag,
+    clearSearch,
+    setCategory,
+    setSearchWithinDescendant,
+  };
+}

kolibri/plugins/learn/assets/src/constants.js

@@ -2,9 +2,8 @@
 export const PageNames = {
   ROOT: 'ROOT',
   HOME: 'HOME',
-  TOPICS_ROOT: 'TOPICS_ROOT',
-  TOPICS_CHANNEL: 'TOPICS_CHANNEL',
   TOPICS_TOPIC: 'TOPICS_TOPIC',
+  TOPICS_TOPIC_SEARCH: 'TOPICS_TOPIC_SEARCH',
   TOPICS_CONTENT: 'TOPICS_CONTENT',
   LIBRARY: 'LIBRARY',
   RECOMMENDED_POPULAR: 'RECOMMENDED_POPULAR',
@@ -42,10 +41,7 @@ export const pageNameToModuleMap = {
   [ClassesPageNames.EXAM_REPORT_VIEWER]: 'examReportViewer',
   [ClassesPageNames.LESSON_PLAYLIST]: 'lessonPlaylist',
   [ClassesPageNames.LESSON_RESOURCE_VIEWER]: 'lessonPlaylist/resource',
-  [PageNames.TOPICS_ROOT]: 'topicsRoot',
-  [PageNames.LIBRARY]: 'library',
-  [PageNames.TOPICS_CHANNEL]: 'topicsTree',
   [PageNames.TOPICS_CONTENT]: 'topicsTree',
   [PageNames.TOPICS_TOPIC]: 'topicsTree',
-  [PageNames.RECOMMENDED_CONTENT]: 'topicsTree',
+  [PageNames.TOPICS_TOPIC_SEARCH]: 'topicsTree',
 };