musora-content-services 2.7.0 → 2.7.2

package/src/services/contentProgress.js

@@ -40,6 +40,16 @@ export async function getResumeTimeSecondsByIds(contentIds) {
   return getByIds(contentIds, DATA_KEY_RESUME_TIME, 0)
 }
 
+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] ?? ''}))
+  return progress
+}
+
 async function getById(contentId, dataKey, defaultValue) {
   let data = await dataContext.getData()
   return data[contentId]?.[dataKey] ?? defaultValue
@@ -96,29 +106,49 @@ export async function getAllCompleted(limit = null) {
   return ids
 }
 
-export async function getAllStartedOrCompleted(limit = null) {
+export async function getAllStartedOrCompleted({ limit = null, onlyIds = true, brand = null, excludedIds = [] } = {}) {
   const data = await dataContext.getData()
-  let ids = Object.keys(data)
-    .filter(function (key) {
-      return (
-        data[parseInt(key)][DATA_KEY_STATUS] === STATE_STARTED ||
-        data[parseInt(key)][DATA_KEY_STATUS] === STATE_COMPLETED
-      )
-    })
-    .map(function (key) {
-      return parseInt(key)
+  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
+
+  let filtered = Object.entries(data)
+    .filter(([key, item]) => {
+      const id = parseInt(key)
+      const isRelevantStatus =
+        item[DATA_KEY_STATUS] === STATE_STARTED || item[DATA_KEY_STATUS] === STATE_COMPLETED
+      const isRecent = item[DATA_KEY_LAST_UPDATED_TIME] >= oneMonthAgoInSeconds
+      const isCorrectBrand = !brand || item.b === brand
+      const isNotExcluded = !excludedSet.has(id)
+      return isRelevantStatus && isRecent && isCorrectBrand && isNotExcluded
     })
-    .sort(function (a, b) {
-      let v1 = data[a][DATA_KEY_LAST_UPDATED_TIME]
-      let v2 = data[b][DATA_KEY_LAST_UPDATED_TIME]
+    .sort(([, a], [, b]) => {
+      const v1 = a[DATA_KEY_LAST_UPDATED_TIME]
+      const v2 = b[DATA_KEY_LAST_UPDATED_TIME]
       if (v1 > v2) return -1
       else if (v1 < v2) return 1
       return 0
     })
+
   if (limit) {
-    ids = ids.slice(0, limit)
+    filtered = filtered.slice(0, limit)
+  }
+
+  if (onlyIds) {
+    return filtered.map(([key]) => parseInt(key))
+  } else {
+    const progress = {}
+    filtered.forEach(([key, item]) => {
+      const id = parseInt(key)
+      progress[id] = {
+        last_update: item?.[DATA_KEY_LAST_UPDATED_TIME] ?? 0,
+        progress: item?.[DATA_KEY_PROGRESS] ?? 0,
+        status: item?.[DATA_KEY_STATUS] ?? '',
+        brand: item?.b ?? '',
+      }
+    })
+    return progress
   }
-  return ids
 }
 
 export async function assignmentStatusCompleted(assignmentId, parentContentId) {
@@ -252,12 +282,11 @@ export async function recordWatchSession(
     sessionId = uuidv4()
   }
 
-  await recordUserPractice({ content_id: contentId, duration_seconds: secondsPlayed })
-    try {
-      await recordUserPractice({ content_id: contentId, duration_seconds: secondsPlayed })
-    } catch (error) {
+  try {
+      await recordUserPractice({ content_id: contentId, duration_seconds: Math.ceil(secondsPlayed)  })
+  } catch (error) {
       console.error('Failed to record user practice:', error)
-    }
+  }
 
   await dataContext.update(
     async function (localContext) {

package/src/services/sanity.js

@@ -512,15 +512,18 @@ export async function fetchByRailContentId(id, contentType) {
  *   .then(contents => console.log(contents))
  *   .catch(error => console.error(error));
  */
-export async function fetchByRailContentIds(ids, contentType = undefined) {
+export async function fetchByRailContentIds(ids, contentType = undefined, brand= undefined) {
   if (!ids) {
     return []
   }
   const idsString = ids.join(',')
+  const brandFilter = brand ? ` && brand == "${brand}"` : ''
+  const query = `*[
+    railcontent_id in [${idsString}]${brandFilter}
+  ]{
+    ${getFieldsForContentType(contentType)}
+  }`
 
-  const query = `*[railcontent_id in [${idsString}]]{
-        ${getFieldsForContentType(contentType)}
-      }`
   const results = await fetchSanity(query, true)
 
   const sortFuction = function compare(a, b) {
@@ -2355,3 +2358,18 @@ export async function fetchScheduledAndNewReleases(
 
   return fetchSanity(query, true)
 }
+
+export async function fetchShows(
+  brand,
+  type,
+  sort = 'sort'
+) {
+  const sortOrder = getSortOrder(sort, brand)
+  const filter = `_type == '${type}'  && brand == '${brand}'`
+  const filterParams = {}
+
+  const query = await buildQuery(filter, filterParams, getFieldsForContentType(type), {
+    sortOrder: sortOrder
+  })
+  return fetchSanity(query, true)
+}

package/src/services/userActivity.js

@@ -11,10 +11,13 @@ import {
   fetchRecentUserActivities,
 } from './railcontent'
 import { DataContext, UserActivityVersionKey } from './dataContext.js'
-import { fetchByRailContentIds } from './sanity'
-import { lessonTypesMapping } from '../contentTypeConfig'
+import { fetchByRailContentIds, fetchShows } from './sanity'
+import {fetchUserPlaylists} from "./content-org/playlists";
 import { convertToTimeZone, getMonday, getWeekNumber, isSameDate, isNextDay } from './dateUtils.js'
 import { globalConfig } from './config'
+import {collectionLessonTypes, lessonTypesMapping, progressTypesMapping} from "../contentTypeConfig";
+import {getAllStartedOrCompleted, getProgressStateByIds} from "./contentProgress";
+import {TabResponseType} from "../contentMetaData";
 
 const DATA_KEY_PRACTICES = 'practices'
 const DATA_KEY_LAST_UPDATED_TIME = 'u'
@@ -835,14 +838,6 @@ async function formatPracticeMeta(practices) {
   })
 }
 
-export function getFormattedType(type) {
-  for (const [key, values] of Object.entries(lessonTypesMapping)) {
-    if (values.includes(type)) {
-      return key.replace(/\b\w/g, (char) => char.toUpperCase())
-    }
-  }
-  return null
-}
 
 /**
  * Records a new user activity in the system.
@@ -887,3 +882,346 @@ export async function deleteUserActivity(id) {
   const url = `/api/user-management-system/v1/activities/${id}`
   return await fetchHandler(url, 'DELETE')
 }
+/**
+ * Fetches and combines recent user progress rows and playlists, excluding certain types and parents.
+ *
+ * @param {Object} [options={}] - Options for fetching progress rows.
+ * @param {string|null} [options.brand=null] - The brand context for progress data.
+ * @param {number} [options.limit=8] - Maximum number of progress rows to return.
+ * @returns {Promise<Object>} - A promise that resolves to an object containing progress rows formatted for UI.
+ *
+ * @example
+ * getProgressRows({ brand: 'drumeo', limit: 10 })
+ *   .then(data => console.log(data))
+ *   .catch(error => console.error(error));
+ */
+export async function getProgressRows({ brand = null, limit = 8 } = {}) {
+  const excludedTypes = new Set([
+    'pack-bundle',
+    'learning-path-course',
+    'learning-path-level'
+  ]);
+
+  const recentPlaylists = await fetchUserPlaylists(brand, {
+    sort: '-last_progress',
+    limit: limit,
+  });
+  const playlists = recentPlaylists?.data || [];
+  const eligiblePlaylistItems = await getEligiblePlaylistItems(playlists);
+  const playlistEngagedOnContents = eligiblePlaylistItems.map(item => item.last_engaged_on);
+  const playlistsContents = await fetchByRailContentIds(playlistEngagedOnContents, 'progress-tracker');
+  const excludedParents = new Set();
+  for (const item of playlistsContents) {
+    const contentId = item.id ?? item.railcontent_id;
+    excludedParents.add(contentId)
+    const parentIds = item.parent_content_data || [];
+    parentIds.forEach(id => excludedParents.add(id));
+  }
+
+  const progressContents = await getAllStartedOrCompleted({onlyIds: false, brand: brand, excludedIds: Array.from(excludedParents) });
+  const contents = await fetchByRailContentIds(Object.keys(progressContents), 'progress-tracker', brand);
+  const contentsMap = {};
+  contents.forEach(content => {
+    contentsMap[content.railcontent_id] = content;
+  });
+  const childToParentMap = {};
+  Object.values(contentsMap).forEach(content => {
+    if (Array.isArray(content.parent_content_data) && content.parent_content_data.length > 0) {
+      childToParentMap[content.id] = content.parent_content_data[content.parent_content_data.length - 1];
+    }
+  });
+  const progressMap = new Map();
+  for (const [idStr, progress] of Object.entries(progressContents)) {
+    const id = parseInt(idStr);
+    const content = contentsMap[id];
+    if (!content || excludedTypes.has(content.type)) continue;
+    const parentId = childToParentMap[id];
+    // Handle children with parents
+    if (parentId) {
+      const parentContent = contentsMap[parentId];
+      if (!parentContent || excludedTypes.has(parentContent.type)) continue;
+      const existing = progressMap.get(parentId);
+      if (existing) {
+        // If childIndex isn't already set, set it
+        if (existing.childIndex === undefined) {
+          existing.childIndex = id;
+        }
+      } else {
+        progressMap.set(parentId, {
+          id: parentId,
+          raw: parentContent,
+          state: progress.status,
+          percent: progress.progress,
+          progressTimestamp: progress.last_update * 1000,
+          childIndex: id
+        });
+      }
+      continue;
+    }
+    // Handle standalone parents
+    if (!progressMap.has(id)) {
+      progressMap.set(id, {
+        id,
+        raw: content,
+        state: progress.status,
+        percent: progress.progress,
+        progressTimestamp: progress.last_update * 1000
+      });
+    }
+  }
+  const progressList = Array.from(progressMap.values());
+
+  const combined = mergeAndSortItems([...progressList, ...eligiblePlaylistItems], limit);
+  const results = await Promise.all(
+    combined.slice(0, limit).map(item =>
+      item.type === 'playlist'
+        ? processPlaylistItem(item)
+        : processContentItem(item)
+    )
+  );
+
+  return {
+    type: TabResponseType.PROGRESS_ROWS,
+    data: results
+  };
+}
+
+async function processContentItem(item) {
+  let data = item.raw;
+  const contentType = getFormattedType(data.type);
+  const status = item.state;
+
+  let ctaText = 'Continue';
+  if (contentType === 'transcription' || contentType === 'play-along' || contentType === 'jam-track') ctaText = 'Replay Song';
+  if (contentType === 'lesson') ctaText = status === 'completed' ? 'Revisit Lesson' : 'Continue';
+  if ((contentType === 'pack' || contentType === 'song tutorial' || collectionLessonTypes.includes(contentType)) && status === 'completed') {
+    ctaText = 'View Lessons';
+  }
+
+  if (data.lesson_count > 0) {
+    if (item.childIndex) {
+      let nextId = item.childIndex
+      const lessonIds = extractLessonIds(item);
+      const progressOnItems = await getProgressStateByIds(lessonIds);
+      const completedCount = Object.values(progressOnItems).filter(value => value === 'completed').length;
+      const nextByProgress = findIncompleteLesson(progressOnItems, item.childIndex, item.raw.type);
+      nextId = nextByProgress ? nextByProgress : nextId;
+
+      const nestedLessons = data.lessons
+        .filter(item => Array.isArray(item.lessons))
+        .flatMap(parent =>
+          parent.lessons.map(lesson => ({
+            ...lesson,
+            parent: {
+              id: parent.id,
+              slug: parent.slug,
+              title: parent.title,
+              type: parent.type
+            }
+          }))
+        );
+
+      const lessons = (nestedLessons.length === 0) ? data.lessons : nestedLessons;
+      const nextLesson = lessons.find(lesson => lesson.id === nextId);
+      data.first_incomplete_child = nextLesson?.parent ?? nextLesson;
+      data.second_incomplete_child = (nextLesson?.parent) ? nextLesson : null;
+      data.completed_children = completedCount;
+    }
+  }
+
+  if(contentType == 'show' && status == 'completed'){
+    const shows = await fetchShows(data.brand, data.type)
+    const showIds = shows.map(item => item.id);
+    const progressOnItems = await getProgressStateByIds(showIds);
+    const nextByProgress = findIncompleteLesson(progressOnItems, data.id, data.type);
+    data = shows.find(lesson => lesson.id === nextByProgress);
+  }
+
+  return {
+    id:                item.id,
+    progressType:      'content',
+    header:            contentType,
+    body:              {
+      progressPercent: item.percent,
+      thumbnail:       data.thumbnail,
+      title:           data.title,
+      subtitle:        !data.child_count || data.lesson_count === 1
+                         ? `${data.difficulty_string} • ${data.artist_name}`
+                         : `${data.completed_children} of ${data.lesson_count ?? data.child_count} Lessons Complete`
+    },
+    cta:               {
+      text:   ctaText,
+      action: {
+        type:  data.type,
+        brand: data.brand,
+        id:    data.id,
+        slug:  data.slug,
+        child: data.first_incomplete_child
+                 ? {
+            id:    data.first_incomplete_child.id,
+            type:  data.first_incomplete_child.type,
+            brand: data.first_incomplete_child.brand,
+            slug:  data.first_incomplete_child.slug,
+            child: data.second_incomplete_child
+                     ? {
+                id:    data.second_incomplete_child.id,
+                type:  data.second_incomplete_child.type,
+                brand: data.second_incomplete_child.brand,
+                slug:  data.second_incomplete_child.slug
+              }
+                     : null
+          }
+                 : null
+      }
+    },
+    progressTimestamp: item.progressTimestamp
+  };
+}
+
+async function processPlaylistItem(item) {
+  const playlist = item.raw;
+  const progressOnItems = await getProgressStateByIds(playlist.items.map(a => a.content_id));
+  const allItemsCompleted = item.raw.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;
+    }
+  }
+
+  return {
+    id:                playlist.id,
+    progressType:      'playlist',
+    header:            'playlist',
+    body:              {
+      first_items_thumbnail_url: playlist.first_items_thumbnail_url,
+      title:                     playlist.name,
+      subtitle:                  `${playlist.duration_formated} • ${playlist.total_items} items • ${playlist.likes} likes • ${playlist.user.display_name}`
+    },
+    progressTimestamp: item.progressTimestamp,
+    cta:               {
+      text:   'Continue',
+      action: {
+        brand:  playlist.brand,
+        id:     playlist.id,
+        itemId: nextItem.id,
+        type:   'playlists',
+      }
+    }
+  }
+}
+
+const getFormattedType = type => {
+  for (const [key, values] of Object.entries(progressTypesMapping)) {
+    if (values.includes(type)) {
+      return key;
+    }
+  }
+  return null;
+};
+
+function extractLessonIds(data) {
+  const ids = [];
+  function traverse(lessons) {
+    for (const item of lessons) {
+      if (item.id) {
+        ids.push(item.id);
+      }
+      if (item.lessons) {
+        traverse(item.lessons); // Recursively handle nested lessons
+      }
+    }
+  }
+  if (data.raw && Array.isArray(data.raw.lessons)) {
+    traverse(data.raw.lessons);
+  }
+
+  return ids;
+}
+
+
+async function getEligiblePlaylistItems(playlists) {
+  const eligible = playlists.filter(p => p.last_progress && p.last_engaged_on);
+  return Promise.all(
+    eligible.map(async p => {
+      const utcDate = new Date(p.last_progress.replace(' ', 'T') + 'Z');
+      const timestamp = utcDate.getTime();
+      return {
+        type: 'playlist',
+        progressTimestamp: timestamp,
+        last_engaged_on: p.last_engaged_on,
+        raw: p
+      };
+    })
+  );
+}
+
+function mergeAndSortItems(items, limit) {
+  return items
+    .filter(item => typeof item.progressTimestamp === 'number' && item.progressTimestamp > 0)
+    .sort((a, b) => b.progressTimestamp - a.progressTimestamp)
+    .slice(0, limit + 5);
+}
+
+function findIncompleteLesson(progressOnItems, currentContentId, contentType) {
+  const ids = Object.keys(progressOnItems).map(Number);
+  if (contentType === 'challenge') {
+    // Return first incomplete lesson
+    return ids.find(id => progressOnItems[id] !== 'completed') || null;
+  }
+
+  // For other types, find next incomplete after current
+  const currentIndex = ids.indexOf(Number(currentContentId));
+  if (currentIndex === -1) return null;
+
+  for (let i = currentIndex + 1; i < ids.length; i++) {
+    const id = ids[i];
+    if (progressOnItems[id] !== 'completed') {
+      return id;
+    }
+  }
+
+  return ids[0];
+}
+
+/**
+ * Pins a specific progress row for a user, scoped by brand.
+ *
+ * @param {string} brand - The brand context for the pin action.
+ * @param {number|string} id - The ID of the progress item to pin.
+ * @param {string} progressType - The type of progress (e.g., 'content', 'playlist').
+ * @returns {Promise<Object>} - A promise resolving to the response from the pin API.
+ *
+ * @example
+ * pinProgressRow('drumeo', 12345, 'content')
+ *   .then(response => console.log(response))
+ *   .catch(error => console.error(error));
+ */
+export async function pinProgressRow(brand, id, progressType) {
+  const url = `/api/user-management-system/v1/progress/pin?brand=${brand}&id=${id}&progressType=${progressType}`;
+  return await fetchHandler(url, 'PUT', null)
+}
+/**
+ * Unpins the current pinned progress row for a user, scoped by brand.
+ *
+ * @param {string} brand - The brand context for the unpin action.
+ * @returns {Promise<Object>} - A promise resolving to the response from the unpin API.
+ *
+ * @example
+ * unpinProgressRow('drumeo')
+ *   .then(response => console.log(response))
+ *   .catch(error => console.error(error));
+ */
+export async function unpinProgressRow(brand) {
+  const url = `/api/user-management-system/v1/progress/unpin?brand=${brand}`;
+  return await fetchHandler(url, 'PUT', null)
+}
+