musora-content-services 2.75.0 → 2.77.0

package/src/services/contentAggregator.js

@@ -1,12 +1,14 @@
 import {
-  getLastInteractedOf, getNavigateTo,
-  getNextLesson, getProgressDateByIds,
+  getLastInteractedOf,
+  getNavigateTo,
+  getNextLesson,
+  getProgressDateByIds,
   getProgressPercentageByIds,
   getProgressStateByIds,
-  getResumeTimeSecondsByIds
-} from "./contentProgress"
-import {isContentLikedByIds} from "./contentLikes"
-import {fetchLastInteractedChild, fetchLikeCount} from "./railcontent"
+  getResumeTimeSecondsByIds,
+} from './contentProgress'
+import { isContentLikedByIds } from './contentLikes'
+import { fetchLastInteractedChild, fetchLikeCount } from './railcontent'
 
 /**
  * Combine sanity data with BE contextual data.
@@ -57,8 +59,7 @@ import {fetchLastInteractedChild, fetchLikeCount} from "./railcontent"
 
 // need to add method support.
 // this means returning collection_type and collection_id
-export async function addContextToContent(dataPromise, ...dataArgs)
-{
+export async function addContextToContent(dataPromise, ...dataArgs) {
   const lastArg = dataArgs[dataArgs.length - 1]
   const options = typeof lastArg === 'object' && !Array.isArray(lastArg) ? lastArg : {}
 
@@ -80,18 +81,27 @@ export async function addContextToContent(dataPromise, ...dataArgs)
 
   let data = await dataPromise(...dataParam)
   const isDataAnArray = Array.isArray(data)
-  if(isDataAnArray && data.length === 0) return data
-  if(!data) return false
+  if (isDataAnArray && data.length === 0) return data
+  if (!data) return false
 
   const items = extractItemsFromData(data, dataField, isDataAnArray, dataField_includeParent) ?? []
-  const ids = items.map(item => item?.id).filter(Boolean)
-  if(ids.length === 0) return data
+  const ids = items.map((item) => item?.id).filter(Boolean)
+  if (ids.length === 0) return data
 
-  const [progressData, isLikedData, resumeTimeData, lastInteractedChildData, nextLessonData, navigateToData] = await Promise.all([
-    addProgressPercentage || addProgressStatus || addProgressTimestamp ? getProgressDateByIds(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),
+    addLastInteractedChild ? fetchLastInteractedChild(ids) : Promise.resolve(null),
     addNextLesson ? getNextLesson(items) : Promise.resolve(null),
     addNavigateTo ? getNavigateTo(items) : Promise.resolve(null),
   ])
@@ -105,33 +115,40 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(item.id) } : {}),
     ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.id] } : {}),
     ...(addLastInteractedChild ? { lastInteractedChild: lastInteractedChildData?.[item.id] } : {}),
-    ...(addNextLesson ? { nextLesson: nextLessonData?.[item.id] } : {}),
+    ...(addNextLesson
+      ? {
+          nextLesson: nextLessonData?.[item.id], //deprecated
+          next_lesson_id: nextLessonData?.[item.id],
+          next_lesson: item?.children?.find((child) => child.id === nextLessonData?.[item.id]),
+        }
+      : {}),
     ...(addNavigateTo ? { navigateTo: navigateToData?.[item.id] } : {}),
   })
 
   return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
 }
 
-export async function getNavigateToForPlaylists(data, {dataField = null} = {} )
-{
+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);
+  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;
+    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);
+      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;
+        nextItem = playlist.items[index + 1] ?? nextItem
       } else {
-        nextItem = playlist.items[index] ?? nextItem;
+        nextItem = playlist.items[index] ?? nextItem
       }
     }
     playlist.navigateTo = {
@@ -140,11 +157,10 @@ export async function getNavigateToForPlaylists(data, {dataField = null} = {} )
     }
     return playlist
   }
-  return await processItems(data, addContext, dataField, false, false,)
+  return await processItems(data, addContext, dataField, false, false)
 }
 
-function extractItemsFromData(data, dataField, isParentArray, includeParent)
-{
+function extractItemsFromData(data, dataField, isParentArray, includeParent) {
   let items = []
   if (dataField) {
     if (isParentArray) {
@@ -164,18 +180,17 @@ function extractItemsFromData(data, dataField, isParentArray, includeParent)
       }
     }
   } else if (Array.isArray(data)) {
-    items = data;
+    items = data
   } else if (data?.id) {
     items = [data]
   }
   return items
 }
 
-async function processItems(data, addContext, dataField, isParentArray, includeParent)
-{
+async function processItems(data, addContext, dataField, isParentArray, includeParent) {
   if (dataField) {
     if (isParentArray) {
-      for(let parent of data) {
+      for (let parent of data) {
         parent[dataField] = Array.isArray(parent[dataField])
           ? await Promise.all(parent[dataField].map(addContext))
           : await addContext(parent[dataField])
@@ -186,16 +201,10 @@ async function processItems(data, addContext, dataField, isParentArray, includeP
         : await addContext(data[dataField])
     }
     if (includeParent) {
-      data = isParentArray
-        ? await Promise.all(data.map(addContext))
-        : await addContext(data)
+      data = isParentArray ? await Promise.all(data.map(addContext)) : await addContext(data)
     }
     return data
   } else {
-    return Array.isArray(data)
-      ? await Promise.all(data.map(addContext))
-      : await addContext(data)
+    return Array.isArray(data) ? await Promise.all(data.map(addContext)) : await addContext(data)
   }
 }
-
-

package/src/services/contentProgress.js

@@ -67,7 +67,7 @@ export async function getNextLesson(data) {
         const lastInteractedStatus = childrenStates[lastInteracted]
 
         //different nextLesson behaviour for different content types
-        if (content.type === 'course' || content.type === 'pack-bundle') {
+        if (content.type === 'course' || content.type === 'pack-bundle' || content.type === 'skill-pack') {
           if (lastInteractedStatus === STATE_STARTED) {
             nextLessonData[content.id] = lastInteracted
           } else {
@@ -117,16 +117,13 @@ export async function getNavigateTo(data) {
         const firstChild = content.children[0]
         let lastInteractedChildNavToData = await getNavigateTo([firstChild])
         lastInteractedChildNavToData = lastInteractedChildNavToData[firstChild.id] ?? null
-        navigateToData[content.id] = buildNavigateTo(
-          firstChild,
-          lastInteractedChildNavToData
-        )
+        navigateToData[content.id] = buildNavigateTo(firstChild, 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 (content.type === 'course' || content.type === 'pack-bundle' || content.type === 'skill-pack') {
           if (lastInteractedStatus === STATE_STARTED) {
             navigateToData[content.id] = buildNavigateTo(children.get(lastInteracted))
           } else {
@@ -265,7 +262,6 @@ export async function getAllCompleted(limit = null) {
   return ids
 }
 
-// todo: either refactor to use watermelon, or add method functionality to dataContext (more work overall)
 export async function getAllStartedOrCompleted({
   limit = null,
   onlyIds = true,
@@ -401,7 +397,12 @@ function startStatusInLocalContext(localContext, contentId, hierarchy) {
   setStartedOrCompletedStatusInLocalContext(localContext, contentId, false, hierarchy)
 }
 
-function setStartedOrCompletedStatusInLocalContext(localContext, contentId, isCompleted, hierarchy) {
+function setStartedOrCompletedStatusInLocalContext(
+  localContext,
+  contentId,
+  isCompleted,
+  hierarchy
+) {
   let data = localContext.data[contentId] ?? {}
   data[DATA_KEY_PROGRESS] = isCompleted ? 100 : 0
   data[DATA_KEY_STATUS] = isCompleted ? STATE_COMPLETED : STATE_STARTED

package/src/services/forums/posts.ts

@@ -5,6 +5,7 @@ import { HttpClient } from '../../infrastructure/http/HttpClient'
 import { globalConfig } from '../config.js'
 import { ForumPost } from './types'
 import { PaginatedResponse } from '../api/types'
+import { markThreadAsRead } from './threads'
 
 const baseUrl = `/api/forums`
 
@@ -47,6 +48,7 @@ export interface FetchPostParams {
 }
 /**
  * Fetches posts for the given thread.
+ * Automatically marks the thread as read when posts are fetched.
  *
  * @param {number} threadId - The ID of the forum thread.
  * @param {string} brand - The brand context (e.g., "drumeo", "singeo").
@@ -71,6 +73,12 @@ export async function fetchPosts(
   const query = new URLSearchParams(queryObj).toString()
 
   const url = `${baseUrl}/v1/threads/${threadId}/posts?${query}`
+
+  // Mark thread as read in background (non-blocking)
+  markThreadAsRead(threadId, brand).catch(error => {
+    console.error('Failed to mark thread as read:', error)
+  })
+
   return httpClient.get<PaginatedResponse<ForumPost>>(url)
 }
 
@@ -165,6 +173,7 @@ export async function search(
 
 /**
  * Fetches posts for the given post, jumping to the post's location in the thread.
+ * Automatically marks the thread as read when posts are fetched.
  *
  * @param {number} postId - The ID of the forum post.
  * @param {string} brand - The brand context (e.g., "drumeo", "singeo").
@@ -189,5 +198,15 @@ export async function jumpToPost(
   const query = new URLSearchParams(queryObj).toString()
 
   const url = `${baseUrl}/v1/posts/${postId}/jump?${query}`
-  return httpClient.get<PaginatedResponse<ForumPost>>(url)
+  const response = await httpClient.get<PaginatedResponse<ForumPost>>(url)
+
+  // Mark thread as read in background (non-blocking)
+  // Extract thread from first post if available
+  if (response.data.length > 0 && response.data[0].thread?.id) {
+    markThreadAsRead(response.data[0].thread.id, brand).catch(error => {
+      console.error('Failed to mark thread as read:', error)
+    })
+  }
+
+  return response
 }

package/src/services/forums/threads.ts

@@ -59,7 +59,7 @@ export async function updateThread(
  */
 export async function followThread(threadId: number, brand: string): Promise<void> {
   const httpClient = new HttpClient(globalConfig.baseUrl)
-  return httpClient.post<void>(`${baseUrl}/v1/threads/${threadId}/follow`, { brand })
+  return httpClient.put<void>(`${baseUrl}/v1/threads/${threadId}/follow`, { brand })
 }
 
 /**
@@ -75,6 +75,19 @@ export async function unfollowThread(threadId: number, brand: string): Promise<v
   return httpClient.delete<void>(`${baseUrl}/v1/threads/${threadId}/follow?brand=${brand}`)
 }
 
+/**
+ * Marks a thread as read for the authenticated user.
+ *
+ * @param {number} threadId - The ID of the thread to mark as read.
+ * @param {string} brand - The brand context (e.g., "drumeo", "singeo").
+ * @return {Promise<void>} - A promise that resolves when the thread is marked as read.
+ * @throws {HttpError} - If the request fails.
+ */
+export async function markThreadAsRead(threadId: number, brand: string): Promise<void> {
+  const httpClient = new HttpClient(globalConfig.baseUrl)
+  return httpClient.put<void>(`${baseUrl}/v1/threads/${threadId}/read?brand=${brand}`, {})
+}
+
 export interface FetchThreadParams {
   is_followed?: boolean,
   page?: number,

package/src/services/forums/types.ts

@@ -13,6 +13,7 @@ export interface ForumPost {
   author: ForumUser | null
   like_count: number
   is_liked: boolean
+  thread?: { id: number; title?: string; slug?: string }
 }
 
 export interface ForumThread {

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

@@ -4,21 +4,22 @@
 
 import {
   getDailySession,
+  getActivePath,
   resetAllLearningPaths,
   startLearningPath,
-} from '../content-org/learning-paths.ts'
+  fetchLearningPathLessons,
+} from '../content-org/learning-paths'
 import { getToday } from '../dateUtils.js'
 import { fetchByRailContentId, fetchByRailContentIds, fetchMethodV2IntroVideo } from '../sanity'
 import { addContextToContent } from '../contentAggregator.js'
+import { getProgressState } from '../contentProgress'
 
 export async function getMethodCard(brand) {
-  const dailySession = await getDailySession(brand, getToday())
-  const activeLearningPathId = dailySession?.active_learning_path_id
+  const introVideo = await fetchMethodV2IntroVideo(brand)
+  const introVideoProgressState = await getProgressState(introVideo.id)
   //resetAllLearningPaths()
-  if (!activeLearningPathId) {
+  if (introVideoProgressState != 'completed') {
     //startLearningPath('drumeo', 422533)
-
-    const introVideo = await fetchMethodV2IntroVideo(brand)
     const timestamp = Math.floor(Date.now() / 1000)
     return {
       id: 0, // method card has no id
@@ -36,36 +37,30 @@ export async function getMethodCard(brand) {
       progressTimestamp: timestamp,
     }
   } else {
-    const todayContentIds = dailySession.daily_session[0]?.content_ids || []
-    const nextContentIds = dailySession.daily_session[1]?.content_ids || []
+    //TODO: Optimize loading of dailySessions/Path, should not need multiple requests
+    const activeLearningPath = await getActivePath(brand)
+    const learningPath = await fetchLearningPathLessons(
+      activeLearningPath.active_learning_path_id,
+      brand,
+      getToday()
+    )
 
-    const addContextParameters = {
-      addProgressStatus: true,
-      addProgressPercentage: true,
-      addProgressTimestamp: true,
-    }
-    const todaysLessons = await addContextToContent(
-      fetchByRailContentIds,
-      todayContentIds,
-      addContextParameters
+    const allCompleted = learningPath?.todays_lessons.every(
+      (lesson) => lesson.progressStatus === 'completed'
+    )
+    const anyCompleted = learningPath?.todays_lessons.some(
+      (lesson) => lesson.progressStatus === 'completed'
     )
-    const nextLPLessons = await addContextToContent(
-      fetchByRailContentIds,
-      nextContentIds,
-      addContextParameters
+    const noneCompleted = learningPath?.todays_lessons.every(
+      (lesson) => lesson.progressStatus !== 'completed'
     )
-    const allCompleted = todaysLessons.every((lesson) => lesson.progressStatus === 'completed')
-    const anyCompleted = todaysLessons.some((lesson) => lesson.progressStatus === 'completed')
-    const noneCompleted = todaysLessons.every((lesson) => lesson.progressStatus !== 'completed')
 
-    const nextIncompleteLesson = todaysLessons.find(
+    const nextIncompleteLesson = learningPath?.todays_lessons.find(
       (lesson) => lesson.progressStatus !== 'completed'
     )
-    let maxProgressTimestamp = Math.max(...todaysLessons.map((lesson) => lesson.progressTimestamp))
-    if (!maxProgressTimestamp) {
-      maxProgressTimestamp = dailySession.active_learning_path_created_at
-    }
-    let ctaText, action
+    let ctaText,
+      action,
+      nextLesson = null
     if (noneCompleted) {
       ctaText = 'Start Session'
       action = getMethodActionCTA(nextIncompleteLesson)
@@ -73,26 +68,28 @@ export async function getMethodCard(brand) {
       ctaText = 'Continue Session'
       action = getMethodActionCTA(nextIncompleteLesson)
     } else if (allCompleted) {
-      //TODO:: get next lessons when all completed
-      const nextAvailableLesson = null
-
-      ctaText = nextAvailableLesson ? 'Start Next Lesson' : 'Browse Lessons'
-      action = nextAvailableLesson
-        ? getMethodActionCTA(nextAvailableLesson)
+      ctaText = learningPath.next_lesson ? 'Start Next Lesson' : 'Browse Lessons'
+      action = learningPath.next_lesson
+        ? getMethodActionCTA(learningPath.next_lesson)
         : {
             type: 'lessons',
             brand: brand,
           }
     }
+
+    let maxProgressTimestamp = Math.max(
+      ...learningPath?.children.map((lesson) => lesson.progressTimestamp)
+    )
+    if (!maxProgressTimestamp) {
+      maxProgressTimestamp = learningPath.active_learning_path_created_at
+    }
+
     return {
       id: 0,
-      type: 'method',
+      type: 'learning-path-v2',
       progressType: 'content',
       header: 'Method',
-      body: {
-        todays_lessons: todaysLessons,
-        next_learning_path_lessons: nextLPLessons,
-      },
+      body: learningPath,
       cta: {
         text: ctaText,
         action: action,

package/src/services/sanity.js

@@ -2299,7 +2299,7 @@ export async function fetchShows(brand, type, sort = 'sort') {
 export async function fetchMethodV2IntroVideo(brand) {
   const type = "method-intro";
   const filter = `_type == '${type}' && brand == '${brand}'`;
-  const fields = getIntroVideoFields();
+  const fields = getIntroVideoFields('method');
 
   const query = `*[${filter}] { ${fields.join(", ")} }`;
   return fetchSanity(query, false);

package/src/services/user/account.ts

@@ -163,3 +163,30 @@ export async function numberOfActiveUsers(): Promise<number> {
   const response = await httpClient.get<{ active_users: number }>(apiUrl)
   return response.active_users
 }
+
+export interface UserResource {
+  id: number
+  email: string
+  display_name: string
+  first_name: string
+  last_name: string
+  permission_level: string
+  use_student_view: boolean
+  is_admin: boolean
+  show_admin_toggle: boolean
+  [key: string]: any // Allow additional properties from the API
+}
+
+/**
+ * Toggles the student view mode for admin users.
+ * When enabled, admins see the platform as a regular student would.
+ *
+ * @param {boolean} useStudentView - Whether to enable student view mode (true) or admin view mode (false).
+ * @returns {Promise<UserResource>} - A promise that resolves to the updated user resource.
+ * @throws {HttpError} - Throws HttpError if the request fails or user is not an admin.
+ */
+export async function toggleStudentView(useStudentView: boolean): Promise<UserResource> {
+  const apiUrl = `/api/user-management-system/v1/user/student-view`
+  const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
+  return httpClient.patch<UserResource>(apiUrl, { use_student_view: useStudentView })
+}

package/src/services/user/types.js

@@ -73,6 +73,8 @@
  * @property {number} send_mobile_app_push_notifications
  * @property {number} send_email_notifications
  * @property {number} use_legacy_video_player
+ * @property {boolean} use_student_view
+ * @property {boolean} show_admin_toggle
  * @property {number} drumeo_ship_magazine
  * @property {string|null} magazine_shipping_address_id
  * @property {string|null} ios_latest_review_display_date

package/src/services/userActivity.js

@@ -1055,12 +1055,11 @@ function generateContentsMap(contents, playlistsContents, methodProgressContents
  */
 export async function getProgressRows({ brand = 'drumeo', limit = 8 } = {}) {
   // TODO slice progress to a reasonable number, say 100
-
-  const [recentPlaylists, progressContents, userPinnedItem, methodCard] = await Promise.all([
+  const methodCardPromise = getMethodCard(brand)
+  const [recentPlaylists, progressContents, userPinnedItem] = await Promise.all([
     fetchUserPlaylists(brand, { sort: '-last_progress', limit: limit }),
     getAllStartedOrCompleted({ onlyIds: false, brand: brand }),
     getUserPinnedItem(brand),
-    getMethodCard(brand),
   ])
 
   const playlists = recentPlaylists?.data || []
@@ -1103,7 +1102,7 @@ export async function getProgressRows({ brand = 'drumeo', limit = 8 } = {}) {
   ])
 
   const contentsMap = generateContentsMap(contents, playlistsContents)
-
+  const methodCard = await methodCardPromise
   let combined = await extractPinnedItemsAndSortAllItems(
     userPinnedItem,
     contentsMap,

package/test/learningPaths.test.js

@@ -1,6 +1,8 @@
 import { initializeTestService } from './initializeTests.js'
-import { fetchLearningPathLessons } from '../src/services/content-org/learning-paths.ts'
-import { fetchByRailContentId } from '../src/services/sanity.js'
+import {
+  fetchLearningPathLessons,
+  getLearningPath,
+} from '../src/services/content-org/learning-paths.ts'
 import { contentStatusCompleted } from '../src/services/contentProgress.js'
 describe('learning-paths', function () {
   beforeEach(async () => {
@@ -8,7 +10,7 @@ describe('learning-paths', function () {
   })
 
   test('getLearningPathsV2Test', async () => {
-    const results = await fetchByRailContentId(417140, 'learning-path-v2')
+    const results = await getLearningPath(417140)
   })
   test('getlearningPathLessonsTestNew', async () => {
     await contentStatusCompleted(417105)