musora-content-services 2.154.0 → 2.155.0

package/src/services/content.js

@@ -16,14 +16,12 @@ import {
 import {TabResponseType, Tabs, capitalizeFirstLetter} from '../contentMetaData.js'
 import {recommendations, rankCategories, rankItems} from "./recommendations";
 import {addContextToContent} from "./contentAggregator.js";
-import {globalConfig} from "./config";
 import {getUserData} from "./user/management";
 import {
   lessonTypesMapping,
   ownedContentTypes
 } from "../contentTypeConfig";
-import {getPermissionsAdapter} from "./permissions/index.ts";
-import {MEMBERSHIP_PERMISSIONS} from "../constants/membership-permissions.ts";
+import { fetchUserPermissions, getPermissionsAdapter, isUserFreeTier, doesUserHaveMembership } from './permissions/index.ts'
 
 
 export async function getLessonContentRows (brand='drumeo', pageName = 'lessons') {
@@ -93,9 +91,12 @@ export async function getTabResults(brand, pageName, tabName, {
   sort = 'recommended',
   selectedFilters = []
 } = {}) {
-
   if (!tabName && ['lessons', 'songs'].includes(pageName)) return { type: TabResponseType.CATALOG, data: [], meta: { filters: [], sort: {} } }
 
+  const userPermissions = await fetchUserPermissions()
+  const permissions = userPermissions.permissions || []
+  const isFreeTier = isUserFreeTier(userPermissions)
+
   // Extract and handle 'progress' filter separately
   const progressFilter = selectedFilters.find(f => f.startsWith('progress,')) || 'progress,all';
   const progressValue = progressFilter.split(',')[1].toLowerCase();
@@ -131,6 +132,10 @@ export async function getTabResults(brand, pageName, tabName, {
 
       recommendedContent = filterCoursesInCourseCollections(recommendedContent)
 
+      if (isFreeTier) {
+        recommendedContent = applyPermissionsPostSort(recommendedContent, permissions)
+      }
+
       const start = (page - 1) * limit
       const end = start + limit
       const pagesFilledByRec = Math.floor(recommendedContent.length / limit)
@@ -143,7 +148,8 @@ export async function getTabResults(brand, pageName, tabName, {
           sort: '-published_on',
           includedFields: mergedIncludedFields,
           progress: progressValue,
-          excludeIds: recommendedContent.map(c => c.id)
+          excludeIds: recommendedContent.map(c => c.id),
+          sortPermissions: permissions,
         })
 
         // Filter out duplicates and combine
@@ -163,7 +169,8 @@ export async function getTabResults(brand, pageName, tabName, {
         limit,
         sort: '-published_on',
         includedFields: mergedIncludedFields,
-        progress: progressValue
+        progress: progressValue,
+        sortPermissions: permissions,
       })
       contentToDisplay = temp.entity
     }
@@ -175,7 +182,17 @@ export async function getTabResults(brand, pageName, tabName, {
       addProgressStatus: true
     })
   } else {
-    let temp = await fetchTabData(brand, pageName, { page, limit, sort, includedFields: mergedIncludedFields, progress: progressValue });
+    let temp = await fetchTabData(
+      brand,
+      pageName,
+      {
+        page,
+        limit,
+        sort,
+        includedFields: mergedIncludedFields,
+        progress: progressValue,
+        sortPermissions: permissions,
+      });
     const [ranking, contextResults] = await Promise.all([
       sort === 'recommended' ? rankItems(brand, temp.entity.map(e => e.id)) : [],
       addContextToContent(() => temp.entity, {
@@ -550,9 +567,7 @@ export async function getLegacyMethods(brand)
   const userPermissions = userPermissionsData.permissions
   // Users should only have access to this if they have an active membership AS WELL as the content access
   // This is hardcoded behaviour and isn't found elsewhere
-  const hasMembership = userPermissionsData.isAdmin
-    || userPermissions.includes(MEMBERSHIP_PERMISSIONS.base)
-    || userPermissions.includes(MEMBERSHIP_PERMISSIONS.plus)
+  const hasMembership = doesUserHaveMembership(userPermissionsData)
   const hasContentPermission = userPermissions.includes(100000000 + ids[0])
   if (hasMembership && hasContentPermission) {
    return Promise.all(ids.map(id => fetchCourseCollectionData(id)))
@@ -625,3 +640,14 @@ export async function getOwnedContent(brand, {
 export function filterCoursesInCourseCollections(data) {
   return data.filter(c => !(c.type === 'course' && c.parent_id))
 }
+
+function applyPermissionsPostSort(contentList, permissionIds) {
+  contentList.sort((a, b) => {
+    const hasAccess = (item) =>
+      item.permission_id?.includes(permissionIds)
+
+    return hasAccess(b) - hasAccess(a);
+  });
+
+  return contentList;
+}

package/src/services/contentProgress.js

@@ -1,10 +1,17 @@
-import { getHierarchy } from './sanity.js'
+import { getHierarchy, getHierarchies } from './sanity.js'
 import { db } from './sync'
 import { COLLECTION_ID_SELF, COLLECTION_TYPE, STATE } from './sync/models/ContentProgress'
-import { trackUserPractice, findIncompleteLesson } from './userActivity'
+import { trackUserPractice } from './userActivity'
 import { getNextLessonLessonParentTypes } from '../contentTypeConfig.js'
 import { getDailySession, onContentCompletedLearningPathActions } from './content-org/learning-paths.ts'
 
+/**
+ * Exported functions that are excluded from index generation.
+ *
+ * @type {string[]}
+ */
+const excludeFromGeneratedIndex = ['_recordWatchSession', 'setStartedOrCompletedStatus', 'setStartedOrCompletedStatusMany', 'resetStatus']
+
 const STATE_STARTED = STATE.STARTED
 const STATE_COMPLETED = STATE.COMPLETED
 const MAX_DEPTH = 3
@@ -46,7 +53,7 @@ export async function getNavigateToForMethod(data) {
   for (const content of data) {
     if (!content) continue
 
-    const { _, collection } = extractFromRecordId(content.record_id)
+    const { collection } = extractFromRecordId(content.record_id)
 
     const findFirstIncomplete = (ids, progresses) =>
       ids.find(id => progresses.get(id) !== STATE_COMPLETED) || ids[0]
@@ -181,6 +188,28 @@ export async function getNavigateTo(data) {
   return navigateToData
 }
 
+function findIncompleteLesson(progressOnItems, currentContentId, contentType) {
+  const isMap = progressOnItems instanceof Map
+  const ids = isMap ? Array.from(progressOnItems.keys()) : Object.keys(progressOnItems).map(Number)
+  const getProgress = (id) => isMap ? progressOnItems.get(id) : progressOnItems[id]
+
+  if (contentType === 'guided-course' || contentType === COLLECTION_TYPE.LEARNING_PATH) {
+    return ids.find((id) => getProgress(id) !== 'completed') || ids.at(0)
+  }
+
+  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 (getProgress(id) !== 'completed') {
+      return id
+    }
+  }
+
+  return ids[0]
+}
+
 function buildNavigateTo(content, child = null, collection = null) {
   if (!content) {
     return null
@@ -405,10 +434,10 @@ async function _getAllStartedOrCompleted({
  * @param {int} mediaLengthSeconds - total length of video media || live event duration if livestream
  * @param {int} currentSeconds - seconds timestamp relative to beginning of video
  * @param {int} secondsPlayed - seconds played in this watch session (since last pause)
- * @param {any} prevSession - This function records a sessionId to pass into future updates to progress on the same video
+ * @param {string|null} prevSession - This function records a sessionId to pass into future updates to progress on the same video
  * @param {int|null} instrumentId - enum value of instrument id
  * @param {int|null} categoryId - enum value of category id
- * @param {boolean} isLivestream - determines livestream-specific progress handling
+ * @param {boolean|null} isLivestream - determines livestream-specific progress handling
  */
 export async function recordWatchSession(
   contentId,
@@ -419,6 +448,53 @@ export async function recordWatchSession(
   instrumentId = null,
   categoryId = null,
   isLivestream = false,
+) {
+  return _recordWatchSession(
+    contentId,
+    mediaLengthSeconds,
+    currentSeconds,
+    secondsPlayed,
+    {
+      collection,
+      prevSession,
+      instrumentId,
+      categoryId,
+      isLivestream,
+    })
+}
+
+/**
+ * internal function to be called by only or offline version of recordWatchSession
+ * @return {string} sessionId - provide in future calls to update progress
+ * @param {int} contentId
+ * @param {any} collection - progress collection context, null if a-la-carte
+ * @param {string} collection.type - enum value of collection type
+ * @param {int} collection.id - content_id of parent collection (e.g. learning path content_id)
+ * @param {int} mediaLengthSeconds - total length of video media || live event duration if livestream
+ * @param {int} currentSeconds - seconds timestamp relative to beginning of video
+ * @param {int} secondsPlayed - seconds played in this watch session (since last pause)
+ * @param {string|null} prevSession - This function records a sessionId to pass into future updates to progress on the same video
+ * @param {int|null} instrumentId - enum value of instrument id
+ * @param {int|null} categoryId - enum value of category id
+ * @param {boolean|null} isLivestream - determines livestream-specific progress handling
+ * @param {boolean} isOffline - whether this watch session is being recorded in offline mode, which affects how progress is tracked and pushed
+ * @param {object|null} hierarchy - response from getHierarchy, passed in to avoid redundant calls within the same session
+ * @private
+ */
+export async function _recordWatchSession(
+  contentId,
+  mediaLengthSeconds,
+  currentSeconds,
+  secondsPlayed,
+  {
+    collection = null,
+    prevSession = null,
+    instrumentId = null,
+    categoryId = null,
+    isLivestream = false,
+    isOffline = false,
+    hierarchy = null,
+  } = {}
 ) {
   contentId = normalizeContentId(contentId)
   collection = normalizeCollection(collection)
@@ -426,7 +502,7 @@ export async function recordWatchSession(
   // Track practice and progress locally (no immediate push)
   await Promise.all([
     trackPractice(contentId, secondsPlayed, { instrumentId, categoryId }),
-    trackProgress(contentId, collection, currentSeconds, mediaLengthSeconds, isLivestream),
+    trackProgress(contentId, collection, currentSeconds, mediaLengthSeconds, isLivestream, isOffline, hierarchy),
   ])
 }
 
@@ -439,7 +515,15 @@ async function trackPractice(contentId, secondsPlayed, details = {}) {
   return trackUserPractice(contentId, secondsPlayed, details)
 }
 
-async function trackProgress(contentId, collection, currentSeconds, mediaLengthSeconds, isLivestream = false) {
+async function trackProgress(
+  contentId,
+  collection,
+  currentSeconds,
+  mediaLengthSeconds,
+  isLivestream = false,
+  isOffline = false,
+  hierarchy = null,
+) {
   const progress = Math.max(1, Math.min(
     99,
     Math.round(((currentSeconds ?? 0) / Math.max(1, mediaLengthSeconds)) * 100)
@@ -450,25 +534,17 @@ async function trackProgress(contentId, collection, currentSeconds, mediaLengthS
     // doesn't affect livestream resumeTime, but will send users to 0 seconds in VOD
     currentSeconds = 0
   }
-  return saveContentProgress(contentId, collection, progress, currentSeconds, { skipPush: true })
+  return saveContentProgress(contentId, collection, progress, currentSeconds, { isOffline, hierarchy, skipPush: true })
 }
 
 export async function contentStatusCompleted(contentId, collection = null) {
   collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
-  return setStartedOrCompletedStatus(
-    normalizeContentId(contentId),
-    normalizeCollection(collection),
-    true
-  )
+  return setStartedOrCompletedStatus(contentId, collection, true)
 }
 
 export async function contentStatusCompletedMany(contentIds, collection = null) {
   collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
-  return setStartedOrCompletedStatusMany(
-    normalizeContentIds(contentIds),
-    normalizeCollection(collection),
-    true
-  )
+  return setStartedOrCompletedStatusMany(contentIds, collection, true)
 }
 
 // skipBubbleTrickle is only for starting enrolled GC's as a hack to get them into the progress row.
@@ -486,7 +562,18 @@ export async function contentStatusReset(contentId, collection = null, {skipPush
   return resetStatus(contentId, collection, {skipPush})
 }
 
-async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false, accessedDirectly = true} = {}) {
+async function saveContentProgress(
+  contentId,
+  collection,
+  progress,
+  currentSeconds,
+  {
+    isOffline = false,
+    hierarchy = null,
+    skipPush = false,
+    accessedDirectly = true,
+  } = {}
+) {
   collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
   const isPlaylist = collection?.type === COLLECTION_TYPE.PLAYLIST
@@ -498,7 +585,9 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
     progress = currentProgress
   }
 
-  const hierarchy = await getHierarchy(contentId, collection)
+  if (!isOffline) {
+    hierarchy = await getHierarchy(contentId, collection)
+  }
   const metadata = hierarchy.metadata || {}
 
   if (isPlaylist) {
@@ -518,10 +607,10 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
   // note - previous implementation explicitly did not trickle progress to children here
   // (only to siblings/parents via le bubbles)
 
-  // skip bubbling if progress hasnt changed
-  if (progress === currentProgress) {
+  // skip bubbling if progress hasnt changed, or if offline
+  if (progress === currentProgress || offline) {
     if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
-    return
+    return response
   }
 
   const bubbledProgresses = await bubbleProgress(hierarchy, contentId, collection)
@@ -542,6 +631,7 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
       {skipPush: true, accessedDirectly})
   }
 
+  // there are problems if we allow downloading LPs, since we require 2 different hierarchies for this.
   if (isLP) {
     let exportIds = bubbledProgresses
     exportIds[contentId] = progress
@@ -561,10 +651,12 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
   return response
 }
 
-async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {skipPush = false, skipBubbleTrickle = false} = {}) {
+async function setStartedOrCompletedStatus(contentId, collection, isCompleted, { isOffline = false, hierarchy = null, skipPush = false, skipBubbleTrickle = false } = {}) {
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
-  const hierarchy = await getHierarchy(contentId, collection)
+  if (!isOffline) {
+    hierarchy = await getHierarchy(contentId, collection)
+  }
   const metadata = hierarchy.metadata || {}
 
   const progress = isCompleted ? 100 : 0
@@ -576,7 +668,13 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
     null,
     {skipPush: true}
   )
-
+  
+  // skip bubbling if offline
+  if (isOffline) {
+    if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
+    return response
+  }
+  
   let allProgresses = {}
   allProgresses[contentId] = progress
 
@@ -605,12 +703,16 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
   return response
 }
 
-async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted, {skipPush = false} = {}) {
+export async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted, { isOffline = false, hierarchy = null, skipPush = false } = {}) {
+  contentIds = normalizeContentIds(contentIds)
+  collection = normalizeCollection(collection)
+
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
   const progress = isCompleted ? 100 : 0
 
-  // we assume this is used only for contents within the same hierarchy
-  const hierarchy = await getHierarchy(collection.id, collection)
+  if (!isOffline) {
+    hierarchy = await getHierarchies(contentIds, collection)
+  }
   const metadata = hierarchy.metadata || {}
 
   const contents = Object.fromEntries(contentIds.map((id) => [id, progress]))
@@ -621,6 +723,12 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
     {skipPush: true}
   )
 
+  // skip bubbling if offline
+  if (isOffline) {
+    if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
+    return response
+  }
+  
   let allProgresses = Object.fromEntries(contentIds.map(id => [id, progress]))
 
   let progresses = {}
@@ -650,15 +758,24 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
   return response
 }
 
-async function resetStatus(contentId, collection = null, {skipPush = false} = {}) {
+export async function resetStatus(contentId, collection = null, { isOffline = false, hierarchy = null, skipPush = false } = {}) {
+  contentId = normalizeContentId(contentId)
+  collection = normalizeCollection(collection)
+
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
   const progress = 0
   const response = await db.contentProgress.eraseProgress(normalizeContentId(contentId), normalizeCollection(collection), {skipPush: true})
-
-  const hierarchy = await getHierarchy(contentId, collection)
+  
+  // skip bubbling if offline
+  if (isOffline) {
+    if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
+    return response
+  }
+  
+  hierarchy = await getHierarchy(contentId, collection)
   const metadata = hierarchy.metadata || {}
-
+  
   let allProgresses = {}
   allProgresses[contentId] = progress
 

package/src/services/offline/activities.ts

@@ -0,0 +1,97 @@
+import { db } from '../sync'
+import { Q } from '@nozbe/watermelondb'
+import { STATE } from '../sync/models/ContentProgress'
+import { lessonRecentTypes, SONG_TYPES } from '../../contentTypeConfig.js'
+import dayjs from 'dayjs'
+
+interface Activity {
+  contentId: number
+  action: 'Start' | 'Complete'
+  contentType: 'lesson' | 'song'
+  date: string
+  brand: string
+}
+
+/**
+ * @param offlineTimestamp - Minimum `updated_at` epoch ms to include
+ * @param options.page - Page number (default 1)
+ * @param options.limit - Results per page (default 5)
+ * @param options.tabName - Restrict to `'lessons'`, `'songs'`, or both when `null`
+ * @returns `{ currentPage, totalPages, data }` where `data` is a page of `Activity` records
+ */
+export async function getRecentActivityOffline(
+  offlineTimestamp: number,
+  {
+    page = 1,
+    limit = 5,
+    tabName = null
+  }: {
+    page?: number,
+    limit?: number,
+    tabName?: 'lessons'|'songs'|null
+  } = {}): Promise<any> {
+  // Note: this is kind of a hack. We're really just getting RADFOP: Recent Activities Derived From Offline Progress,
+  // because setting up watermelon user activities table is extremely complicated.
+  // Note: this implementation does not persist "activities" beyond when the corresponding record is deleted. That's ok right now.
+
+  const clauses = getClauses(offlineTimestamp, tabName)
+
+  const query = await db.contentProgress.queryAll(...clauses)
+  const progress = query.data
+
+  const activities = deriveActivitiesFromProgress(progress)
+
+  const totalPages = Math.ceil(activities.length / limit)
+  const currentPage = Math.min(page, totalPages)
+
+  const sorted = activities.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+  const data = sorted.slice((currentPage - 1) * limit, currentPage * limit)
+
+  return {
+    currentPage,
+    totalPages,
+    data,
+  }
+}
+
+function getClauses(offlineTimestamp: number, tabName: string|null) {
+  let clauses: Q.Clause[] = [
+    Q.where('updated_at', Q.gte(offlineTimestamp)),
+    Q.sortBy('created_at', 'desc'),
+  ]
+
+  if (tabName === 'lessons') {
+    clauses.push(Q.where('content_type', Q.oneOf(lessonRecentTypes)))
+  } else if (tabName === 'songs') {
+    clauses.push(Q.where('content_type', Q.oneOf(SONG_TYPES)))
+  } else {
+    clauses.push(Q.where('content_type', Q.oneOf([...lessonRecentTypes, ...SONG_TYPES])))
+  }
+
+  return clauses
+}
+
+function deriveActivitiesFromProgress(progress: Record<any, any>) {
+  const activities: Activity[] = []
+  progress.forEach(p => {
+    const type = lessonRecentTypes.includes(p.content_type) ? 'lesson' : 'song'
+
+    activities.push({
+      contentId: p.content_id,
+      action: 'Start',
+      contentType: type,
+      date: dayjs(p.created_at).toISOString(),
+      brand: p.content_brand,
+    })
+    if (p.state === STATE.COMPLETED) {
+      activities.push({
+        contentId: p.content_id,
+        action: 'Complete',
+        contentType: type,
+        date: dayjs(p.updated_at).toISOString(),
+        brand: p.content_brand,
+      })
+    }
+  })
+  return activities
+}

package/src/services/offline/practices.ts

@@ -0,0 +1,47 @@
+import { db } from '../sync'
+import { Q } from '@nozbe/watermelondb'
+import dayjs from 'dayjs'
+import { globalConfig } from '../config'
+import { calculateLongestStreaks } from '../userActivity.js'
+
+/**
+ * @param offlineTimestamp - Minimum `updated_at` epoch ms to include
+ * @param options.day - Date in YYYY-MM-DD format, defaults to today
+ * @returns `{ data: { practices, practiceDuration } }` where `practiceDuration` is total seconds
+ */
+export async function getPracticeSessionsOffline(
+  offlineTimestamp: number,
+  { day = dayjs().format('YYYY-MM-DD') }: { day?: string } = {}
+) {
+
+  const query = await db.practices.queryAll(
+    Q.where('updated_at', Q.gte(offlineTimestamp)),
+    Q.where('date', day),
+    Q.sortBy('created_at', 'asc'))
+  const practices = query.data
+
+  if (!practices.length) return { data: { practices: [], practiceDuration: 0 } }
+
+  const practiceDuration = Math.round(practices.reduce(
+    (total, practice) => total + (practice.duration_seconds || 0),
+    0
+  ))
+
+  return { data: { practices, practiceDuration } }
+}
+
+export async function otherStatsOffline(userId = globalConfig.sessionConfig.userId) {
+  const longestStreaks = await calculateLongestStreaks(userId)
+
+  return {
+    longest_day_streak: {
+      type: 'day',
+      length: longestStreaks.longestDailyStreak,
+    },
+    longest_week_streak: {
+      type: 'week',
+      length: longestStreaks.longestWeeklyStreak,
+    },
+    total_practice_time: longestStreaks.totalPracticeSeconds,
+  }
+}

package/src/services/offline/progress.ts

@@ -0,0 +1,104 @@
+import {
+  _recordWatchSession, resetStatus,
+  setStartedOrCompletedStatus,
+  setStartedOrCompletedStatusMany,
+} from '../contentProgress.js'
+import { COLLECTION_ID_SELF, COLLECTION_TYPE, CollectionParameter, STATE } from '../sync/models/ContentProgress'
+
+interface HierarchyParameter {
+  topLevelId: number
+  parents: { [contentId: number]: [parentId: number] }
+  children: { [contentId: number]: [childId: number] }
+  metadata: {
+    brand: string
+    parent_id: number
+    type: string
+  }
+}
+
+/**
+ * @param contentId
+ * @param mediaLengthSeconds - Total length of the media
+ * @param currentSeconds - Playhead position at session end
+ * @param secondsPlayed - Seconds actively watched in this session
+ * @param hierarchy - Content hierarchy used to update parent progress offline
+ * @param options.collection - Collection context; defaults to self
+ * @param options.prevSession - Previous session identifier for continuity
+ * @param options.instrumentId - Instrument filter for the session
+ * @param options.categoryId - Category filter for the session
+ */
+export async function recordWatchSessionOffline(
+  contentId: number,
+  mediaLengthSeconds: number,
+  currentSeconds: number,
+  secondsPlayed: number,
+  hierarchy: HierarchyParameter,
+  {
+    collection = null,
+    prevSession = null,
+    instrumentId = null,
+    categoryId = null,
+  }: {
+    collection?: CollectionParameter|null,
+    prevSession?: string|null,
+    instrumentId?: number|null,
+    categoryId?: number|null
+  } = {}
+) {
+  return _recordWatchSession(
+    contentId,
+    mediaLengthSeconds,
+    currentSeconds,
+    secondsPlayed,
+    {
+      collection,
+      prevSession,
+      instrumentId,
+      categoryId,
+      isOffline: true,
+      hierarchy,
+    })
+}
+
+/**
+ * @param contentId
+ * @param collection - Collection context; defaults to self
+ * @param hierarchy - Content hierarchy used to update parent progress offline
+ */
+export async function contentStatusCompletedOffline(contentId: number, collection: CollectionParameter = null, hierarchy: HierarchyParameter) {
+  collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
+  return setStartedOrCompletedStatus(contentId, collection, true, {isOffline: true, hierarchy})
+}
+
+/**
+ * @param contentIds
+ * @param collection - Collection context; defaults to self
+ * @param hierarchy - Content hierarchy used to update parent progress offline
+ */
+export async function contentStatusCompletedManyOffline(contentIds: number[], collection: CollectionParameter = null, hierarchy: HierarchyParameter) {
+  collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
+  return setStartedOrCompletedStatusMany(contentIds, collection, true, {isOffline: true, hierarchy})
+}
+
+/**
+ * @param contentId
+ * @param collection - Collection context; defaults to self
+ * @param hierarchy - Content hierarchy used to update parent progress offline
+ */
+export async function contentStatusStartedOffline(contentId: number, collection: CollectionParameter = null, hierarchy: HierarchyParameter) {
+  collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
+  return setStartedOrCompletedStatus(contentId, collection, false, {isOffline: true, hierarchy})
+}
+
+/**
+ * @param contentId
+ * @param collection - Collection context; defaults to self
+ * @param hierarchy - Content hierarchy used to update parent progress offline
+ * @param options.skipPush - Skip queuing the reset for server sync (default false)
+ */
+export async function contentStatusResetOffline(contentId: number, collection: CollectionParameter = null, hierarchy: HierarchyParameter, {skipPush = false} = {}) {
+  collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
+  return resetStatus(contentId, collection, {hierarchy, skipPush})
+}
+
+