musora-content-services 2.104.4 → 2.104.7

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

@@ -72,7 +72,7 @@ export async function getDailySession(brand: string, userDate: Date) {
 export async function updateDailySession(
   brand: string,
   userDate: Date,
-  keepFirstLearningPath: boolean
+  keepFirstLearningPath: boolean = false
 ) {
   const stringDate = userDate.toISOString().split('T')[0]
   const url: string = `${LEARNING_PATHS_PATH}/daily-session/create`
@@ -194,6 +194,23 @@ export function mapContentToParent(lessons, parentContentType, parentContentId)
   })
 }
 
+interface fetchLearningPathLessonsResponse {
+  id: number
+  thumbnail?: string
+  title: string
+  children: any[]
+  is_active_learning_path: boolean
+  active_learning_path_id?: number
+  active_learning_path_created_at?: string
+  upcoming_lessons?: any[]
+  completed_lessons?: any[]
+  learning_path_dailies?: any[]
+  next_learning_path_dailies?: any[]
+  next_learning_path_id?: number
+  previous_learning_path_dailies?: any[]
+  previous_learning_path_id?: number
+}
+
 /** Fetches and organizes learning path lessons.
  *
  * @param {number} learningPathId - The learning path ID.
@@ -203,13 +220,17 @@ export function mapContentToParent(lessons, parentContentType, parentContentId)
  * @returns {number} result.id - The learning path ID.
  * @returns {string} result.thumbnail - Optional thumbnail URL for the learning path.
  * @returns {string} result.title - The title of the learning path.
- * @returns {boolean} result.is_active_learning_path - Whether the learning path is currently active.
  * @returns {Array} result.children - Array of all lessons.
- * @returns {Array} result.upcoming_lessons - Array of upcoming/additional lessons.
- * @returns {Array} result.todays_lessons - Array of today's lessons (max 3).
- * @returns {Array} result.next_learning_path_lessons - Array of next lessons to be taken.
- * @returns {Array} result.completed_lessons - Array of completed lessons.
- * @returns {Array} result.previous_learning_path_todays - Array of completed lessons.
+ * @returns {boolean} result.is_active_learning_path - Whether the learning path is currently active.
+ * @returns {number} result.active_learning_path_id - The active learning path ID from daily session.
+ * @returns {string} result.active_learning_path_created_at - The datetime the learning path was set as active.
+ * @returns {Array} result.upcoming_lessons - Array of upcoming lessons.
+ * @returns {Array} result.learning_path_dailies - Array of today's dailies in this learning path.
+ * @returns {Array} result.next_learning_path_dailies - Array of today's dailies in the next learning path.
+ * @returns {number} result.next_learning_path_id - the next learning path (after the active path).
+ * @returns {Array} result.completed_lessons - Array of completed lessons in this learning path.
+ * @returns {Array} result.previous_learning_path_dailies - Array of today's dailies in the previous learning path.
+ * @returns {number} result.previous_learning_path_id - the previous learning path (before the active path)
  */
 export async function fetchLearningPathLessons(
   learningPathId: number,
@@ -217,9 +238,9 @@ export async function fetchLearningPathLessons(
   userDate: Date
 ) {
   const learningPath = await getEnrichedLearningPath(learningPathId)
-  let dailySession = await getDailySession(brand, userDate); // what if the call just fails, and a DS does exist?
+  let dailySession = await getDailySession(brand, userDate) as DailySessionResponse // what if the call just fails, and a DS does exist?
   if (!dailySession) {
-    dailySession = await updateDailySession(brand, userDate, false)
+    dailySession = await updateDailySession(brand, userDate, false) as DailySessionResponse
   }
 
   const isActiveLearningPath = (dailySession?.active_learning_path_id || 0) == learningPathId
@@ -227,48 +248,64 @@ export async function fetchLearningPathLessons(
     return {
       ...learningPath,
       is_active_learning_path: isActiveLearningPath,
-    }
+    } as fetchLearningPathLessonsResponse
   }
-  // this assumes that the first entry is active_path, based on user flows
-  const todayContentIds = dailySession.daily_session[0]?.content_ids || []
-  const todayLearningPathId = dailySession.daily_session[0]?.learning_path_id
 
-  const nextContentIds = dailySession.daily_session[1]?.content_ids || []
-  const nextLearningPathId = dailySession.daily_session[1]?.learning_path_id
+  let todayContentIds = []
+  let todayLearningPathId = null
+  let nextContentIds = []
+  let nextLearningPathId = null
+  let previousContentIds = []
+  let previousLearningPathId = null
+
+
+
+  for (const session of dailySession.daily_session) {
+    if (session.learning_path_id === learningPathId) {
+      todayContentIds = session.content_ids || []
+      todayLearningPathId = session.learning_path_id
+    } else {
+      if (!todayLearningPathId) {
+        previousContentIds = session.content_ids || []
+        previousLearningPathId = session.learning_path_id
+      } else if (!nextLearningPathId) {
+        nextContentIds = session.content_ids || []
+        nextLearningPathId = session.learning_path_id
+      }
+    }
+  }
 
   const completedLessons = []
   let thisLPDailies = []
   let nextLPDailies = []
-  let previousLearningPathTodays = []
+  let previousLPDailies = []
   const upcomingLessons = []
 
+  //previous/next never within LP
   learningPath.children.forEach((lesson: any) => {
     if (todayContentIds.includes(lesson.id)) {
       thisLPDailies.push(lesson)
-    } else if (lesson.progressStatus === 'completed') {
+    } else if (lesson.progressStatus === STATE.COMPLETED) {
       completedLessons.push(lesson)
     } else {
       upcomingLessons.push(lesson)
     }
   })
 
-  if (thisLPDailies.length == 0) {
-    // Daily sessions first lessons are not part of the active learning path, but next lessons are
-    // load todays lessons from previous learning path
-    previousLearningPathTodays = await getLearningPathLessonsByIds(
-      todayContentIds,
-      todayLearningPathId
+  if (previousContentIds.length !== 0) {
+    previousLPDailies = await getLearningPathLessonsByIds(
+      previousContentIds,
+      previousLearningPathId
     )
-  } else if ( // show next LP dailies if they exist
-    nextContentIds.length > 0
-  ) {
-    // Daily sessions first lessons are the active learning path and the next lessons are not
-    // load next lessons from next learning path
-    const lessons = await getLearningPathLessonsByIds(nextContentIds, nextLearningPathId)
-    nextLPDailies = lessons.map(lesson => ({
+  }
+  if (nextContentIds.length !== 0) {
+    nextLPDailies = await getLearningPathLessonsByIds(
+      nextContentIds,
+      nextLearningPathId
+    ).then(lessons => lessons.map(lesson => ({
       ...lesson,
-      in_next_learning_path: STATE.COMPLETED === learningPath.progressStatus
-    }))
+      in_next_learning_path: learningPath.progressStatus === STATE.COMPLETED
+    })))
   }
 
   return {
@@ -277,11 +314,12 @@ export async function fetchLearningPathLessons(
     active_learning_path_id: dailySession?.active_learning_path_id,
     active_learning_path_created_at: dailySession?.active_learning_path_created_at,
     upcoming_lessons: upcomingLessons,
-    todays_lessons: thisLPDailies,
-    next_learning_path_lessons: nextLPDailies,
-    next_learning_path_id: nextLearningPathId,
     completed_lessons: completedLessons,
-    previous_learning_path_todays: previousLearningPathTodays,
+    learning_path_dailies: thisLPDailies,
+    next_learning_path_dailies: nextLPDailies,
+    next_learning_path_id: nextLearningPathId,
+    previous_learning_path_dailies: previousLPDailies,
+    previous_learning_path_id: previousLearningPathId,
   }
 }
 
@@ -341,12 +379,14 @@ interface completeLearningPathIntroVideo {
   intro_video_response: SyncWriteDTO<ContentProgress, any> | null
   learning_path_reset_response: SyncWriteDTO<ContentProgress, any> | null
   lesson_import_response: SyncWriteDTO<ContentProgress, any> | null
+  update_dailies_response: DailySessionResponse | null
 }
 /**
  * Handles completion of learning path intro video and other related actions.
  * @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.
+ * @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<void>} response.learning_path_reset_response - The reset learning path response.
@@ -355,7 +395,8 @@ interface completeLearningPathIntroVideo {
 export async function completeLearningPathIntroVideo(
   introVideoId: number,
   learningPathId: number,
-  lessonsToImport: number[] | null
+  lessonsToImport: number[] | null,
+  brand: string | null
 ) {
   let response = {} as completeLearningPathIntroVideo
 
@@ -368,6 +409,15 @@ export async function completeLearningPathIntroVideo(
 
   } else {
     response.lesson_import_response = await contentStatusCompletedMany(lessonsToImport, collection)
+
+    const activePath = await getActivePath(brand)
+    if (activePath.active_learning_path_id === learningPathId) {
+      response.update_dailies_response = await updateDailySession(
+        brand,
+        getToday(),
+        true
+      )
+    }
   }
 
   return response

package/src/services/progress-row/method-card.js

@@ -6,7 +6,7 @@ import { getActivePath, fetchLearningPathLessons } from '../content-org/learning
 import { getToday } from '../dateUtils.js'
 import { fetchMethodV2IntroVideo } from '../sanity'
 import { getProgressState } from '../contentProgress'
-import { COLLECTION_TYPE } from '../sync/models/ContentProgress'
+import {COLLECTION_TYPE, STATE} from '../sync/models/ContentProgress'
 
 export async function getMethodCard(brand) {
   const introVideo = await fetchMethodV2IntroVideo(brand)
@@ -19,7 +19,7 @@ export async function getMethodCard(brand) {
 
   const activeLearningPath = await getActivePath(brand)
 
-  if (introVideoProgressState !== 'completed' || !activeLearningPath) {
+  if (introVideoProgressState !== STATE.COMPLETED || !activeLearningPath) {
     //startLearningPath('drumeo', 422533)
     const timestamp = Math.floor(Date.now() / 1000)
     const instructorText =
@@ -43,43 +43,57 @@ export async function getMethodCard(brand) {
       progressTimestamp: timestamp,
     }
   } else {
-    //TODO: Optimize loading of dailySessions/Path, should not need multiple requests
     const learningPath = await fetchLearningPathLessons(
       activeLearningPath.active_learning_path_id,
       brand,
       getToday()
     )
 
-    const allCompleted = learningPath?.todays_lessons.every(
-      (lesson) => lesson.progressStatus === 'completed'
-    )
-
-    const anyCompleted = learningPath?.todays_lessons.some(
-      (lesson) => lesson.progressStatus === 'completed'
-    )
-
-    const noneCompleted = learningPath?.todays_lessons.every(
-      (lesson) => lesson.progressStatus !== 'completed'
-    )
+    if (!learningPath) {
+      return null
+    }
 
-    const nextIncompleteLesson = learningPath?.todays_lessons.find(
-      (lesson) => lesson.progressStatus !== 'completed'
-    )
+    // need to calculate based on all dailies
+    const allDailies = [
+      ...learningPath.previous_learning_path_dailies,
+      ...learningPath.learning_path_dailies,
+      ...learningPath.next_learning_path_dailies
+    ]
+
+    let allDailiesCompleted = true;
+    let anyDailiesCompleted = false;
+    let noDailiesCompleted = true;
+    let nextIncompleteDaily = null;
+
+    for (const lesson of allDailies) {
+      if (lesson.progressStatus === STATE.COMPLETED) {
+        anyDailiesCompleted = true;
+        noDailiesCompleted = false;
+      } else {
+        allDailiesCompleted = false;
+        if (!nextIncompleteDaily) {
+          nextIncompleteDaily = lesson;
+        }
+      }
+      if (!allDailiesCompleted && anyDailiesCompleted && nextIncompleteDaily) {
+        break;
+      }
+    }
 
     // get the first incomplete lesson from upcoming and next learning path lessons
     const nextLesson = [
       ...learningPath?.upcoming_lessons,
-      ...learningPath?.next_learning_path_lessons,
-    ]?.find((lesson) => lesson.progressStatus !== 'completed')
+      ...learningPath?.next_learning_path_dailies,
+    ]?.find((lesson) => lesson.progressStatus !== STATE.COMPLETED)
 
     let ctaText, action
-    if (noneCompleted) {
+    if (noDailiesCompleted) {
       ctaText = 'Start Session'
-      action = getMethodActionCTA(nextIncompleteLesson)
-    } else if (anyCompleted && !allCompleted) {
+      action = getMethodActionCTA(nextIncompleteDaily)
+    } else if (anyDailiesCompleted && !allDailiesCompleted) {
       ctaText = 'Continue Session'
-      action = getMethodActionCTA(nextIncompleteLesson)
-    } else if (allCompleted) {
+      action = getMethodActionCTA(nextIncompleteDaily)
+    } else if (allDailiesCompleted) {
       ctaText = nextLesson ? 'Start Next Lesson' : 'Browse Lessons'
       action = nextLesson
         ? getMethodActionCTA(nextLesson)

package/src/services/sanity.js

@@ -1306,7 +1306,7 @@ export async function fetchByReference(
  * @returns {Promise<int|null>}
  */
 export async function fetchTopLevelParentId(railcontentId) {
-  const parentFilter = "railcontent_id in [...(^.parent_content_data[].id)]"
+  const parentFilter = 'railcontent_id in [...(^.parent_content_data[].id)]'
   const statusFilter = "&& status in ['scheduled', 'published', 'archived', 'unlisted']"
 
   const query = `*[railcontent_id == ${railcontentId}]{
@@ -1379,7 +1379,7 @@ export async function fetchHierarchy(railcontentId) {
 }
 
 function populateHierarchyLookups(currentLevel, data, parentId) {
-  const railcontentIdField = currentLevel.railcontent_id ? "railcontent_id" : "id";
+  const railcontentIdField = currentLevel.railcontent_id ? 'railcontent_id' : 'id'
 
   let contentId = currentLevel[railcontentIdField]
   let children = currentLevel['children']
@@ -1534,6 +1534,10 @@ function contentResultsDecorator(results, fieldName, callback) {
     results.related_lessons.forEach((result) => {
       result[fieldName] = callback(result)
     })
+  } else if (results.data && Array.isArray(results.data)) {
+    results.data.forEach((result) => {
+      result[fieldName] = callback(result)
+    })
   } else {
     results[fieldName] = callback(results)
   }
@@ -2017,7 +2021,7 @@ export async function fetchMethodV2Structure(brand) {
  * @returns {Promise<*|null>}
  */
 export async function fetchMethodV2StructureFromId(contentId) {
-  const _type = "method-v2";
+  const _type = 'method-v2'
   const query = `*[_type == '${_type}' && brand == *[railcontent_id == ${contentId}][0].brand][0...1]{
     'sanity_id': _id,
     brand,
@@ -2028,7 +2032,7 @@ export async function fetchMethodV2StructureFromId(contentId) {
       'children': child[]->railcontent_id
     }
   }`
-  return await fetchSanity(query, false);
+  return await fetchSanity(query, false)
 }
 
 /**