musora-content-services 2.96.2 → 2.98.0

package/src/services/contentProgress.js

@@ -4,13 +4,15 @@ import { COLLECTION_TYPE, STATE } from './sync/models/ContentProgress'
 import { trackUserPractice, findIncompleteLesson } from './userActivity'
 import { getNextLessonLessonParentTypes } from '../contentTypeConfig.js'
 import { emitContentCompleted } from './progress-events'
+import {getDailySession} from "./content-org/learning-paths.js";
+import {getToday} from "./dateUtils.js";
 
 const STATE_STARTED = STATE.STARTED
 const STATE_COMPLETED = STATE.COMPLETED
 const MAX_DEPTH = 3
 
-export async function getProgressState(contentId) {
-  return getById(contentId, 'state', '')
+export async function getProgressState(contentId, collection = null) {
+  return getById(contentId, collection, 'state', '')
 }
 
 export async function getProgressStateByIds(contentIds, collection = null) {
@@ -26,6 +28,68 @@ export async function getResumeTimeSecondsByIds(contentIds, collection = null) {
   )
 }
 
+export async function getResumeTimeSecondsByIdsAndCollections(tuples) {
+  return getByIdsAndCollections(tuples, 'resume_time_seconds', 0)
+}
+
+export async function getNavigateToForMethod(data) {
+  let navigateToData = {}
+
+  const brand = data[0].content.brand || null
+  const dailySessionResponse = await getDailySession(brand, getToday())
+  const dailySession = dailySessionResponse?.daily_session || null
+  const activeLearningPathId = dailySessionResponse?.active_learning_path_id || null
+
+  for (const tuple of data) {
+    if (!tuple) continue
+
+    const {content, collection} = tuple
+
+    const findFirstIncomplete = (progresses) =>
+      Object.keys(progresses).find(id => progresses[id] !== STATE_COMPLETED) || null
+
+    const findChildById = (children, id) =>
+      children?.find(child => child.id === Number(id)) || null
+
+    const getFirstOrIncompleteChild = async (content, collection) => {
+      const childrenIds = content?.children.map(child => child.id) || []
+      if (childrenIds.length === 0) return null
+
+      const progresses = await getProgressStateByIds(childrenIds, collection)
+      const incompleteId = findFirstIncomplete(progresses)
+
+      return incompleteId ? findChildById(content.children, incompleteId) : content.children[0]
+    }
+
+    const getDailySessionNavigateTo = async (content, dailySession, collection) => {
+      const dailiesIds = dailySession?.map(item => item.content_ids).flat() || []
+      const progresses = await getProgressStateByIds(dailiesIds, collection)
+      const incompleteId = findFirstIncomplete(progresses)
+
+      return incompleteId ? findChildById(content.children, incompleteId) : null
+    }
+
+    // does not support passing in 'method-v2' type yet
+    if (content.type === COLLECTION_TYPE.LEARNING_PATH) {
+      let navigateTo = null
+
+      if (content.id === activeLearningPathId) {
+        navigateTo = await getDailySessionNavigateTo(content, dailySession, collection)
+      }
+
+      if (!navigateTo) {
+        navigateTo = await getFirstOrIncompleteChild(content, collection)
+      }
+
+      navigateToData[content.id] =buildNavigateTo(navigateTo, null, collection)
+
+    } else {
+      navigateToData[content.id] = null
+    }
+  }
+  return navigateToData
+}
+
 export async function getNavigateTo(data, collection = null) {
   collection = normalizeCollection(collection)
   let navigateToData = {}
@@ -178,10 +242,52 @@ export async function getProgressDataByIds(contentIds, collection) {
   return progress
 }
 
-async function getById(contentId, dataKey, defaultValue) {
+/**
+ * Get progress data for multiple content IDs, each with their own collection context.
+ * Useful when fetching progress for tuples that belong to different collections.
+ *
+ * @param {Array<{contentId: number, collection: {type: string, id: number}|null}>} tuples - Array of objects with contentId and collection
+ * @returns {Promise<Object>} - Object mapping content IDs to progress data
+ *
+ * @example
+ * const tuples = [
+ *   { contentId: 123, collection: { id: 456, type: 'learning-path-v2' } },
+ *   { contentId: 789, collection: { id: 101, type: 'learning-path-v2' } },
+ *   { contentId: 111, collection: null }
+ * ]
+ * const progress = await getProgressDataByIdsAndCollections(tuples)
+ * // Returns: { 123: { progress: 50, status: 'started', last_update: 123456 }, ... }
+ */
+
+// todo: warning: this doesnt work with having 2 items with same contentId but different collection, because
+//  of the response structure here with contentId as key
+export async function getProgressDataByIdsAndCollections(tuples) {
+  tuples = tuples.map(t => ({contentId: normalizeContentId(t.contentId), collection: normalizeCollection(t.collection)}))
+  const progress = Object.fromEntries(tuples.map(item => [item.contentId, {
+    last_update: 0,
+    progress: 0,
+    status: '',
+    collection: {},
+  }]))
+
+  await db.contentProgress.getSomeProgressByContentIdsAndCollection(tuples).then(r => {
+    r.data.forEach(p => {
+      progress[p.content_id] = {
+        last_update: p.updated_at,
+        progress: p.progress_percent,
+        status: p.state,
+        collection: (p.collection_type && p.collection_id) ? {type: p.collection_type, id: p.collection_id} : null
+      }
+    })
+  })
+
+  return progress
+}
+
+async function getById(contentId, collection, dataKey, defaultValue) {
   if (!contentId) return defaultValue
   return db.contentProgress
-    .getOneProgressByContentId(contentId)
+    .getOneProgressByContentId(contentId, collection)
     .then((r) => r.data?.[dataKey] ?? defaultValue)
 }
 
@@ -197,6 +303,18 @@ async function getByIds(contentIds, collection, dataKey, defaultValue) {
   return progress
 }
 
+async function getByIdsAndCollections(tuples, dataKey, defaultValue) {
+  tuples = tuples.map(t => ({contentId: normalizeContentId(t.contentId), collection: normalizeCollection(t.collection)}))
+  const progress = Object.fromEntries(tuples.map(tuple => [tuple.contentId, defaultValue]))
+
+  await db.contentProgress.getSomeProgressByContentIdsAndCollection(tuples).then(r => {
+    r.data.forEach(p => {
+      progress[p.content_id] = p[dataKey] ?? defaultValue
+    })
+  })
+  return progress
+}
+
 export async function getAllStarted(limit = null) {
   return db.contentProgress.startedIds(limit).then((r) => r.data.map((id) => parseInt(id)))
 }

package/src/services/sanity.js

@@ -2000,8 +2000,11 @@ export async function fetchMethodV2Structure(brand) {
   const _type = 'method-v2'
   const query = `*[_type == '${_type}' && brand == '${brand}'][0...1]{
     'sanity_id': _id,
+    brand,
+    'intro_video_id': intro_video->railcontent_id,
     'learning_paths': child[]->{
       'id': railcontent_id,
+      'intro_video_id': intro_video->railcontent_id,
       'children': child[]->railcontent_id
     }
   }`
@@ -2017,8 +2020,11 @@ export async function fetchMethodV2StructureFromId(contentId) {
   const _type = "method-v2";
   const query = `*[_type == '${_type}' && brand == *[railcontent_id == ${contentId}][0].brand][0...1]{
     'sanity_id': _id,
+    brand,
+    'intro_video_id': intro_video->railcontent_id,
     'learning_paths': child[]->{
       'id': railcontent_id,
+      'intro_video_id': intro_video->railcontent_id,
       'children': child[]->railcontent_id
     }
   }`

package/src/services/sync/repositories/content-progress.ts

@@ -1,6 +1,15 @@
-import SyncRepository, { Q } from './base'
-import ContentProgress, { COLLECTION_TYPE, COLLECTION_ID_SELF, STATE } from '../models/ContentProgress'
+import SyncRepository, {Q} from './base'
+import ContentProgress, {COLLECTION_ID_SELF, COLLECTION_TYPE, STATE} from '../models/ContentProgress'
 
+interface ContentIdCollectionTuple {
+  contentId: number,
+  collection: CollectionParameter | null,
+}
+
+export interface CollectionParameter {
+  type: COLLECTION_TYPE,
+  id: number,
+}
 export default class ProgressRepository extends SyncRepository<ContentProgress> {
   // null collection only
   async startedIds(limit?: number) {
@@ -77,7 +86,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return clauses
   }
 
-  async mostRecentlyUpdatedId(contentIds: number[], collection: { type: COLLECTION_TYPE; id: number } | null = null) {
+  async mostRecentlyUpdatedId(contentIds: number[], collection: CollectionParameter | null = null) {
     return this.queryOneId(
       Q.where('content_id', Q.oneOf(contentIds)),
       Q.where('collection_type', collection?.type ?? COLLECTION_TYPE.SELF),
@@ -89,7 +98,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   async getOneProgressByContentId(
     contentId: number,
-    { collection }: { collection?: { type: COLLECTION_TYPE; id: number } | null } = {}
+    collection: CollectionParameter | null = null
   ) {
     const clauses = [
       Q.where('content_id', contentId),
@@ -102,7 +111,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   async getSomeProgressByContentIds(
     contentIds: number[],
-    collection: { type: COLLECTION_TYPE; id: number } | null = null
+    collection: CollectionParameter | null = null
   ) {
     const clauses = [
       Q.where('content_id', Q.oneOf(contentIds)),
@@ -113,7 +122,23 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return await this.queryAll(...clauses)
   }
 
-  recordProgress(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null, progressPct: number, resumeTime?: number) {
+  async getSomeProgressByContentIdsAndCollection(tuples: ContentIdCollectionTuple[]) {
+    const clauses = []
+
+    clauses.push(...tuples.map(tuple => Q.and(...tupleClauses(tuple))))
+
+    return await this.queryAll(Q.or(...clauses))
+
+    function tupleClauses(tuple: ContentIdCollectionTuple) {
+      return [
+        Q.where('content_id', tuple.contentId),
+        Q.where('collection_type', tuple.collection?.type ?? COLLECTION_TYPE.SELF),
+        Q.where('collection_id', tuple.collection?.id ?? COLLECTION_ID_SELF)
+      ]
+    }
+  }
+
+  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number) {
     const id = ProgressRepository.generateId(contentId, collection)
 
     const result = this.upsertOne(id, (r) => {
@@ -156,7 +181,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   recordProgresses(
     contentIds: number[],
-    collection: { type: COLLECTION_TYPE; id: number } | null,
+    collection: CollectionParameter | null,
     progressPct: number
   ) {
     return this.upsertSome(
@@ -178,7 +203,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   recordProgressesTentative(
     contentProgresses: Record<string, number>, // Accept plain object
-    collection: { type: COLLECTION_TYPE; id: number } | null
+    collection: CollectionParameter | null
   ) {
     const data = Object.fromEntries(
       Object.entries(contentProgresses).map(([contentId, progressPct]) => [
@@ -196,13 +221,13 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return this.upsertSomeTentative(data)
   }
 
-  eraseProgress(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null) {
+  eraseProgress(contentId: number, collection: CollectionParameter | null) {
     return this.deleteOne(ProgressRepository.generateId(contentId, collection))
   }
 
   private static generateId(
     contentId: number,
-    collection: { type: COLLECTION_TYPE; id: number } | null
+    collection: CollectionParameter | null
   ) {
     return `${contentId}:${collection?.type || COLLECTION_TYPE.SELF}:${collection?.id || COLLECTION_ID_SELF}`
   }

package/src/services/user/memberships.ts

@@ -218,3 +218,35 @@ export async function restorePurchases(
     requestBody
   )
 }
+
+/**
+ * Get the upgrade price from Basic to Plus membership.
+ * Returns the price based on the user's subscription interval.
+ *
+ * For monthly subscribers: Returns the monthly upgrade cost (difference between Plus and Base monthly prices, ~$5/month)
+ * For yearly subscribers: Returns the monthly equivalent upgrade cost ($3.33/month from $40/year)
+ * For lifetime subscribers: Returns the annual upgrade cost for songs add-on ($40/year)
+ * If interval cannot be determined: Defaults to monthly price
+ *
+ * @returns {Promise<{price: number, currency: string, period: string|null}>} - The upgrade price information
+ * @property {number} price - The upgrade cost in USD (monthly for month/year, annual for lifetime)
+ * @property {string} currency - The currency 
+ * @property {string|null} period - The billing period for the price ('month' or 'year'). Note: lifetime subscribers return 'year' period with annual price
+ *
+ * @example
+ * getUpgradePrice()
+ *   .then(info => {
+ *     console.log(`Upgrade price: $${info.price} per ${info.period}`)
+ *     // Example outputs:
+ *     // Monthly: "Upgrade price: $5 per month"
+ *     // Yearly: "Upgrade price: $3.33 per month"
+ *     // Lifetime: "Upgrade price: $40 per year"
+ *   })
+ *   .catch(error => {
+ *     console.error('Failed to fetch upgrade price:', error)
+ *   })
+ */
+export async function getUpgradePrice() {
+  const httpClient = new HttpClient(globalConfig.baseUrl)
+  return  httpClient.get(`${baseUrl}/v1/upgrade-price`)
+}