musora-content-services 1.3.19 → 2.0.2

package/src/services/content.js

@@ -0,0 +1,371 @@
+/**
+ * @module Content-Services-V2
+ */
+
+import {
+  fetchAll,
+  fetchByRailContentIds,
+  fetchMetadata,
+  fetchRecent,
+  fetchTabData,
+  fetchNewReleases,
+  fetchUpcomingEvents,
+  fetchScheduledReleases,
+  fetchReturning,
+  fetchLeaving, fetchScheduledAndNewReleases
+} from './sanity.js'
+import {TabResponseType, Tabs, capitalizeFirstLetter} from '../contentMetaData.js'
+import {getAllStartedOrCompleted} from "./contentProgress";
+import {fetchHandler} from "./railcontent";
+import {recommendations} from "./recommendations";
+
+export async function getLessonContentRows (brand='drumeo', pageName = 'lessons') {
+  let recentContentIds = await fetchRecent(brand, pageName, { progress: 'recent' });
+  recentContentIds = recentContentIds.map(item => item.id);
+
+  let contentRows = await getContentRows(brand, pageName);
+  contentRows = Array.isArray(contentRows) ? contentRows : [];
+  contentRows.unshift({
+    id: 'recent',
+    title: 'Recent ' + capitalizeFirstLetter(pageName),
+    content: recentContentIds || []
+  });
+
+  const results = await Promise.all(
+      contentRows.map(async (row) => {
+        if (row.content.length == 0){
+          return { id: row.id, title: row.title, items: [] }
+        }
+        const data = await fetchByRailContentIds(row.content)
+        return { id: row.id, title: row.title, items: data }
+      })
+  )
+  return results
+}
+
+/**
+ * Get data that should be displayed for a specific tab with pagination
+ * @param {string} brand - The brand for which to fetch data.
+ * @param {string} pageName - The page name (e.g., 'lessons', 'songs','challenges).
+ * @param {string} tabName - The name for the selected tab. Should be same name received from fetchMetadata (e.g., 'Individuals', 'Collections','For You').
+ * @param {Object} params - Parameters for pagination, sorting, and filter.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The number of items per page.
+ * @param {string} [params.sort="-published_on"] - The field to sort the data by.
+ * @param {Array<string>} [params.selectedFilters=[]] - The selected filter.
+ * @returns {Promise<Object|null>} - The fetched content data or null if not found.
+ *
+ * @example
+ * getTabResults('drumeo', 'lessons','Singles', {
+ *   page: 2,
+ *   limit: 20,
+ *   sort: '-popularity',
+ *   includedFields: ['difficulty,Intermediate'],
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function getTabResults(brand, pageName, tabName, {
+  page = 1,
+  limit = 10,
+  sort = 'recommended',
+  selectedFilters = []
+} = {}) {
+
+  // Extract and handle 'progress' filter separately
+  const progressFilter = selectedFilters.find(f => f.startsWith('progress,')) || 'progress,all';
+  const progressValue = progressFilter.split(',')[1].toLowerCase();
+  const filteredSelectedFilters = selectedFilters.filter(f => !f.startsWith('progress,'));
+
+  // Prepare included fields
+  const mergedIncludedFields = [...filteredSelectedFilters, `tab,${tabName.toLowerCase()}`];
+
+  // Fetch data
+  const results = tabName === Tabs.ForYou.name
+      ? { entity: await getLessonContentRows(brand, pageName) }
+      : await fetchTabData(brand, pageName, { page, limit, sort, includedFields: mergedIncludedFields, progress: progressValue });
+
+  // Fetch metadata
+  const metaData = await fetchMetadata(brand, pageName);
+
+  // Process filters
+  const filters = (metaData.filters ?? []).map(filter => ({
+    ...filter,
+    items: filter.items.map(item => {
+      const value = item.value.split(',')[1];
+      return {
+        ...item,
+        selected: selectedFilters.includes(`${filter.key},${value}`) ||
+                      (filter.key === 'progress' && value === 'all' && !selectedFilters.some(f => f.startsWith('progress,')))
+      };
+    })
+  }));
+
+  // Process sort options
+  const sortOptions = {
+    title: metaData.sort?.title ?? 'Sort By',
+    type: metaData.sort?.type ?? 'radio',
+    items: (metaData.sort?.items ?? []).map(option => ({
+      ...option,
+      selected: option.value === sort
+    }))
+  };
+
+  return {
+    type: tabName === Tabs.ForYou.name ? TabResponseType.SECTIONS : TabResponseType.CATALOG,
+    data: results.entity,
+    meta: { filters, sort: sortOptions }
+  };
+}
+
+/**
+ * Fetches recent content for a given brand and page with pagination.
+ *
+ * @param {string} brand - The brand for which to fetch data.
+ * @param {string} pageName - The page name (e.g., 'all', 'incomplete', 'completed').
+ * @param {string} [tabName='all'] - The tab name (defaults to 'all' for recent content).
+ * @param {Object} params - Parameters for pagination and sorting.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The number of items per page.
+ * @param {string} [params.sort="-published_on"] - The field to sort the data by.
+ * @returns {Promise<Object>} - The fetched content data.
+ *
+ * @example
+ * getRecent('drumeo', 'lessons', 'all', {
+ *   page: 2,
+ *   limit: 15,
+ *   sort: '-popularity'
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function getRecent(brand, pageName, tabName = 'all', {
+  page = 1,
+  limit = 10,
+  sort = '-published_on',
+} = {}) {
+  const progress = tabName.toLowerCase() == 'all' ? 'recent':tabName.toLowerCase();
+  const recentContentIds = await fetchRecent(brand, pageName, { page:page, limit:limit, progress: progress });
+  const metaData = await fetchMetadata(brand, 'recent');
+  return {
+    type: TabResponseType.CATALOG,
+    data: recentContentIds,
+    meta:  { tabs: metaData.tabs }
+  };
+}
+
+/**
+ * Fetches content rows for a given brand and page with optional filtering by content row id.
+ *
+ * @param {string} brand - The brand for which to fetch content rows.
+ * @param {string} pageName - The page name (e.g., 'lessons', 'songs', 'challenges').
+ * @param {string} [contentRowId] - The specific content row ID to fetch.
+ * @param {Object} params - Parameters for pagination.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The maximum number of content items per row.
+ * @returns {Promise<Object>} - The fetched content rows.
+ *
+ * @example
+ * getContentRows('drumeo', 'lessons', 'Your-Daily-Warmup', {
+ *   page: 1,
+ *   limit: 5
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function getContentRows(brand, pageName, contentRowId , {
+  page = 1,
+  limit = 10,
+} = {}) {
+  const contentRow = contentRowId ? `&content_row_id=${contentRowId}` : ''
+  const url = `/api/content/v1/rows?brand=${brand}&page_name=${pageName}${contentRow}&page=${page}&limit=${limit}`;
+  return  await fetchHandler(url, 'get', null);
+}
+
+/**
+ * Fetches new and upcoming releases for a given brand with pagination options.
+ *
+ * @param {string} brand - The brand for which to fetch new and upcoming releases.
+ * @param {Object} [params={}] - Pagination parameters.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The maximum number of content items to fetch.
+ * @returns {Promise<{ data: Object[] } | null>} - A promise that resolves to the fetched content data or `null` if no data is found.
+ *
+ * @example
+ * // Fetch the first page with 10 results
+ * getNewAndUpcoming('drumeo')
+ *   .then(response => console.log(response))
+ *   .catch(error => console.error(error));
+ *
+ * @example
+ * // Fetch the second page with 20 results
+ * getNewAndUpcoming('drumeo', { page: 2, limit: 20 })
+ *   .then(response => console.log(response))
+ *   .catch(error => console.error(error));
+ */
+export async function getNewAndUpcoming(brand, {
+  page = 1,
+  limit = 10,
+} = {}) {
+
+  const data = await fetchScheduledAndNewReleases(brand, {page: page, limit: limit});
+  if (!data) {
+    return null;
+  }
+
+  return {
+    data: data,
+  };
+}
+
+/**
+ * Fetches scheduled content rows for a given brand with optional filtering by content row ID.
+ *
+ * @param {string} brand - The brand for which to fetch content rows.
+ * @param {string} [contentRowId=null] - The specific content row ID to fetch (optional).
+ * @param {Object} [params={}] - Pagination parameters.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The maximum number of content items per row.
+ * @returns {Promise<Object>} - A promise that resolves to the fetched content rows.
+ *
+ * @example
+ * // Fetch all sections with default pagination
+ * getScheduleContentRows('drumeo')
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ *
+ * @example
+ * // Fetch only the 'New-Releases' section with custom pagination
+ * getScheduleContentRows('drumeo', 'New-Releases', { page: 1, limit: 30 })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ *
+ * @example
+ * // Fetch only the 'Live-Streams' section with unlimited results
+ * getScheduleContentRows('drumeo', 'Live-Streams')
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function getScheduleContentRows(brand, contentRowId = null, { page = 1, limit = 10 } = {}) {
+  const sections = {
+    'New-Releases': {
+      title: 'New Releases',
+      fetchMethod: fetchNewReleases
+    },
+    'Live-Streams': {
+      title: 'Live Streams',
+      fetchMethod: fetchUpcomingEvents
+    },
+    'Upcoming-Releases': {
+      title: 'Upcoming Releases',
+      fetchMethod: fetchScheduledReleases
+    },
+    'Returning-Soon': {
+      title: 'Returning Soon',
+      fetchMethod: fetchReturning
+    },
+    'Leaving-Soon': {
+      title: 'Leaving Soon',
+      fetchMethod: fetchLeaving
+    }
+  };
+
+  if (contentRowId) {
+    if (!sections[contentRowId]) {
+      return null; // Return null if the requested section does not exist
+    }
+
+    const items = await sections[contentRowId].fetchMethod(brand, { page, limit });
+
+    // Fetch only the requested section
+    const result = {
+      id: contentRowId,
+      title: sections[contentRowId].title,
+      // TODO: Remove content after FE/MA updates the existing code to use items
+      content: items,
+      items: items
+    };
+
+    return {
+      type: TabResponseType.CATALOG,
+      data: result,
+      meta: {}
+    };
+  }
+
+  // If no specific contentRowId, fetch all sections
+  const results = await Promise.all(
+    Object.entries(sections).map(async ([id, section]) => {
+      // Apply special pagination rules
+      const isNewReleases = id === 'New-Releases';
+      const pagination = isNewReleases ? { page: 1, limit: 30 } : { page: 1, limit: Number.MAX_SAFE_INTEGER };
+
+      return {
+        id,
+        title: section.title,
+        content: await section.fetchMethod(brand, pagination)
+      };
+    })
+  );
+
+  return {
+    type: TabResponseType.SECTIONS,
+    data: results,
+    meta: {}
+  };
+}
+
+/**
+ * Fetches recommended content for a given brand with pagination support.
+ *
+ * @param {string} brand - The brand for which to fetch recommended content.
+ * @param {Object} [params={}] - Pagination parameters.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The maximum number of recommended content items per page.
+ * @returns {Promise<Object>} - A promise that resolves to an object containing recommended content.
+ *
+ * @example
+ * // Fetch recommended content for a brand with default pagination
+ * getRecommendedForYou('drumeo')
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ *
+ * @example
+ * // Fetch recommended content for a brand with custom pagination
+ * getRecommendedForYou('drumeo', { page: 2, limit: 5 })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function getRecommendedForYou(brand, rowId = null, {
+  page = 1,
+  limit = 10,
+} = {}) {
+  const requiredItems = page * limit;
+  const data = await recommendations(brand, {limit: requiredItems});
+  if (!data || !data.length) {
+    return { id: 'recommended', title: 'Recommended For You', items: [] };
+  }
+
+  // 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
+  };
+
+  if (rowId) {
+    return {
+      type: TabResponseType.CATALOG,
+      data: contents,
+      meta: {}
+    };
+  }
+
+  return { id: 'recommended', title: 'Recommended For You', items: contents }
+}
+
+

package/src/services/forum.js

@@ -0,0 +1,57 @@
+/**
+ * @module Forum-V2
+ */
+
+
+export async function getActiveDiscussions(brand, { page = 1, limit = 10 } = {}) {
+  // Dummy data TODO: BE endpoint call
+  const results = {
+    entity: [
+      {
+        id: 11,
+        url: 'https://forum.example.com/post/11',
+        post: "<p><strong>Lorem ipsum</strong> dolor sit amet, <em>consectetur adipiscing elit</em>. <a href='#'>Click here</a> for more info.</p>",
+        author: {
+          id: 123,
+          name: 'John Doe',
+          avatar: 'https://d3fzm1tzeyr5n3.cloudfront.net/profile_picture_url/5f6abe99-f1ed-49ec-aff4-893c017ed1aa-1681577292-565638.jpg'
+        }
+      },
+      {
+        id: 12,
+        url: 'https://forum.example.com/post/12',
+        post: "<p>This is a <span style='color: red;'>sample forum post</span> to <strong>test</strong> data structure. <ul><li>Point 1</li><li>Point 2</li></ul></p>",
+        author: {
+          id: 124,
+          name: 'Jane Smith',
+          avatar: 'https://d3fzm1tzeyr5n3.cloudfront.net/profile_picture_url/5f6abe99-f1ed-49ec-aff4-893c017ed1aa-1681577292-565638.jpg'
+        }
+      },
+      {
+        id: 13,
+        url: 'https://forum.example.com/post/13',
+        post: "<blockquote>Another test post with some <i>dummy text</i> content.</blockquote>",
+        author: {
+          id: 125,
+          name: 'Alice Johnson',
+          avatar: 'https://d3fzm1tzeyr5n3.cloudfront.net/profile_picture_url/5f6abe99-f1ed-49ec-aff4-893c017ed1aa-1681577292-565638.jpg'
+        }
+      },
+      {
+        id: 14,
+        url: 'https://forum.example.com/post/14',
+        post: "<h2>Final example post</h2><p>To complete the dataset, here is a <strong>bold</strong> statement and an image: <img src='https://example.com/image.jpg' alt='Example Image'></p>",
+        author: {
+          id: 126,
+          name: 'Bob Williams',
+          avatar: 'https://d3fzm1tzeyr5n3.cloudfront.net/profile_picture_url/5f6abe99-f1ed-49ec-aff4-893c017ed1aa-1681577292-565638.jpg'
+        }
+      }
+    ]
+  };
+
+  return {
+    data: results.entity,
+    meta: {}
+  };
+}

