musora-content-services 2.77.2 → 2.79.0

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

@@ -5,9 +5,25 @@
 import { fetchHandler } from '../railcontent.js'
 import { fetchByRailContentId, fetchByRailContentIds, fetchMethodV2Structure } from '../sanity.js'
 import { addContextToContent } from '../contentAggregator.js'
-import { getProgressStateByIds } from '../contentProgress.js'
+import {
+  contentStatusCompleted,
+  contentStatusReset,
+  getProgressState,
+  getProgressStateByIds
+} from '../contentProgress.js'
 
 const BASE_PATH: string = `/api/content-org`
+const LEARNING_PATHS_PATH = `${BASE_PATH}/v1/user/learning-paths`
+
+interface ActiveLearningPathResponse {
+  user_id: number,
+  brand: string,
+  active_learning_path_id: number,
+}
+
+
+
+
 
 /**
  * Gets today's daily session for the user.
@@ -16,7 +32,7 @@ const BASE_PATH: string = `/api/content-org`
  */
 export async function getDailySession(brand: string, userDate: Date) {
   const stringDate = userDate.toISOString().split('T')[0]
-  const url: string = `${BASE_PATH}/v1/user/learning-paths/daily-session/get-or-create`
+  const url: string = `${LEARNING_PATHS_PATH}/daily-session/get-or-create`
   const body = { brand: brand, userDate: stringDate }
   return await fetchHandler(url, 'POST', null, body)
 }
@@ -33,7 +49,7 @@ export async function updateDailySession(
   keepFirstLearningPath: boolean
 ) {
   const stringDate = userDate.toISOString().split('T')[0]
-  const url: string = `${BASE_PATH}/v1/user/learning-paths/daily-session/update`
+  const url: string = `${LEARNING_PATHS_PATH}/daily-session/update`
   const body = { brand: brand, userDate: stringDate, keepFirstLearningPath: keepFirstLearningPath }
   return await fetchHandler(url, 'POST', null, body)
 }
