@magmamath/students-features 1.5.1 → 1.5.3-rc.1

package/src/features/chatbot/model/VoiceTranscriptSnapshotModel.ts

@@ -0,0 +1,128 @@
+import { createEffect, sample } from 'effector'
+import {
+  AudioTranscriptResponse,
+  TranscriptionStatus,
+  VoiceRecordCollectionItem,
+} from '../../voice/types'
+import { VoiceRecordModel } from '../../voice/recording/model/VoiceRecord.model'
+import { RequestOptionalConfig } from '../../../lib/effector/createControllerEffect'
+
+const TRANSCRIPT_RETRY_INTERVAL_MS = 3000
+const TRANSCRIPT_MAX_RETRIES = 20
+
+type GetTranscriptApi = {
+  getAudioFileTranscript: (audioFileId: string) => Promise<AudioTranscriptResponse>
+}
+
+type CaptureParams = {
+  voiceKey: string
+  record: VoiceRecordCollectionItem
+}
+
+type VoiceTranscriptSnapshotModelProps = {
+  voiceRecord: VoiceRecordModel
+  api: GetTranscriptApi
+}
+
+// Voice key: `${assignmentId}-${problemId}-${attemptsCount}`
+// Chat key:  `${assignmentId}-${problemId}` — survives attempt increments and voice deletion.
+const toChatKey = (voiceKey: string): string | null => {
+  const lastDashIndex = voiceKey.lastIndexOf('-')
+  if (lastDashIndex <= 0) return null
+  return voiceKey.slice(0, lastDashIndex)
+}
+
+export class VoiceTranscriptSnapshotModel {
+  public readonly fetchTranscript = (audioFileId: string): Promise<string | undefined> => {
+    const cached = this.transcriptByAudioFileId.get(audioFileId)
+    if (cached) return cached
+
+    const promise = this.pollTranscript(audioFileId).catch(() => undefined)
+    this.transcriptByAudioFileId.set(audioFileId, promise)
+    return promise
+  }
+
+  public readonly getTranscriptForCurrent = async (): Promise<string | undefined> => {
+    const voiceKey = this.voiceRecord.$currentKey.getState()
+    if (!voiceKey) return undefined
+
+    const chatKey = toChatKey(voiceKey)
+    if (chatKey) {
+      const snapshot = this.snapshotByChatKey.get(chatKey)
+      if (snapshot) return snapshot
+    }
+
+    const record = this.voiceRecord.collection.get(voiceKey)
+    if (!record) return undefined
+
+    const audioFileId = await this.resolveAudioFileId(record)
+    if (!audioFileId) return undefined
+
+    return this.fetchTranscript(audioFileId)
+  }
+
+  public readonly wrapRequestHint = <P extends object, R>(
+    apiFn: (
+      params: P & { voiceTranscript?: string },
+      requestConfig?: RequestOptionalConfig,
+    ) => Promise<R>,
+  ) => {
+    return async (params: P, requestConfig?: RequestOptionalConfig): Promise<R> => {
+      const voiceTranscript = await this.getTranscriptForCurrent()
+      return apiFn(voiceTranscript ? { ...params, voiceTranscript } : params, requestConfig)
+    }
+  }
+
+  constructor({ voiceRecord, api }: VoiceTranscriptSnapshotModelProps) {
+    this.voiceRecord = voiceRecord
+    this.api = api
+
+    sample({
+      clock: voiceRecord.setCurrentRecord,
+      source: voiceRecord.$currentKey,
+      filter: (_, record): record is VoiceRecordCollectionItem => !!record,
+      fn: (voiceKey, record) => ({ voiceKey, record }),
+      target: this.captureSnapshotFx,
+    })
+  }
+
+  private readonly voiceRecord: VoiceRecordModel
+  private readonly api: GetTranscriptApi
+  private readonly transcriptByAudioFileId = new Map<string, Promise<string | undefined>>()
+  private readonly snapshotByChatKey = new Map<string, Promise<string | undefined>>()
+
+  private readonly captureSnapshotFx = createEffect(async ({ voiceKey, record }: CaptureParams) => {
+    const chatKey = toChatKey(voiceKey)
+    if (!chatKey) return
+
+    const audioFileId = await this.resolveAudioFileId(record)
+    if (!audioFileId) return
+
+    this.snapshotByChatKey.set(chatKey, this.fetchTranscript(audioFileId))
+  })
+
+  private async pollTranscript(audioFileId: string): Promise<string | undefined> {
+    for (let attempt = 0; attempt < TRANSCRIPT_MAX_RETRIES; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, TRANSCRIPT_RETRY_INTERVAL_MS))
+
+      const response = await this.api.getAudioFileTranscript(audioFileId)
+
+      if (response.status === TranscriptionStatus.COMPLETED) return response.text
+      if (response.status === TranscriptionStatus.FAILED) return undefined
+    }
+    return undefined
+  }
+
+  private async resolveAudioFileId(
+    record: VoiceRecordCollectionItem,
+  ): Promise<string | undefined> {
+    if (record.id) return record.id
+    if (!record.audioUploadPromise) return undefined
+    try {
+      const result = await record.audioUploadPromise
+      return result?.id
+    } catch {
+      return undefined
+    }
+  }
+}

