musora-content-services 2.79.0 → 2.80.0

package/src/services/content/instructor.ts

@@ -0,0 +1,131 @@
+/**
+ * @module Instructor
+ */
+import { FilterBuilder } from '../../filterBuilder.js'
+import { filtersToGroq, getFieldsForContentType } from '../../contentTypeConfig.js'
+import { buildEntityAndTotalQuery, fetchSanity, getSortOrder } from '../sanity.js'
+import { Lesson } from './content'
+
+export interface Instructor {
+  lessonCount: number
+  slug: string
+  name: string
+  short_bio: string
+  thumbnail: string
+}
+
+/**
+ * Fetch all instructor with lessons available for a specific brand.
+ *
+ * @param {string} brand - The brand for which to fetch instructors.
+ * @returns {Promise<Instructor[]>} - A promise that resolves to an array of instructor objects.
+ *
+ * @example
+ * fetchInstructors('drumeo')
+ *   .then(instructors => console.log(instructors))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchInstructors(brand: string): Promise<Instructor[]> {
+  const filter = await new FilterBuilder(`brand == "${brand}" && references(^._id)`, {
+    bypassPermissions: true,
+  }).buildFilter()
+
+  const query = `
+  *[_type == "instructor"] {
+    name,
+    "slug": slug.current,
+    "lessonsCount": count(*[${filter}])
+  }[lessonsCount > 0] |order(lower(name)) `
+  return fetchSanity(query, true, { processNeedAccess: false, processPageType: false })
+}
+
+/**
+ * Fetch a single instructor by their name
+ *
+ * @param {string} slug - The slug of the instructor to fetch.
+ * @param {string} [brand] - The brand for which to fetch the instructor. Lesson count will be filtered by this brand if provided.
+ * @returns {Promise<Instructor[]>} - A promise that resolves to an instructor object or null if not found.
+ *
+ * @example
+ * fetchInstructorBySlug('66samus', 'drumeo')
+ *   .then(instructor => console.log(instructor))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchInstructorBySlug(
+  slug: string,
+  brand?: string
+): Promise<Instructor | null> {
+  const brandFilter = brand ? `brand == "${brand}" && ` : ''
+  const filter = await new FilterBuilder(`${brandFilter} references(^._id)`, {
+    bypassPermissions: true,
+  }).buildFilter()
+
+  const query = `
+  *[_type == "instructor" && slug.current == '${slug}'][0] {
+    name,
+    "slug": slug.current,
+    short_bio,
+    'thumbnail': thumbnail_url.asset->url,
+    "lessonsCount": count(*[${filter}])
+  }`
+  return fetchSanity(query, true, { processNeedAccess: false, processPageType: false })
+}
+
+export interface FetchInstructorLessonsOptions {
+  sortOrder?: string
+  searchTerm?: string
+  page?: number
+  limit?: number
+  includedFields?: Array<string>
+}
+
+export interface InstructorLessonsResponse {
+  entity: Lesson[]
+  total: number
+}
+
+/**
+ * Fetch the data needed for the instructor screen.
+ * @param {string} brand - The brand for which to fetch instructor lessons
+ * @param {string} slug - The slug of the instructor
+ *
+ * @param {FetchInstructorLessonsOptions} options - Parameters for pagination, filtering and sorting.
+ * @param {string} [options.sortOrder="-published_on"] - The field to sort the lessons by.
+ * @param {string} [options.searchTerm=""] - The search term to filter content by title.
+ * @param {number} [options.page=1] - The page number for pagination.
+ * @param {number} [options.limit=10] - The number of items per page.
+ * @param {Array<string>} [options.includedFields=[]] - Additional filters to apply to the query in the format of a key,value array. eg. ['difficulty,Intermediate', 'genre,rock'].
+ *
+ * @returns {Promise<InstructorLessonsResponse>} - The lessons for the instructor or null if not found.
+ * @example
+ * fetchInstructorLessons('instructor123')
+ *   .then(lessons => console.log(lessons))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchInstructorLessons(
+  slug: string,
+  brand: string,
+  {
+    sortOrder = '-published_on',
+    searchTerm = '',
+    page = 1,
+    limit = 20,
+    includedFields = [],
+  }: FetchInstructorLessonsOptions = {}
+): Promise<InstructorLessonsResponse> {
+  const fieldsString = getFieldsForContentType() as string
+  const start = (page - 1) * limit
+  const end = start + limit
+  const searchFilter = searchTerm ? `&& title match "${searchTerm}*"` : ''
+  const includedFieldsFilter = includedFields.length > 0 ? filtersToGroq(includedFields) : ''
+  const filter = `brand == '${brand}' ${searchFilter} ${includedFieldsFilter} && references(*[_type=='instructor' && slug.current == '${slug}']._id)`
+  const filterWithRestrictions = await new FilterBuilder(filter).buildFilter()
+
+  sortOrder = getSortOrder(sortOrder, brand)
+  const query = buildEntityAndTotalQuery(filterWithRestrictions, fieldsString, {
+    sortOrder: sortOrder,
+    start: start,
+    end: end,
+  })
+  return fetchSanity(query, true)
+}

package/src/services/content-org/learning-paths.ts

@@ -101,21 +101,28 @@ export async function resetAllLearningPaths() {
  * @returns {Promise<Object>} Learning path with enriched lesson data
  */
 export async function getEnrichedLearningPath(learningPathId) {
-  //TODO BEH-1410: refactor/cleanup
-  let learningPath = await fetchByRailContentId(learningPathId, 'learning-path-v2')
-  learningPath.children = mapContentToParent(
-    learningPath.children,
+  // TODO: replace addNextLesson with addNaviageTo
+  const response = (await addContextToContent(
+    fetchByRailContentId,
+    learningPathId,
+    'learning-path-v2',
+    {
+      dataField: 'children',
+      dataField_includeParent: true,
+      addProgressStatus: true,
+      addProgressPercentage: true,
+      addProgressTimestamp: true,
+      addNextLesson: true,
+    }
+  )) as any
+  if (!response) return response
+  
+  response.children = mapContentToParent(
+    response.children,
     'learning-path-lesson-v2',
     learningPathId
   )
-
-  learningPath.children = await addContextToContent(() => learningPath.children, {
-    addProgressStatus: true,
-    addProgressPercentage: true,
-    addProgressTimestamp: true,
-  })
-  learningPath = await addContextToContent(() => learningPath, { addNextLesson: true })
-  return learningPath
+  return response
 }
 
 /**
@@ -234,7 +241,7 @@ interface completeMethodIntroVideo {
 }
 /**
  * Handles completion of method intro video and other related actions.
- * @param introVideoId - The intro video content ID.
+ * @param introVideoId - The method intro video content ID.
  * @param brand
  * @returns {Promise<Array>} response - The response object.
  * @returns {Promise<Object|null>} response.intro_video_response - The intro video completion response or null if already completed.
@@ -245,8 +252,11 @@ export async function completeMethodIntroVideo(introVideoId: number, brand: stri
 
   response.intro_video_response = await completeIfNotCompleted(introVideoId)
 
+  const methodStructure = await fetchMethodV2Structure(brand)
+  const learningPathId = methodStructure.learningPaths[0].id
+
   const url: string = `${LEARNING_PATHS_PATH}/start`
-  const body = { brand: brand }
+  const body = { learning_path_id: learningPathId, brand: brand }
   response.active_path_response = await fetchHandler(url, 'POST', null, body)
 
   return response
@@ -254,13 +264,18 @@ export async function completeMethodIntroVideo(introVideoId: number, brand: stri
 
 interface completeLearningPathIntroVideo {
   intro_video_response: Object | null,
-  learning_path_reset_response: void | Object[] | Object
+  learning_path_reset_response: void | null,
+  lesson_import_response: Object[] | null
 }
 /**
  * Handles completion of learning path intro video and other related actions.
- * @param introVideoId
- * @param learningPathId
- * @param lessonsToImport
+ * @param introVideoId - The learning path intro video content ID.
+ * @param learningPathId - The content_id of the learning path that this learning path intro video belongs to.
+ * @param lessonsToImport - content ids for all lessons with progress found during intro video progress check. empty if user chose not to keep learning path progress.
+ * @returns {Promise<Array>} response - The response object.
+ * @returns {Promise<Object|null>} response.intro_video_response - The intro video completion response or null if already completed.
+ * @returns {Promise<void>} response.learning_path_reset_response - The reset learning path response.
+ * @returns {Promise<Object[]>} response.lesson_import_response - The responses for completing each content_id within the learning path.
  */
 export async function completeLearningPathIntroVideo(introVideoId: number, learningPathId: number, lessonsToImport: number[] | null) {
   let response = {} as completeLearningPathIntroVideo
@@ -268,14 +283,13 @@ export async function completeLearningPathIntroVideo(introVideoId: number, learn
   response.intro_video_response = await completeIfNotCompleted(introVideoId)
 
   if (!lessonsToImport) {
-    // reset progress within the learning path
+    // returns nothing now, but it will when watermelon comes 'round
     response.learning_path_reset_response = await contentStatusReset(learningPathId)
   } else {
-    response.learning_path_reset_response = null
 
     // todo: add collection context + optimize with bulk calls with watermelon
     for (const contentId of lessonsToImport) {
-      response.learning_path_reset_response[contentId] = await contentStatusCompleted(contentId)
+      response.lesson_import_response[contentId] = await contentStatusCompleted(contentId)
     }
   }