musora-content-services 2.94.7 → 2.95.0

package/src/services/awards/internal/award-definitions.js

@@ -0,0 +1,239 @@
+/**
+ * @module Awards
+ */
+
+
+/**  @typedef {Map} AwardDefinitionsMap */
+/**  @typedef {Map} ContentToAwardsMap */
+
+const STORAGE_KEY = 'musora_award_definitions_last_fetch'
+
+class AwardDefinitionsService {
+  constructor() {
+    /** @type {AwardDefinitionsMap} */
+    this.definitions = new Map()
+
+    /** @type {ContentToAwardsMap} */
+    this.contentIndex = new Map()
+
+    /** @type {number} */
+    this.lastFetch = 0
+
+    /** @type {number} */
+    this.cacheDuration = 24 * 60 * 60 * 1000
+
+    /** @type {boolean} */
+    this.isFetching = false
+
+    /** @type {boolean} */
+    this.initialized = false
+  }
+
+  /** @returns {Promise<import('./types').AwardDefinition[]>} */
+  async getAll(forceRefresh = false) {
+    if (this.shouldRefresh() || forceRefresh) {
+      await this.fetchFromSanity()
+    }
+    return Array.from(this.definitions.values())
+  }
+
+  /** @returns {Promise<import('./types').AwardDefinition | null>} */
+  async getById(awardId) {
+    if (this.shouldRefresh()) {
+      await this.fetchFromSanity()
+    }
+    return this.definitions.get(awardId) || null
+  }
+
+  /** @returns {Promise<import('./types').AwardDefinition[]>} */
+  async getByContentId(contentId) {
+    if (this.shouldRefresh()) {
+      await this.fetchFromSanity()
+    }
+
+    const awardIds = this.contentIndex.get(contentId) || []
+    return awardIds
+      .map(id => this.definitions.get(id))
+      .filter(Boolean)
+  }
+
+  /** @returns {Promise<boolean>} */
+  async hasAwards(contentId) {
+    if (this.shouldRefresh()) {
+      await this.fetchFromSanity()
+    }
+    return (this.contentIndex.get(contentId)?.length ?? 0) > 0
+  }
+
+  /** @returns {Promise<void>} */
+  async fetchFromSanity() {
+    if (this.isFetching) {
+      return new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (!this.isFetching) {
+            clearInterval(checkInterval)
+            resolve()
+          }
+        }, 100)
+      })
+    }
+
+    this.isFetching = true
+
+    try {
+      const { fetchSanity } = await import('../../sanity')
+      const { FilterBuilder } = await import('../../../filterBuilder')
+
+      const childFilter = await new FilterBuilder('@->exclude_from_awards_calculation != true', {
+        isChildrenFilter: true,
+        bypassPublishedDateRestriction: true,
+        bypassPermissions: true,
+      }).buildFilter()
+
+      const query = `*[_type == 'content-award'] {
+        _id,
+        is_active,
+        name,
+        'logo': logo.asset->url,
+        'badge': badge.asset->url,
+        'award': award.asset->url,
+        'content_id': content->railcontent_id,
+        'content_type': content->_type,
+        'type': _type,
+        brand,
+        'content_title': content->title,
+        award_custom_text,
+        'instructor_name': content->instructor[0]->name,
+        'child_ids': content->child[${childFilter}]->railcontent_id,
+      }`
+
+      const awards = await fetchSanity(query, true, { processNeedAccess: false })
+
+      this.definitions.clear()
+      this.contentIndex.clear()
+
+      awards.forEach(award => {
+        this.definitions.set(award._id, award)
+
+        if (award.content_id) {
+          const existing = this.contentIndex.get(award.content_id) || []
+          this.contentIndex.set(award.content_id, [...existing, award._id])
+        }
+
+        if (award.child_ids && Array.isArray(award.child_ids)) {
+          award.child_ids.forEach(childId => {
+            if (childId) {
+              const existing = this.contentIndex.get(childId) || []
+              this.contentIndex.set(childId, [...existing, award._id])
+            }
+          })
+        }
+      })
+
+      this.lastFetch = Date.now()
+      await this.saveLastFetchToStorage()
+    } catch (error) {
+      console.error('Failed to fetch award definitions from Sanity:', error)
+    } finally {
+      this.isFetching = false
+    }
+  }
+
+  /** @returns {boolean} */
+  shouldRefresh() {
+    return this.definitions.size === 0 ||
+           (Date.now() - this.lastFetch) > this.cacheDuration
+  }
+
+  /** @returns {Promise<void>} */
+  async refresh() {
+    await this.fetchFromSanity()
+  }
+
+  async loadLastFetchFromStorage() {
+    try {
+      const { globalConfig } = await import('../../config')
+      if (!globalConfig.localStorage) {
+        return
+      }
+
+      const stored = globalConfig.isMA
+        ? await globalConfig.localStorage.getItem(STORAGE_KEY)
+        : globalConfig.localStorage.getItem(STORAGE_KEY)
+      if (stored) {
+        const timestamp = parseInt(stored, 10)
+        if (!isNaN(timestamp)) {
+          this.lastFetch = timestamp
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load lastFetch from storage:', error)
+    }
+  }
+
+  async saveLastFetchToStorage() {
+    try {
+      const { globalConfig } = await import('../../config')
+      if (!globalConfig.localStorage) {
+        return
+      }
+
+      if (globalConfig.isMA) {
+        await globalConfig.localStorage.setItem(STORAGE_KEY, this.lastFetch.toString())
+      } else {
+        globalConfig.localStorage.setItem(STORAGE_KEY, this.lastFetch.toString())
+      }
+    } catch (error) {
+      console.error('Failed to save lastFetch to storage:', error)
+    }
+  }
+
+  async initialize() {
+    if (this.initialized) {
+      return
+    }
+
+    await this.loadLastFetchFromStorage()
+
+    if (this.shouldRefresh()) {
+      await this.fetchFromSanity()
+    }
+
+    this.initialized = true
+  }
+
+  clear() {
+    this.definitions.clear()
+    this.contentIndex.clear()
+    this.lastFetch = 0
+    this.initialized = false
+  }
+
+  getCacheStats() {
+    return {
+      totalDefinitions: this.definitions.size,
+      totalContentMappings: this.contentIndex.size,
+      lastFetch: this.lastFetch ? new Date(this.lastFetch).toISOString() : null,
+      cacheAge: this.lastFetch ? Date.now() - this.lastFetch : null,
+      isFetching: this.isFetching,
+      initialized: this.initialized,
+      cacheDuration: this.cacheDuration
+    }
+  }
+}
+
+
+export const awardDefinitions = new AwardDefinitionsService()
+
+/** @returns {Promise<void>} */
+export async function initializeAwardDefinitions() {
+  await awardDefinitions.initialize()
+}
+
+/**
+ * @param {import('./types').AwardDefinition} award
+ * @returns {number[]}
+ */
+export function getEligibleChildIds(award) {
+  return award.child_ids || []
+}

package/src/services/awards/internal/award-events.js

@@ -0,0 +1,102 @@
+/**  @typedef {Object} AwardGrantedPayload */
+/**  @typedef {Object} AwardProgressPayload */
+/**  @callback AwardGrantedListener */
+/**  @callback AwardProgressListener */
+
+
+class AwardEventsService {
+  constructor() {
+    /** @type {Set<AwardGrantedListener>} */
+    this.awardGrantedListeners = new Set()
+
+    /** @type {Set<AwardProgressListener>} */
+    this.awardProgressListeners = new Set()
+  }
+
+  /**
+   * @param {'awardGranted' | 'awardProgress'} event - Event name
+   * @param {AwardGrantedListener | AwardProgressListener} listener - Listener function
+   * @returns {Function} Unsubscribe function
+   */
+  on(event, listener) {
+    if (event === 'awardGranted') {
+      this.awardGrantedListeners.add(listener)
+      return () => this.awardGrantedListeners.delete(listener)
+    } else if (event === 'awardProgress') {
+      this.awardProgressListeners.add(listener)
+      return () => this.awardProgressListeners.delete(listener)
+    }
+    return () => {}
+  }
+
+  /**
+   * @param {'awardGranted' | 'awardProgress'} event - Event name
+   * @param {AwardGrantedListener | AwardProgressListener} listener - Listener function
+   * @returns {void}
+   */
+  once(event, listener) {
+    const wrappedListener = (...args) => {
+      this.off(event, wrappedListener)
+      listener(...args)
+    }
+    this.on(event, wrappedListener)
+  }
+
+  /**
+   * @param {'awardGranted' | 'awardProgress'} event - Event name
+   * @param {AwardGrantedListener | AwardProgressListener} listener - Listener function
+   * @returns {void}
+   */
+  off(event, listener) {
+    if (event === 'awardGranted') {
+      this.awardGrantedListeners.delete(listener)
+    } else if (event === 'awardProgress') {
+      this.awardProgressListeners.delete(listener)
+    }
+  }
+
+  /**
+   * @param {AwardGrantedPayload} payload - Event payload
+   * @returns {void}
+   */
+  emitAwardGranted(payload) {
+    this.awardGrantedListeners.forEach(listener => {
+      try {
+        listener(payload)
+      } catch (error) {
+        console.error('Error in awardGranted listener:', error)
+      }
+    })
+  }
+
+  /**
+   * @param {AwardProgressPayload} payload - Event payload
+   * @returns {void}
+   */
+  emitAwardProgress(payload) {
+    this.awardProgressListeners.forEach(listener => {
+      try {
+        listener(payload)
+      } catch (error) {
+        console.error('Error in awardProgress listener:', error)
+      }
+    })
+  }
+
+  /** @returns {void} */
+  removeAllListeners() {
+    this.awardGrantedListeners.clear()
+    this.awardProgressListeners.clear()
+  }
+
+  /** @returns {Object} Listener counts */
+  getListenerCounts() {
+    return {
+      awardGranted: this.awardGrantedListeners.size,
+      awardProgress: this.awardProgressListeners.size
+    }
+  }
+}
+
+
+export const awardEvents = new AwardEventsService()

package/src/services/awards/internal/award-manager.js

@@ -0,0 +1,162 @@
+import { awardDefinitions, getEligibleChildIds } from './award-definitions'
+import { awardEvents } from './award-events'
+import { generateCompletionData } from './completion-data-generator'
+import { AwardMessageGenerator } from './message-generator'
+import db from '../../sync/repository-proxy'
+import { STATE, COLLECTION_TYPE } from '../../sync/models/ContentProgress'
+import {getProgressStateByIds} from "../../contentProgress.js";
+
+async function getCompletionStates(contentIds, collection = null) {
+  const progress = await getProgressStateByIds(contentIds, collection)
+
+  return contentIds.map(id => {
+    return {
+      id,
+      completed: progress[id] === STATE.COMPLETED
+    }
+  })
+}
+
+function getCollectionFromAward(award) {
+  if (award.content_type === COLLECTION_TYPE.LEARNING_PATH && award.content_id) {
+    return { type: COLLECTION_TYPE.LEARNING_PATH, id: award.content_id }
+  }
+  return null
+}
+
+
+export class AwardManager {
+  async onContentCompleted(contentId) {
+    try {
+      const awards = await awardDefinitions.getByContentId(contentId)
+
+      if (awards.length === 0) {
+        return
+      }
+
+      for (const award of awards) {
+        await this.evaluateAward(award)
+      }
+    } catch (error) {
+      console.error('Error checking awards for completed content:', error)
+    }
+  }
+
+  async evaluateAward(award) {
+    try {
+      const hasCompleted = await db.userAwardProgress.hasCompletedAward(award._id)
+      if (hasCompleted) {
+        console.log(`Award ${award._id} already completed, skipping evaluation`)
+        return
+      }
+
+      const collection = getCollectionFromAward(award)
+      const isEligible = await this.checkAwardEligibility(award, collection)
+
+      if (isEligible) {
+        console.log(`Award ${award._id} is now eligible, granting award`)
+        await this.grantAward(award, collection)
+      } else {
+        await this.updateAwardProgress(award, collection)
+      }
+    } catch (error) {
+      console.error(`Error checking award ${award._id}:`, error)
+    }
+  }
+
+  async checkAwardEligibility(award, collection) {
+    try {
+      const childIds = getEligibleChildIds(award)
+
+      if (childIds.length === 0) {
+        return false
+      }
+
+      const completionStates = await getCompletionStates(childIds, collection)
+      return completionStates.every(state => state.completed)
+    } catch (error) {
+      console.error('Error checking award eligibility:', error)
+      return false
+    }
+  }
+
+  async grantAward(award, collection) {
+    const completionData = await generateCompletionData(award, collection)
+
+    const childIds = getEligibleChildIds(award)
+    const completionStates = await getCompletionStates(childIds, collection)
+
+    const completedLessonIds = completionStates
+      .filter(state => state.completed)
+      .map(state => state.id)
+
+    const progressData = {
+      completedLessonIds,
+      totalLessons: childIds.length,
+      completedCount: completedLessonIds.length
+    }
+
+    const popupMessage = AwardMessageGenerator.generatePopupMessage(completionData)
+
+    await db.userAwardProgress.recordAwardProgress(award._id, 100, {
+      completedAt: Date.now(),
+      completionData,
+      progressData,
+      immediate: true
+    })
+
+    awardEvents.emitAwardGranted({
+      awardId: award._id,
+      definition: award,
+      completionData,
+      popupMessage,
+      timestamp: Date.now()
+    })
+  }
+
+  async updateAwardProgress(award, collection) {
+    try {
+      const childIds = getEligibleChildIds(award)
+
+      if (childIds.length === 0) return
+
+      const completionStates = await getCompletionStates(childIds, collection)
+
+      const completedLessonIds = completionStates
+        .filter(state => state.completed)
+        .map(state => state.id)
+
+      const completedCount = completedLessonIds.length
+      const progressPercentage = Math.round((completedCount / childIds.length) * 100)
+
+      const progressData = {
+        completedLessonIds,
+        totalLessons: childIds.length,
+        completedCount
+      }
+
+      await db.userAwardProgress.recordAwardProgress(award._id, progressPercentage, {
+        progressData
+      })
+
+      awardEvents.emitAwardProgress({
+        awardId: award._id,
+        progressPercentage,
+        timestamp: Date.now()
+      })
+    } catch (error) {
+      console.error('Error updating award progress:', error)
+    }
+  }
+
+  async refreshDefinitions() {
+    await awardDefinitions.refresh()
+  }
+
+  clearDefinitionsCache() {
+    awardDefinitions.clear()
+  }
+}
+
+
+export const awardManager = new AwardManager()

package/src/services/awards/internal/certificate-builder.js

@@ -0,0 +1,66 @@
+/**
+ * @module Awards
+ */
+
+
+import { AWARD_ASSETS } from '../../../constants/award-assets'
+import { AwardMessageGenerator } from './message-generator'
+import { globalConfig } from '../../config'
+
+/** @returns {Promise<import('./types').CertificateData>} */
+export async function buildCertificateData(awardId) {
+  const { awardDefinitions } = await import('./award-definitions')
+  const { getUserData } = await import('../../user/management')
+  const db = await import('../../sync/repository-proxy')
+
+  const awardDef = await awardDefinitions.getById(awardId)
+
+  if (!awardDef) {
+    throw new Error(`Award definition not found: ${awardId}`)
+  }
+
+  const userProgress = await db.default.userAwardProgress.getByAwardId(awardId)
+
+  if (!userProgress.data || !userProgress.data.completion_data) {
+    throw new Error('Completion data not found in local database')
+  }
+
+  const completionData = userProgress.data.completion_data
+
+  const popupMessage = AwardMessageGenerator.generatePopupMessage(completionData)
+
+  const certificateMessage = AwardMessageGenerator.generateCertificateMessage(
+    completionData,
+    awardDef.award_custom_text
+  )
+
+  const userData = await getUserData()
+
+  return {
+    userId: globalConfig.sessionConfig.userId,
+    userName: userData?.display_name || userData?.name || 'User',
+    completedAt: userProgress.data.completed_at
+      ? new Date(userProgress.data.completed_at * 1000).toISOString()
+      : new Date().toISOString(),
+
+    awardId: awardDef._id,
+    awardType: awardDef.type || 'content-award',
+    awardTitle: awardDef.name,
+
+    popupMessage,
+    certificateMessage,
+
+    ribbonImage: AWARD_ASSETS.ribbon,
+    awardImage: awardDef.award,
+    badgeImage: awardDef.badge,
+    brandLogo: getBrandLogo(awardDef.brand),
+    musoraLogo: AWARD_ASSETS.musoraLogo,
+    musoraBgLogo: AWARD_ASSETS.musoraBgLogo,
+    instructorName: awardDef.instructor_name
+  }
+}
+
+function getBrandLogo(brand) {
+  const normalizedBrand = brand.toLowerCase()
+  return AWARD_ASSETS.brandLogos[normalizedBrand] || AWARD_ASSETS.musoraLogo
+}

package/src/services/awards/internal/completion-data-generator.js

@@ -0,0 +1,84 @@
+/**
+ * @module Awards
+ */
+
+
+/**
+ * @param {import('./types').AwardDefinition} award
+ * @param {{ type: string; id: number } | null} collection
+ * @returns {Promise<import('./types').CompletionData>}
+ */
+export async function generateCompletionData(award, collection = null) {
+  const db = await import('../../sync/repository-proxy')
+
+  const childIds = award.child_ids || []
+
+  const daysUserPracticed = await calculateDaysUserPracticed(childIds, db.default, collection)
+  const practiceMinutes = await calculatePracticeMinutes(childIds, db.default)
+  const contentTitle = award.content_title || generateContentTitle(award.name)
+
+  return {
+    content_title: contentTitle,
+    completed_at: new Date().toISOString(),
+    days_user_practiced: daysUserPracticed,
+    practice_minutes: practiceMinutes
+  }
+}
+
+/**
+ * @param {number[]} contentIds
+ * @param {any} db
+ * @param {{ type: string; id: number } | null} collection
+ * @returns {Promise<number>}
+ */
+async function calculateDaysUserPracticed(contentIds, db, collection = null) {
+  if (contentIds.length === 0) return 0
+
+  if (!db.contentProgress || typeof db.contentProgress.getSomeProgressByContentIds !== 'function') {
+    console.warn('contentProgress repository not available, returning 1 day')
+    return 1
+  }
+
+  const progressResult = await db.contentProgress.getSomeProgressByContentIds(contentIds, collection)
+  const progressRecords = progressResult.data || []
+
+  if (progressRecords.length === 0) return 0
+
+  const sortedRecords = [...progressRecords].sort((a, b) => a.created_at - b.created_at)
+  const earliestRecord = sortedRecords[0]
+  const earliestStartDate = earliestRecord.created_at * 1000
+
+  const now = Date.now()
+  const daysDiff = Math.floor((now - earliestStartDate) / (1000 * 60 * 60 * 24))
+
+  return Math.max(daysDiff, 1)
+}
+
+/**
+ * @param {number[]} contentIds
+ * @param {any} db
+ * @returns {Promise<number>}
+ */
+async function calculatePracticeMinutes(contentIds, db) {
+  if (contentIds.length === 0) return 0
+
+  if (!db.practices || typeof db.practices.sumPracticeMinutesForContent !== 'function') {
+    console.warn('practices repository not available, returning 0 practice minutes')
+    return 0
+  }
+
+  const totalMinutes = await db.practices.sumPracticeMinutesForContent(contentIds)
+
+  return totalMinutes
+}
+
+/**
+ * @param {string} awardName
+ * @returns {string}
+ */
+function generateContentTitle(awardName) {
+  return awardName
+    .replace(/^Complete\s+/i, '')
+    .replace(/\s+(Course|Learning Path)$/i, '')
+    .trim()
+}