musora-content-services 2.7.1 → 2.7.2

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)
+}
+

package/test/mockData/mockData_progress_content.json

@@ -0,0 +1,182 @@
+{
+  "257242": {
+    "last_update": 1747657503,
+    "progress": 13,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "257243": {
+    "last_update": 1747657502,
+    "progress": 52,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "257245": {
+    "last_update": 1747657470,
+    "progress": 62,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "257249": {
+    "last_update": 1747657493,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "257250": {
+    "last_update": 1747657502,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "259238": {
+    "last_update": 1747657495,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "259240": {
+    "last_update": 1747657505,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "260677": {
+    "last_update": 1747318330,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "274368": {
+    "last_update": 1747211391,
+    "progress": 20,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "274889": {
+    "last_update": 1747211391,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "280498": {
+    "last_update": 1747726731,
+    "progress": 60,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "287853": {
+    "last_update": 1747647688,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "287855": {
+    "last_update": 1747726731,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "287858": {
+    "last_update": 1747653734,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "316732": {
+    "last_update": 1747319258,
+    "progress": 0,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "316752": {
+    "last_update": 1747402511,
+    "progress": 80,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "316772": {
+    "last_update": 1747319687,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "325826": {
+    "last_update": 1747324670,
+    "progress": 41,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "335025": {
+    "last_update": 1747315549,
+    "progress": 0,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "373171": {
+    "last_update": 1747211114,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "373172": {
+    "last_update": 1747211114,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "402009": {
+    "last_update": 1747293447,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "402021": {
+    "last_update": 1747318769,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "402199": {
+    "last_update": 1747318734,
+    "progress": 0,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "410255": {
+    "last_update": 1747211224,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "410478": {
+    "last_update": 1747657306,
+    "progress": 22,
+    "status": "started",
+    "brand": "drumeo"
+  },
+  "410480": {
+    "last_update": 1747657295,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "410481": {
+    "last_update": 1747657306,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "411091": {
+    "last_update": 1747318457,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  },
+  "415585": {
+    "last_update": 1747319147,
+    "progress": 100,
+    "status": "completed",
+    "brand": "drumeo"
+  }
+}