musora-content-services 2.28.6 → 2.30.3

package/src/services/content-org/playlists.js

@@ -3,6 +3,7 @@
  */
 import { globalConfig } from '../config.js'
 import { fetchHandler } from '../railcontent.js'
+import { getNavigateToForPlaylists } from '../contentAggregator.js'
 import './playlists-types.js'
 
 /**
@@ -42,7 +43,7 @@ export async function fetchUserPlaylists(
   const content = content_id ? `&content_id=${content_id}` : ''
   const brandString = brand ? `&brand=${brand}` : ''
   const url = `${BASE_PATH}/v1/user/playlists${pageString}${brandString}${limitString}${sortString}${content}`
-  return await fetchHandler(url)
+  return await getNavigateToForPlaylists(await fetchHandler(url), {dataField: 'data'})
 }
 
 /**
@@ -224,12 +225,13 @@ export async function togglePlaylistPrivate(playlistId, is_private)
  * Updates a playlists values
  *
  * @param {string|number} playlistId
- * @param {Object} updateData - An object containing fields to update on the playlist:
+ * @param {UpdatePlaylistDTO} updateData  - An object containing fields to update on the playlist:
  *  - `name` (string): The name of the new playlist (required, max 255 characters).
  *  - `description` (string): A description of the playlist (optional, max 1000 characters).
- *  - `category` (string): The category of the playlist.
- * + *  - `deleted_items` (array): List of playlist item IDs to delete.
- * + *  - `item_order` (array): Updated order of playlist items (ids, not railcontent_ids).
+ *  - `category` (string): The category of the playlist (optional).
+ *  - `is_private` (boolean): Whether the playlist is private (optional, defaults to false).
+ *  - `deleted_items` (array): List of playlist item IDs to delete (optional).
+ *  - `item_order` (array): Updated order of playlist items (ids, not railcontent_ids) (optional).
  *
  * @returns {Promise<object>} - A promise that resolves to the created playlist data and lessons if successful, or an error response if validation fails.
  *
@@ -242,16 +244,14 @@ export async function togglePlaylistPrivate(playlistId, is_private)
  *   .then(response => console.log(response.playlist); console.log(response.lessons))
  *   .catch(error => console.error('Error updating playlist:', error));
  */