@@ -43,17 +59,19 @@ export async function updateDailySession(
  * @param brand
  */
 export async function getActivePath(brand: string) {
-  const url: string = `${BASE_PATH}/v1/user/learning-paths/active-path/get-or-create`
+  const url: string = `${LEARNING_PATHS_PATH}/active-path/get-or-create`
   const body = { brand: brand }
   return await fetchHandler(url, 'POST', null, body)
 }
 
+// todo this should be removed once we handle active path gen only through
+//  finish method intro or complete current active path
 /**
  * Updates user's active learning path.
  * @param brand
  */
 export async function updateActivePath(brand: string) {
-  const url: string = `${BASE_PATH}/v1/user/learning-paths/active-path/update`
+  const url: string = `${LEARNING_PATHS_PATH}/active-path/update`
   const body = { brand: brand }
   return await fetchHandler(url, 'POST', null, body)
 }
@@ -64,7 +82,7 @@ export async function updateActivePath(brand: string) {
  * @param learningPathId
  */
 export async function startLearningPath(brand: string, learningPathId: number) {
-  const url: string = `${BASE_PATH}/v1/user/learning-paths/start`
+  const url: string = `${LEARNING_PATHS_PATH}/start`
   const body = { brand: brand, learning_path_id: learningPathId }
   return await fetchHandler(url, 'POST', null, body)
 }
@@ -73,7 +91,7 @@ export async function startLearningPath(brand: string, learningPathId: number) {
  * Resets the user's learning path.
  */
 export async function resetAllLearningPaths() {
-  const url: string = `${BASE_PATH}/v1/user/learning-paths/reset`
+  const url: string = `${LEARNING_PATHS_PATH}/reset`
   return await fetchHandler(url, 'POST', null, {})
 }
 
@@ -82,8 +100,8 @@ export async function resetAllLearningPaths() {
  * @param {number} learningPathId - The learning path ID
  * @returns {Promise<Object>} Learning path with enriched lesson data
  */
-export async function getLearningPath(learningPathId) {
-  //TODO: must be a cleaner way to do this
+export async function getEnrichedLearningPath(learningPathId) {
+  //TODO BEH-1410: refactor/cleanup
   let learningPath = await fetchByRailContentId(learningPathId, 'learning-path-v2')
   learningPath.children = mapContentToParent(
     learningPath.children,
@@ -109,10 +127,16 @@ export async function getLearningPath(learningPathId) {
 export async function getLearningPathLessonsByIds(contentIds, learningPathId) {
   // It is more efficient to load the entire learning path than individual lessons
   // Also adds reliability check whether content is actually in the learning path
-  const learningPath = await getLearningPath(learningPathId)
+  const learningPath = await getEnrichedLearningPath(learningPathId)
   return learningPath.children.filter((lesson) => contentIds.includes(lesson.id))
 }
 
+/**
+ * Maps content to its parent learning path - fixes multi-parent problems for cta when lessons have a special collection.
+ * @param lessons
+ * @param parentContentType
+ * @param parentContentId
+ */
 export function mapContentToParent(lessons, parentContentType, parentContentId) {
   return lessons.map((lesson: any) => {
     return { ...lesson, type: parentContentType, parent_id: parentContentId }
@@ -142,7 +166,7 @@ export async function fetchLearningPathLessons(
   userDate: Date
 ) {
   const [learningPath, dailySession] = await Promise.all([
-    getLearningPath(learningPathId),
+    getEnrichedLearningPath(learningPathId),
     getDailySession(brand, userDate),
   ])
 
@@ -203,3 +227,64 @@ export async function fetchLearningPathLessons(
     previous_learning_path_todays: previousLearningPathTodays,
   }
 }
+
+interface completeMethodIntroVideo {
+  intro_video_response: Object | null,
+  active_path_response: ActiveLearningPathResponse
+}
+/**
+ * Handles completion of method intro video and other related actions.
+ * @param introVideoId - The 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.
+ * @returns {Promise<Object>} response.active_path_response - The set active learning path response.
+ */
+export async function completeMethodIntroVideo(introVideoId: number, brand: string): Promise<completeMethodIntroVideo> {
+  let response = {} as completeMethodIntroVideo
+
+  response.intro_video_response = await completeIfNotCompleted(introVideoId)
+
+  const url: string = `${LEARNING_PATHS_PATH}/start`
+  const body = { brand: brand }
+  response.active_path_response = await fetchHandler(url, 'POST', null, body)
+
+  return response
+}
+
+interface completeLearningPathIntroVideo {
+  intro_video_response: Object | null,
+  learning_path_reset_response: void | Object[] | Object
+}
+/**
+ * Handles completion of learning path intro video and other related actions.
+ * @param introVideoId
+ * @param learningPathId
+ * @param lessonsToImport
+ */
+export async function completeLearningPathIntroVideo(introVideoId: number, learningPathId: number, lessonsToImport: number[] | null) {
+  let response = {} as completeLearningPathIntroVideo
+
+  response.intro_video_response = await completeIfNotCompleted(introVideoId)
+
+  if (!lessonsToImport) {
+    // reset progress within the learning path
+    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)
+    }
+  }
+
+  return response
+}
+
+
+async function completeIfNotCompleted(contentId: number): Promise<Object | null> {
+  const introVideoStatus = await getProgressState(contentId)
+
+  return introVideoStatus !== 'completed' ? await contentStatusCompleted(contentId) : null
+}

package/src/services/contentAggregator.js

@@ -136,19 +136,22 @@ export async function getNavigateToForPlaylists(data, { dataField = null } = {})
   )
   const progressOnItems = await getProgressStateByIds(allIds)
   const addContext = async (playlist) => {
-    const allItemsCompleted = playlist.items.every((i) => {
+    // Filter out locked items (where need_access === true) and scheduled content
+    const accessibleItems = playlist.items.filter((item) => !item.need_access && item.status !== 'scheduled')
+
+    const allItemsCompleted = accessibleItems.every((i) => {
       const itemId = i.content_id
       const progress = progressOnItems[itemId]
       return progress && progress === 'completed'
     })
-    let nextItem = playlist.items[0] ?? null
+    let nextItem = accessibleItems[0] ?? null
     if (!allItemsCompleted) {
       const lastItemProgress = progressOnItems[playlist.last_engaged_on]
-      const index = playlist.items.findIndex((i) => i.content_id === playlist.last_engaged_on)
+      const index = accessibleItems.findIndex((i) => i.content_id === playlist.last_engaged_on)
       if (lastItemProgress === 'completed') {
-        nextItem = playlist.items[index + 1] ?? nextItem
+        nextItem = accessibleItems[index + 1] ?? nextItem
       } else {
-        nextItem = playlist.items[index] ?? nextItem
+        nextItem = accessibleItems[index] ?? nextItem
       }
     }
     playlist.navigateTo = {

package/src/services/forums/categories.ts

@@ -43,7 +43,7 @@ export async function createForumCategory(
 
 export interface UpdateForumCategoryParams {
   id: number
-  brand: number
+  brand: string
   name: string
   weight: number
   description?: string

package/src/services/gamification/awards.ts

@@ -11,8 +11,16 @@ const baseUrl = `/api/gamification`
 export interface Award {
   id: number
   user_id: number
-  completed_at: string          // ISO-8601 timestamp
-  completion_data: Object
+  completed_at: string // ISO-8601 timestamp
+  completion_data: {
+    message?: string
+    message_certificate?: string
+    content_title?: string
+    completed_at?: Date
+    days_user_practiced?: number
+    practice_minutes?: number
+    [key: string]: any
+  }
   award_id: number
   type: string
   title: string
@@ -23,7 +31,7 @@ export interface Certificate {
   id: number
   user_name: string
   user_id: number
-  completed_at: string          // ISO-8601 timestamp
+  completed_at: string // ISO-8601 timestamp
   message: string
   award_id: number
   type: string
@@ -42,6 +50,7 @@ export interface Certificate {
   instructor_signature?: string
   instructor_signature_64?: string
 }
+
 /**
  * Get awards for a specific user.
  *
@@ -49,18 +58,23 @@ export interface Certificate {
  * (Alexandre: I'm doing it in a different branch/PR: https://github.com/railroadmedia/musora-content-services/pull/349)
  * NOTE: This function still expects brand because FE passes the argument. It is ignored for now
  *
- * @param {number} userId - The user ID. If not provided, the authenticated user is used instead.
- * @param {string} _brand - The brand to fetch the awards for.
+ * @param {number|null} [userId] - The user ID. If not provided, the authenticated user is used instead.
+ * @param {string|null} [_brand] - The brand to fetch the awards for.
  * @param {number|null} [page=1] - Page attribute for pagination
  * @param {number|null} [limit=5] - Limit how many items to return
  * @returns {Promise<PaginatedResponse<Award>>} - The awards for the user.
+ * @throws {HttpError} - If the HTTP request fails.
  */
 export async function fetchAwardsForUser(
-  userId: number,
-  _brand: string,
+  userId?: number,
+  _brand?: string,
   page: number = 1,
   limit: number = 5
 ): Promise<PaginatedResponse<Award>> {
+  if (!userId) {
+    userId = Number.parseInt(globalConfig.sessionConfig.userId)
+  }
+
   const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
   const response = await httpClient.get<PaginatedResponse<Award>>(
     `${baseUrl}/v1/users/${userId}/awards?limit=${limit}&page=${page}`
@@ -78,10 +92,9 @@ export async function fetchAwardsForUser(
  *
  * @param {number} guidedCourseLessonId - The guided course lesson Id
  * @returns {Promise<Award>} - The award data for a given award and given user.
+ * @throws {HttpError} - If the HTTP request fails.
  */
-export async function getAwardDataForGuidedContent(
-  guidedCourseLessonId,
-): Promise<Award> {
+export async function getAwardDataForGuidedContent(guidedCourseLessonId: number): Promise<Award> {
   const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
   const response = await httpClient.get<Award>(
     `${baseUrl}/v1/users/guided_course_award/${guidedCourseLessonId}`
@@ -99,6 +112,7 @@ export async function getAwardDataForGuidedContent(
  *
  * @param {number} userAwardId - The user award progress id
  * @returns {Promise<Certificate>} - The certificate data for the completed user award.
+ * @throws {HttpError} - If the HTTP request fails.
  */
 export async function fetchCertificate(userAwardId: number): Promise<Certificate> {
   const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)

package/src/services/sanity.js

@@ -904,6 +904,7 @@ export async function fetchFoundation(slug) {
  * @param {string} slug - The slug of the method.
  * @returns {Promise<Object|null>} - The fetched methods data or null if not found.
  */
+//todo BEH-1446 depreciated. remove all old method functions
 export async function fetchMethod(brand, slug) {
   const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()