package/src/services/railcontent.js

@@ -290,6 +290,10 @@ async function patchDataHandler(url, data) {
   return fetchHandler(url, 'patch', null, data)
 }
 
+async function deleteDataHandler(url, data) {
+  return fetchHandler(url, 'delete')
+}
+
 export async function fetchHandler(url, method = 'get', dataVersion = null, body = null) {
   let headers = {
     'Content-Type': 'application/json',
@@ -645,7 +649,7 @@ export async function fetchUserPlaylists(
   const content = content_id ? `&content_id=${content_id}` : ''
   const categoryString =
     categories && categories.length ? categories.map((cat) => `categories[]=${cat}`).join('&') : ''
-  url = `/playlists/all?brand=${brand}${limitString}${pageString}${sortString}${searchFilter}${content}${categoryString ? `&${categoryString}` : ''}`
+  url = `/api/content/v1/user/playlists/all?brand=${brand}${limitString}${pageString}${sortString}${searchFilter}${content}${categoryString ? `&${categoryString}` : ''}`
   return await fetchHandler(url)
 }
 
@@ -771,7 +775,7 @@ export async function updatePlaylist(playlistId, updatedData) {
  *   .catch(error => console.error('Error creating playlist:', error));
  */
 export async function createPlaylist(playlistData) {
-  const url = `/playlists/playlist`
+  const url = `/api/content/v1/user/playlists/playlist`
   return await fetchHandler(url, 'POST', null, playlistData)
 }
 
@@ -1037,7 +1041,7 @@ export async function postContentReset(contentId) {
  *   });
  */
 export async function addItemToPlaylist(payload) {
-  const url = `/playlists/add-item`
+  const url = `/api/content/v1/user/playlists/add-item`
   return await fetchHandler(url, 'POST', null, payload)
 }
 
@@ -1206,28 +1210,28 @@ export async function setStudentViewForUser(userId, enable) {
  * @returns {Promise<Object|null>} - A promise that resolves to an comment object
  */
 export async function fetchTopComment(railcontentId) {
-  const url = `/api/content/v1/comments/${railcontentId}/top`
+  const url = `/api/content/v1/comments/content/${railcontentId}/top`
   return await fetchHandler(url)
 }
 
 
 /**
  *
- * @param railcontentId
- * @param page
- * @param limit
+ * @param {int} railcontentId
+ * @param {int} page
+ * @param {int} limit
  * @returns {Promise<*|null>}
  */
 export async function fetchComments(railcontentId, page = 1, limit = 20) {
-  const url = `/api/content/v1/comments/${railcontentId}/all?page=${page}&limit=${limit}`
+  const url = `/api/content/v1/comments/content/${railcontentId}/all?page=${page}&limit=${limit}`
   return await fetchHandler(url)
 }
 
 /**
  *
- * @param commentId
- * @param page
- * @param limit
+ * @param {int} commentId
+ * @param {int} page
+ * @param {int} limit
  * @returns {Promise<*|null>}
  */
 export async function fetchCommentRelies(commentId, page = 1, limit = 20) {
@@ -1235,6 +1239,115 @@ export async function fetchCommentRelies(commentId, page = 1, limit = 20) {
   return await fetchHandler(url)
 }
 
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function deleteComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}`
+  return await fetchHandler(url, "DELETE")
+}
+
+/**
+ * @param {int} commentId
+ * @param {string} comment
+ * @returns {Promise<*|null>}
+ */
+export async function replyToComment(commentId, comment) {
+  const data = {'comment' : comment}
+  const url = `/api/content/v1/comments/${commentId}/reply`
+  return await postDataHandler(url, data)
+}
+
+/**
+ * @param {int} railcontentId
+ * @param {string} comment
+ * @returns {Promise<*|null>}
+ */
+export async function createComment(railcontentId, comment) {
+  const data = {
+    'comment' : comment,
+    'content_id' : railcontentId
+  }
+  const url = `/api/content/v1/comments/store`
+  return await postDataHandler(url, data)
+}
+
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function assignModeratorToComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}/assign_moderator`
+  return await postDataHandler(url)
+}
+
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function unassignModeratorToComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}/unassign_moderator`
+  return await postDataHandler(url)
+}
+
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function likeComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}/like`
+  return await postDataHandler(url)
+}
+
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function unlikeComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}/like`
+  return await deleteDataHandler(url)
+}
+
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function closeComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}`
+  const data = {
+    'conversation_status' : 'closed'
+  }
+  return await patchDataHandler(url, data)
+}
+
+/**
+ * @param {int} commentId
+ * @returns {Promise<*|null>}
+ */
+export async function openComment(commentId) {
+  const url = `/api/content/v1/comments/${commentId}`
+  const data = {
+    'conversation_status' : 'open'
+  }
+  return await patchDataHandler(url, data)
+}
+
+/**
+ * @param {int} commentId
+ * @param {string} comment
+ * @returns {Promise<*|null>}
+ */
+export async function editComment(commentId, comment) {
+  const url = `/api/content/v1/comments/${commentId}`
+  const data = {
+    'comment' : comment
+  }
+  return await patchDataHandler(url, data)
+}
+
+
+
 function fetchAbsolute(url, params) {
   if (globalConfig.railcontentConfig.authToken) {
     params.headers['Authorization'] = `Bearer ${globalConfig.railcontentConfig.authToken}`

package/src/services/recommendations.js

@@ -109,6 +109,25 @@ export async function rankItems(brand, content_ids) {
   }
 }
 
+export async function recommendations(brand, {
+  page = 1,
+  limit = 10,
+} = {}) {
+  let data = {
+    'brand': brand,
+    'user_id': globalConfig.railcontentConfig.userId,
+    'num_recommendations': limit
+  }
+  const url = `/recommendations/`
+  try {
+    const response = await fetchHandler(url, 'POST', data)
+    return response['recommendations']
+  } catch (error) {
+    console.error('Fetch error:', error)
+    return null
+  }
+}
+
 async function fetchHandler(url, method = 'get', body = null) {
 
   let headers = {