-export async function updatePlaylist(playlistId, {
-  name = null, description = null,  is_private = null, brand = null, category = null, deleted_items = null, item_order = null
-})
+export async function updatePlaylist(playlistId, updateData)
 {
-  const data = {
+  const { name, description, category, is_private, item_order, deleted_items } = updateData;
+  let data = {
     ...name && { name },
-    ...description && { description },
-    ...is_private !== null && { private: is_private},
-    ...brand && { brand },
-    ...category && { category},
+    ...'description' in updateData && { description },
+    ...'is_private' in updateData && { private: is_private || false },
+    ...'category' in updateData && { category },
     ...deleted_items && { deleted_items },
     ...item_order && { item_order },
   }
@@ -344,7 +344,7 @@ export async function duplicatePlaylist(playlistId, playlistData) {
  */
 export async function fetchPlaylist(playlistId) {
   const url = `${BASE_PATH}/v1/user/playlists/${playlistId}`
-  return await fetchHandler(url, 'GET')
+  return await getNavigateToForPlaylists(await fetchHandler(url))
 }
 
 /**

package/src/services/content.js

@@ -80,6 +80,7 @@ export async function getTabResults(brand, pageName, tabName, {
     results = await addContextToContent(getLessonContentRows, brand, pageName, {
       dataField: 'items',
       addNextLesson: true,
+      addNavigateTo: true,
       addProgressPercentage: true,
       addProgressStatus: true
     })
@@ -87,6 +88,7 @@ export async function getTabResults(brand, pageName, tabName, {
     let temp =  await fetchTabData(brand, pageName, { page, limit, sort, includedFields: mergedIncludedFields, progress: progressValue });
     results = await addContextToContent(() => temp.entity, {
       addNextLesson: true,
+      addNavigateTo: true,
       addProgressPercentage: true,
       addProgressStatus: true
     })
@@ -382,7 +384,7 @@ export async function getRecommendedForYou(brand, rowId = null, {
   limit = 10,
 } = {}) {
   const requiredItems = page * limit;
-  const data = await recommendations(brand, {limit: requiredItems});
+  const data = await recommendations( brand, {limit: requiredItems})
   if (!data || !data.length) {
     return { id: 'recommended', title: 'Recommended For You', items: [] };
   }
@@ -390,14 +392,11 @@ export async function getRecommendedForYou(brand, rowId = null, {
   // Apply pagination before calling fetchByRailContentIds
   const startIndex = (page - 1) * limit;
   const paginatedData = data.slice(startIndex, startIndex + limit);
-
-  const contents = await fetchByRailContentIds(paginatedData);
-  const result = {
-    id: 'recommended',
-    title: 'Recommended For You',
-    items: contents
-  };
-
+  const contents = await addContextToContent(fetchByRailContentIds, paginatedData, 'tab-data',
+    {
+      addNextLesson: true,
+      addNavigateTo: true,
+    })
   if (rowId) {
     return {
       type: TabResponseType.CATALOG,

package/src/services/contentAggregator.js

@@ -1,6 +1,6 @@
 import {
-  getLastInteractedOf,
-  getNextLesson,
+  getLastInteractedOf, getNavigateTo,
+  getNextLesson, getProgressDateByIds,
   getProgressPercentageByIds,
   getProgressStateByIds,
   getResumeTimeSecondsByIds
@@ -28,6 +28,7 @@ import {fetchLastInteractedChild, fetchLikeCount} from "./railcontent"
  * @param options.addIsLiked - add isLikedField
  * @param options.addLikeCount - add likeCount field
  * @param options.addProgressStatus - add progressStatus field
+ * @param options.addProgressTimestamp - add progressTimestamp field
  * @param options.addResumeTimeSeconds - add resumeTimeSeconds field
  * @param options.addLastInteractedChild - add lastInteractedChild field. This may be different from nextLesson
  * @param options.addNextLesson - add nextLesson field. For collection type content. each collection has different logic for calculating this data
@@ -66,9 +67,11 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     addIsLiked = false,
     addLikeCount = false,
     addProgressStatus = false,
+    addProgressTimestamp = false,
     addResumeTimeSeconds = false,
     addLastInteractedChild = false,
     addNextLesson = false,
+    addNavigateTo = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
@@ -81,29 +84,63 @@ export async function addContextToContent(dataPromise, ...dataArgs)
 
   if(ids.length === 0) return false
 
-  const [progressPercentageData, progressStatusData, isLikedData, resumeTimeData, lastInteractedChildData, nextLessonData] = await Promise.all([
-    addProgressPercentage ? getProgressPercentageByIds(ids) : Promise.resolve(null),
-    addProgressStatus ? getProgressStateByIds(ids) : Promise.resolve(null),
+  const [progressData, isLikedData, resumeTimeData, lastInteractedChildData, nextLessonData, navigateToData] = await Promise.all([
+    addProgressPercentage || addProgressStatus || addProgressTimestamp ? getProgressDateByIds(ids) : Promise.resolve(null),
     addIsLiked ? isContentLikedByIds(ids) : Promise.resolve(null),
     addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids) : Promise.resolve(null),
     addLastInteractedChild ? fetchLastInteractedChild(ids)  : Promise.resolve(null),
     addNextLesson ? getNextLesson(items) : Promise.resolve(null),
+    addNavigateTo ? getNavigateTo(items) : Promise.resolve(null),
   ])
+  if (addNextLesson) console.log('AddNextLesson is depreciated in favour of addNavigateTo')
 
   const addContext = async (item) => ({
     ...item,
-    ...(addProgressPercentage ? { progressPercentage: progressPercentageData?.[item.id] } : {}),
-    ...(addProgressStatus ? { progressStatus: progressStatusData?.[item.id] } : {}),
+    ...(addProgressPercentage ? { progressPercentage: progressData?.[item.id]['progress'] } : {}),
+    ...(addProgressStatus ? { progressStatus: progressData?.[item.id]['status'] } : {}),
+    ...(addProgressTimestamp ? { progressTimestamp: progressData?.[item.id]['last_update'] } : {}),
     ...(addIsLiked ? { isLiked: isLikedData?.[item.id] } : {}),
     ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(item.id) } : {}),
     ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.id] } : {}),
     ...(addLastInteractedChild ? { lastInteractedChild: lastInteractedChildData?.[item.id] } : {}),
     ...(addNextLesson ? { nextLesson: nextLessonData?.[item.id] } : {}),
+    ...(addNavigateTo ? { navigateTo: navigateToData?.[item.id] } : {}),
   })
 
   return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
 }
 
+export async function getNavigateToForPlaylists(data, {dataField = null} = {} )
+{
+  let playlists = extractItemsFromData(data, dataField, false, false)
+  let allIds = []
+  playlists.forEach((playlist) => allIds = [...allIds, ...playlist.items.map(a => a.content_id)])
+  const progressOnItems = await getProgressStateByIds(allIds);
+  const addContext = async (playlist) => {
+    const allItemsCompleted = playlist.items.every(i => {
+      const itemId = i.content_id;
+      const progress = progressOnItems[itemId];
+      return progress && progress === 'completed';
+    });
+    let nextItem = playlist.items[0] ?? null;
+    if (!allItemsCompleted) {
+      const lastItemProgress = progressOnItems[playlist.last_engaged_on];
+      const index = playlist.items.findIndex(i => i.content_id === playlist.last_engaged_on);
+      if (lastItemProgress === 'completed') {
+        nextItem = playlist.items[index + 1] ?? nextItem;
+      } else {
+        nextItem = playlist.items[index] ?? nextItem;
+      }
+    }
+    playlist.navigateTo = {
+      ...nextItem,
+      playlist_id: playlist.id,
+    }
+    return playlist
+  }
+  return await processItems(data, addContext, dataField, false, false,)
+}
+
 function extractItemsFromData(data, dataField, isParentArray, includeParent)
 {
   let items = []
@@ -159,3 +196,4 @@ async function processItems(data, addContext, dataField, isParentArray, includeP
   }
 }
 
+

package/src/services/contentProgress.js

@@ -5,9 +5,9 @@ import {
   postRecordWatchSession,
 } from './railcontent.js'
 import { DataContext, ContentProgressVersionKey } from './dataContext.js'
-import {fetchHierarchy} from './sanity.js'
-import {recordUserPractice, findIncompleteLesson} from "./userActivity";
-import {getNextLessonLessonParentTypes} from "../contentTypeConfig.js";
+import { fetchHierarchy } from './sanity.js'
+import { recordUserPractice, findIncompleteLesson } from './userActivity'
+import { getNextLessonLessonParentTypes } from '../contentTypeConfig.js'
 
 const STATE_STARTED = 'started'
 const STATE_COMPLETED = 'completed'
@@ -45,22 +45,19 @@ export async function getResumeTimeSecondsByIds(contentIds) {
   return getByIds(contentIds, DATA_KEY_RESUME_TIME, 0)
 }
 
-export async function getNextLesson(data)
-{
+export async function getNextLesson(data) {
   let nextLessonData = {}
 
   for (const content of data) {
-    const children = content.children?.map(child => child.id) ?? []
+    const children = content.children?.map((child) => child.id) ?? []
     //only calculate nextLesson if needed, based on content type
     if (!getNextLessonLessonParentTypes.includes(content.type)) {
       nextLessonData[content.id] = null
-
     } else {
       //return first child if parent-content is complete or no progress
       const contentState = await getProgressState(content.id)
       if (contentState !== STATE_STARTED) {
         nextLessonData[content.id] = children[0]
-
       } else {
         const childrenStates = await getProgressStateByIds(children)
 
@@ -73,16 +70,23 @@ export async function getNextLesson(data)
           if (lastInteractedStatus === STATE_STARTED) {
             nextLessonData[content.id] = lastInteracted
           } else {
-            nextLessonData[content.id] = findIncompleteLesson(childrenStates, lastInteracted, content.type)
+            nextLessonData[content.id] = findIncompleteLesson(
+              childrenStates,
+              lastInteracted,
+              content.type
+            )
           }
-
         } else if (content.type === 'guided-course' || content.type === 'song-tutorial') {
-          nextLessonData[content.id] = findIncompleteLesson(childrenStates, lastInteracted, content.type)
+          nextLessonData[content.id] = findIncompleteLesson(
+            childrenStates,
+            lastInteracted,
+            content.type
+          )
         } else if (content.type === 'pack') {
           const packBundles = content.children ?? []
           const packBundleProgressData = await getNextLesson(packBundles)
-          const parentId = await getLastInteractedOf(packBundles.map(bundle => bundle.id));
-          nextLessonData[content.id] = packBundleProgressData[parentId];
+          const parentId = await getLastInteractedOf(packBundles.map((bundle) => bundle.id))
+          nextLessonData[content.id] = packBundleProgressData[parentId]
         }
       }
     }
@@ -90,6 +94,82 @@ export async function getNextLesson(data)
   return nextLessonData
 }
 
+export async function getNavigateTo(data) {
+  let navigateToData = {}
+  const twoDepthContentTypes = ['pack'] //TODO add method when we know what it's called
+  //TODO add parent hierarchy upwards as well
+  // data structure is the same but instead of child{} we use parent{}
+  for (const content of data) {
+    //only calculate nextLesson if needed, based on content type
+    if (!getNextLessonLessonParentTypes.includes(content.type) || !content.children) {
+      navigateToData[content.id] = null
+    } else {
+      const children = new Map()
+      const childrenIds = []
+      content.children.forEach((child) => {
+        childrenIds.push(child.id)
+        children.set(child.id, child)
+      })
+      // return first child (or grand child) if parent-content is complete or no progress
+      const contentState = await getProgressState(content.id)
+      if (contentState !== STATE_STARTED) {
+        const firstChild = content.children[0]
+        let lastInteractedChildNavToData =
+          (await getNavigateTo([firstChild])[firstChild.id]) ?? null
+        navigateToData[content.id] = buildNavigateTo(
+          content.children[0],
+          lastInteractedChildNavToData
+        )
+      } else {
+        const childrenStates = await getProgressStateByIds(childrenIds)
+        const lastInteracted = await getLastInteractedOf(childrenIds)
+        const lastInteractedStatus = childrenStates[lastInteracted]
+
+        if (content.type === 'course' || content.type === 'pack-bundle') {
+          if (lastInteractedStatus === STATE_STARTED) {
+            navigateToData[content.id] = buildNavigateTo(children.get(lastInteracted))
+          } else {
+            let incompleteChild = findIncompleteLesson(childrenStates, lastInteracted, content.type)
+            navigateToData[content.id] = buildNavigateTo(children.get(incompleteChild))
+          }
+        } else if (content.type === 'guided-course' || content.type === 'song-tutorial') {
+          let incompleteChild = findIncompleteLesson(childrenStates, lastInteracted, content.type)
+          navigateToData[content.id] = buildNavigateTo(children.get(incompleteChild))
+        } else if (twoDepthContentTypes.includes(content.type)) {
+          const firstChildren = content.children ?? []
+          const lastInteractedChildId = await getLastInteractedOf(
+            firstChildren.map((child) => child.id)
+          )
+          if (childrenStates[lastInteractedChildId] === STATE_COMPLETED) {
+            // TODO: packs have an extra situation where we need to jump to the next course if all lessons in the last engaged course are completed
+          }
+          let lastInteractedChildNavToData = await getNavigateTo(firstChildren)
+          lastInteractedChildNavToData = lastInteractedChildNavToData[lastInteractedChildId]
+          navigateToData[content.id] = buildNavigateTo(
+            children.get(lastInteractedChildId),
+            lastInteractedChildNavToData
+          )
+        }
+      }
+    }
+  }
+  return navigateToData
+}
+
+function buildNavigateTo(content, child = null) {
+  if (!content) {
+    return null
+  }
+
+  return {
+    brand: content.brand ?? '',
+    thumbnail: content.thumbnail ?? '',
+    id: content.id ?? null,
+    type: content.type ?? '',
+    child: child,
+  }
+}
+
 /**
  * filter through contents, only keeping the most recent
  * @param {array} contentIds
@@ -115,10 +195,14 @@ export async function getLastInteractedOf(contentIds) {
 export async function getProgressDateByIds(contentIds) {
   let data = await dataContext.getData()
   let progress = {}
-  contentIds?.forEach((id) => (progress[id] = {
-    'last_update': data[id]?.[DATA_KEY_LAST_UPDATED_TIME] ?? 0,
-    'progress': data[id]?.[DATA_KEY_PROGRESS] ?? 0,
-    'status': data[id]?.[DATA_KEY_STATUS] ?? ''}))
+  contentIds?.forEach(
+    (id) =>
+      (progress[id] = {
+        last_update: data[id]?.[DATA_KEY_LAST_UPDATED_TIME] ?? 0,
+        progress: data[id]?.[DATA_KEY_PROGRESS] ?? 0,
+        status: data[id]?.[DATA_KEY_STATUS] ?? '',
+      })
+  )
   return progress
 }
 
@@ -178,11 +262,16 @@ export async function getAllCompleted(limit = null) {
   return ids
 }
 
-export async function getAllStartedOrCompleted({ limit = null, onlyIds = true, brand = null, excludedIds = [] } = {}) {
+export async function getAllStartedOrCompleted({
+  limit = null,
+  onlyIds = true,
+  brand = null,
+  excludedIds = [],
+} = {}) {
   const data = await dataContext.getData()
   const oneMonthAgoInSeconds = Math.floor(Date.now() / 1000) - 60 * 24 * 60 * 60 // 60 days in seconds
 
-  const excludedSet = new Set(excludedIds.map(id => parseInt(id))) // ensure IDs are numbers
+  const excludedSet = new Set(excludedIds.map((id) => parseInt(id))) // ensure IDs are numbers
 
   let filtered = Object.entries(data)
     .filter(([key, item]) => {
@@ -240,13 +329,14 @@ export async function getAllStartedOrCompleted({ limit = null, onlyIds = true, b
  * const progressMap = await getStartedOrCompletedProgressOnly({ brand: 'drumeo' });
  * console.log(progressMap[123]); // => 52
  */
-export async function getStartedOrCompletedProgressOnly({ brand = null} = {}) {
+export async function getStartedOrCompletedProgressOnly({ brand = null } = {}) {
   const data = await dataContext.getData()
   const result = {}
 
   Object.entries(data).forEach(([key, item]) => {
     const id = parseInt(key)
-    const isRelevantStatus = item[DATA_KEY_STATUS] === STATE_STARTED || item[DATA_KEY_STATUS] === STATE_COMPLETED
+    const isRelevantStatus =
+      item[DATA_KEY_STATUS] === STATE_STARTED || item[DATA_KEY_STATUS] === STATE_COMPLETED
     const isCorrectBrand = !brand || item.b === brand
 
     if (isRelevantStatus && isCorrectBrand) {
@@ -360,7 +450,7 @@ export async function recordWatchSession(
   secondsPlayed,
   sessionId = null,
   instrumentId = null,
-  categoryId = null,
+  categoryId = null
 ) {
   let mediaTypeId = getMediaTypeId(mediaType, mediaCategory)
   let updateLocalProgress = mediaTypeId === 1 || mediaTypeId === 2 //only update for video playback
@@ -371,10 +461,16 @@ export async function recordWatchSession(
   try {
     //TODO: Good enough for Alpha, Refine in reliability improvements
     sessionData[sessionId] = sessionData[sessionId] || {}
-    const secondsSinceLastUpdate = Math.ceil(secondsPlayed - (sessionData[sessionId][contentId] ?? 0))
-    await recordUserPractice({ content_id: contentId, duration_seconds: secondsSinceLastUpdate,  instrument_id: instrumentId })
+    const secondsSinceLastUpdate = Math.ceil(
+      secondsPlayed - (sessionData[sessionId][contentId] ?? 0)
+    )
+    await recordUserPractice({
+      content_id: contentId,
+      duration_seconds: secondsSinceLastUpdate,
+      instrument_id: instrumentId,
+    })
   } catch (error) {
-      console.error('Failed to record user practice:', error)
+    console.error('Failed to record user practice:', error)
   }
   sessionData[sessionId][contentId] = secondsPlayed
 
@@ -439,7 +535,7 @@ function bubbleProgress(hierarchy, contentId, localContext) {
     return localContext.data[childId]?.[DATA_KEY_PROGRESS] ?? 0
   })
   let progress = Math.round(childProgress.reduce((a, b) => a + b, 0) / childProgress.length)
-  const brand =localContext.data[contentId]?.[DATA_KEY_BRAND] ?? null
+  const brand = localContext.data[contentId]?.[DATA_KEY_BRAND] ?? null
   data[DATA_KEY_PROGRESS] = progress
   data[DATA_KEY_STATUS] = progress === 100 ? STATE_COMPLETED : STATE_STARTED
   data[DATA_KEY_LAST_UPDATED_TIME] = Math.round(new Date().getTime() / 1000)