package/src/features/chatbot/types/api.types.ts

@@ -130,6 +130,7 @@ export type ChatHintPayload = {
   studentInput: string
   answerOptions?: string[]
   assignmentGrade?: number
+  voiceTranscript?: string
 }
 
 export type ChatHintResponse = {

package/src/features/pmProgress/model/PmProgressModel.ts

@@ -43,7 +43,10 @@ export class PmProgressModel {
 
     sample({
       clock: this.tree.initTreeFx.done,
-      fn: ({ result: [tree] }) => tree,
+      fn: ({ params: { user }, result: [tree] }) => ({
+        tree,
+        lockedGrades: user.setting.practiceModeLockedGrades,
+      }),
       target: this.recommendations.initRecommendationsFx,
     })
   }

package/src/features/pmProgress/model/PmRecommendationsModel.ts

@@ -2,6 +2,12 @@ import { PmProgressApi } from './PmProgressApi'
 import { createEffect, createEvent, createStore, sample } from 'effector'
 import { Recommendations, RecsResponse, TreeMappingResponse } from '../shared/pmProgress.types'
 import { RECOMMENDATIONS_LIMIT_PARAM, SolvingFlow } from '../shared/pmProgress.constants'
+import { filterLockedGradeRecs } from '../shared/pmProgress.helpers'
+
+type FetchMagmaRecsParams = {
+  tree: TreeMappingResponse
+  lockedGrades: number[]
+}
 
 const EMPTY_RECS: Recommendations = { items: [], offset: 0, limit: 0, total: 0 }
 
@@ -22,14 +28,24 @@ export class PmRecommendationsModel {
     ),
   )
 
-  public readonly fetchMagmaRecsFx = createEffect((tree: TreeMappingResponse) =>
-    this.fetchRecs(tree, SolvingFlow.MAGMA, () =>
-      this.api.getMagmaRecsFx({ limit: RECOMMENDATIONS_LIMIT_PARAM }),
-    ),
+  public readonly fetchMagmaRecsFx = createEffect(
+    async ({ tree, lockedGrades }: FetchMagmaRecsParams) => {
+      const recs = await this.fetchRecs(tree, SolvingFlow.MAGMA, () =>
+        this.api.getMagmaRecsFx({ limit: RECOMMENDATIONS_LIMIT_PARAM }),
+      )
+      return {
+        ...recs,
+        items: filterLockedGradeRecs(recs.items, tree.treeMapping, lockedGrades),
+      }
+    },
   )
 
-  public readonly initRecommendationsFx = createEffect((tree: TreeMappingResponse) =>
-    Promise.all([this.fetchTeacherRecsFx(tree), this.fetchMagmaRecsFx(tree)]),
+  public readonly initRecommendationsFx = createEffect(
+    ({ tree, lockedGrades }: FetchMagmaRecsParams) =>
+      Promise.all([
+        this.fetchTeacherRecsFx(tree),
+        this.fetchMagmaRecsFx({ tree, lockedGrades }),
+      ]),
   )
 
   private fetchRecs = async (

package/src/features/pmProgress/shared/pmProgress.helpers.ts

@@ -298,6 +298,39 @@ export const formatGradeLabel = (grade: number, customLabelsMap?: GradeLabelsMap
   return `${getText('pmProgress.grade')} ${label.name}`
 }
 
+const buildSkillGradeMap = (
+  treeMapping: TreeMappingResponse['treeMapping'],
+): Map<string, number> => {
+  const map = new Map<string, number>()
+
+  const collectSkills = (nodeId: string, gradeValue: number) => {
+    const node = treeMapping[nodeId]
+    if (!node) return
+    node.skills.forEach((skillId) => map.set(skillId, gradeValue))
+    node.children.forEach((childId) => collectSkills(childId, gradeValue))
+  }
+
+  Object.values(treeMapping)
+    .filter((node) => node.type === 'grade')
+    .forEach((gradeNode) => collectSkills(gradeNode._id, gradeNode.attributes.grade))
+
+  return map
+}
+
+export const filterLockedGradeRecs = (
+  skills: Skill[],
+  treeMapping: TreeMappingResponse['treeMapping'],
+  lockedGrades: number[],
+): Skill[] => {
+  if (lockedGrades.length === 0) return skills
+  const locked = new Set(lockedGrades)
+  const skillGradeMap = buildSkillGradeMap(treeMapping)
+  return skills.filter((skill) => {
+    const grade = skillGradeMap.get(skill._id)
+    return grade === undefined || !locked.has(grade)
+  })
+}
+
 export const getTreeGrades = (tree: TreeMappingResponse, user: User): Grade[] => {
   const lockedGrades = new Set(user.setting.practiceModeLockedGrades)