@magmamath/students-features 0.2.13 → 0.2.15

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

@@ -1,107 +1,105 @@
-import { ChatbotModel } from './model'
-import { restore, createEvent } from 'effector'
+import { restore, createEvent, Store } from 'effector'
 import { AUDIO_CONFIG, DEFAULT_VOICE } from '../constants'
 import { AudioProvider, AudioStatus, PlayTextToSpeechProps } from '../types/t2s.types'
+import { ChatbotAPI } from './api'
 
-export class ChatTextToSpeech {
-    private readonly model: ChatbotModel
-    private readonly audioCache: Record<string, string> = {}
-    private audioProvider: AudioProvider | null = null
+type ChatTextToSpeechModelProps = {
+  $isOpen: Store<boolean>
+  api: ChatbotAPI
+}
 
-    readonly setCurrentPlayingId = createEvent<string | null>()
-    readonly $currentPlayingId = restore(this.setCurrentPlayingId, null)
-    readonly setStatus = createEvent<AudioStatus>()
-    readonly $status = restore(this.setStatus, AudioStatus.STOPPED)
+export class ChatTextToSpeechModel {
+  private readonly api: ChatbotAPI
+  private readonly audioCache: Record<string, string> = {}
+  private audioProvider: AudioProvider | null = null
+
+  readonly setCurrentPlayingId = createEvent<string | null>()
+  readonly $currentPlayingId = restore(this.setCurrentPlayingId, null)
+  readonly setStatus = createEvent<AudioStatus>()
+  readonly $status = restore(this.setStatus, AudioStatus.STOPPED)
+
+  constructor({ $isOpen, api }: ChatTextToSpeechModelProps) {
+    this.api = api
+
+    $isOpen.updates.watch(isOpen => {
+      if (!isOpen) this.reset()
+    })
+  }
+
+  public setAudioProvider(audioProvider: AudioProvider) {
+    this.audioProvider = audioProvider
+  }
+
+  private getCacheKey = (messageId: string, isTranslated: boolean) => {
+    return `${messageId}-${isTranslated ? 'translated' : 'original'}`
+  }
+
+  async play({ text, messageId, isTranslated, config }: PlayTextToSpeechProps) {
+    if (!this.audioProvider) throw new Error('Audio provider is not set. Use setAudioProvider.')
+
+    try {
+      const status = this.$status.getState()
+      const playingId = this.$currentPlayingId.getState()
+      const isPlaying = status === AudioStatus.PLAYING
+      const isPaused = status === AudioStatus.PAUSED
+      const isCurrentMessage = messageId === playingId
+
+      if (isPlaying && isCurrentMessage) {
+        this.audioProvider.pause()
+        this.setStatus(AudioStatus.PAUSED)
+        return
+      }
+
+      if (isPaused && isCurrentMessage) {
+        this.audioProvider.resume()
+        this.setStatus(AudioStatus.PLAYING)
+        return
+      }
+
+      if (messageId && !isCurrentMessage) {
+        this.audioProvider.stop()
+      }
 
-    constructor(chatbotModel: ChatbotModel) {
-        this.model = chatbotModel
+      const cacheKey = this.getCacheKey(messageId, isTranslated)
+      let audioPath = this.audioCache[cacheKey]
+      this.setCurrentPlayingId(messageId)
 
-        this.model.$isOpen.updates.watch((isOpen) => {
-            if (!isOpen) this.reset()
+      if (!audioPath) {
+        const response = await this.api.textToSpeechTextFx({
+          input: { text },
+          voice: config?.voice ?? DEFAULT_VOICE,
+          audioConfig: config?.audioConfig ?? AUDIO_CONFIG,
         })
-    }
 
-    public setAudioProvider(audioProvider: AudioProvider) {
-        this.audioProvider = audioProvider
-    }
-
-    private getCacheKey = (messageId: string, isTranslated: boolean) => {
-        return `${messageId}-${isTranslated ? 'translated' : 'original'}`
-    }
-
-    async play({ text, messageId, isTranslated, config }: PlayTextToSpeechProps) {
-        if (!this.audioProvider) throw new Error('Audio provider is not set. Use setAudioProvider.')
-
-        try {
-            const status = this.$status.getState()
-            const playingId = this.$currentPlayingId.getState()
-            const isPlaying = status === AudioStatus.PLAYING
-            const isPaused = status === AudioStatus.PAUSED
-            const isCurrentMessage = messageId === playingId
-
-            if (isPlaying && isCurrentMessage) {
-                this.audioProvider.pause()
-                this.setStatus(AudioStatus.PAUSED)
-                return
-            }
-
-            if (isPaused && isCurrentMessage) {
-                this.audioProvider.resume()
-                this.setStatus(AudioStatus.PLAYING)
-                return
-            }
-
-            if (messageId && !isCurrentMessage) {
-                this.audioProvider.stop()
-            }
-
-            const cacheKey = this.getCacheKey(messageId, isTranslated)
-            let audioPath = this.audioCache[cacheKey]
-            this.setCurrentPlayingId(messageId)
-
-            if (!audioPath) {
-                const response = await this.model.api.textToSpeechTextFx({
-                    input: { text },
-                    voice: config?.voice ?? DEFAULT_VOICE,
-                    audioConfig: config?.audioConfig ?? AUDIO_CONFIG,
-                })
-
-                // Response might be different type based on provided AUDIO_CONFIG
-                if (typeof response === 'string') {
-                    audioPath = `data:audio/mpeg;base64,${response}`
-                } else {
-                    audioPath = response?.audioContent ?? ''
-                }
-
-                this.audioCache[cacheKey] = audioPath
-            }
-
-            this.setStatus(AudioStatus.PLAYING)
-            await this.audioProvider.play(audioPath, () => {
-                this.setStatus(AudioStatus.STOPPED)
-                this.setCurrentPlayingId(null)
-            })
-        } catch (error) {
-            this.reset()
-            console.error('Error playing text-to-speech: ', error)
+        // Response might be different type based on provided AUDIO_CONFIG
+        if (typeof response === 'string') {
+          audioPath = `data:audio/mpeg;base64,${response}`
+        } else {
+          audioPath = response?.audioContent ?? ''
         }
-    }
-
-    public stop() {
-        if (!this.audioProvider) throw new Error('Audio provider is not set. Use setAudioProvider.')
-        this.audioProvider.stop()
-    }
 
-    // reset should also do stop(), add watcher to model to not write it in repos
-    // chatbotModel.$isOpen.updates.watch((isOpen) => {
-    //     if (!isOpen) {
-    //     chatbotModel.t2s.stop();
-    //     chatbotModel.t2s.reset();
-    // }
+        this.audioCache[cacheKey] = audioPath
+      }
 
-    public reset() {
-        this.stop()
+      this.setStatus(AudioStatus.PLAYING)
+      await this.audioProvider.play(audioPath, () => {
         this.setStatus(AudioStatus.STOPPED)
         this.setCurrentPlayingId(null)
+      })
+    } catch (error) {
+      this.reset()
+      console.error('Error playing text-to-speech: ', error)
     }
+  }
+
+  public stop() {
+    if (!this.audioProvider) throw new Error('Audio provider is not set. Use setAudioProvider.')
+    this.audioProvider.stop()
+  }
+
+  public reset() {
+    this.stop()
+    this.setStatus(AudioStatus.STOPPED)
+    this.setCurrentPlayingId(null)
+  }
 }

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

@@ -4,6 +4,11 @@ export type ChatAnswer = {
   translatedText?: string
 }
 
+export type GetAlternativesPayload = {
+  municipalityId: string
+  assignmentClassGrade: number
+} | void
+
 export type GetAlternativesResponse = {
   chatAccess?: boolean
   options: {

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

@@ -1,27 +1,28 @@
 import type { Store } from 'effector'
 import {
-    GetAlternativesResponse,
-    PostMessagePayload,
-    PostMessageResponse,
-    GoogleTranslatePayload,
-    GoogleTranslateResponse,
-    GoogleText2SpeechPayload,
-    GoogleText2SpeechResponse,
-    ChatAnswer,
+  GetAlternativesResponse,
+  PostMessagePayload,
+  PostMessageResponse,
+  GoogleTranslatePayload,
+  GoogleTranslateResponse,
+  GoogleText2SpeechPayload,
+  GoogleText2SpeechResponse,
+  ChatAnswer,
+  GetAlternativesPayload,
 } from './api.types'
 
 export type ConversationMessage = {
-    id: string
-    message: string
-    threadId: string
-    options: ChatAnswer[]
-    isOwnMessage: boolean
-    translatedMessage?: string
+  id: string
+  message: string
+  threadId: string
+  options: ChatAnswer[]
+  isOwnMessage: boolean
+  translatedMessage?: string
 }
 
 export type EntityIds = {
-    entityId: string
-    fieldId: string
+  entityId: string
+  fieldId: string
 }
 
 export type ChatMessagesModel = EntityIds & { messages: ConversationMessage[] }
@@ -29,45 +30,45 @@ export type ThreadIdsModel = EntityIds & { threadId: string }
 export type AvailableChatsModel = EntityIds & { isAvailable: boolean }
 
 export type ChatbotModelProps = {
-    credits: {
-        $assignmentId: Store<string>
-        $exerciseId: Store<string>
-    },
-    api: {
-        getAlternatives: (props: void) => Promise<GetAlternativesResponse>
-        postMessage: (props: PostMessagePayload) => Promise<PostMessageResponse>
-        postTranslateText: (props: GoogleTranslatePayload) => Promise<GoogleTranslateResponse>
-        postTextToSpeech: (props: GoogleText2SpeechPayload) => Promise<GoogleText2SpeechResponse>
-    }
-    messages: {
-        error: ConversationMessage,
-        start: ConversationMessage
-    }
+  credits: {
+    $assignmentId: Store<string>
+    $exerciseId: Store<string>
+  }
+  api: {
+    getAlternatives: (props: GetAlternativesPayload) => Promise<GetAlternativesResponse>
+    postMessage: (props: PostMessagePayload) => Promise<PostMessageResponse>
+    postTranslateText: (props: GoogleTranslatePayload) => Promise<GoogleTranslateResponse>
+    postTextToSpeech: (props: GoogleText2SpeechPayload) => Promise<GoogleText2SpeechResponse>
+  }
+  messages: {
+    error: ConversationMessage
+    start: ConversationMessage
+  }
 }
 
 export type SendHelpParams = {
-    payload: PostMessagePayload
-    message: string
-    translationTargetLanguage: string
-    translatedMessage?: string
+  payload: PostMessagePayload
+  message: string
+  translationTargetLanguage: string
+  translatedMessage?: string
 }
 
 export type SendHelpProps = SendHelpParams & {
-    assignmentId: string
-    exerciseId: string
-    messages: Record<string, Record<string, { messages: ConversationMessage[] }>>
-    isTranslated: boolean
+  assignmentId: string
+  exerciseId: string
+  messages: Record<string, Record<string, { messages: ConversationMessage[] }>>
+  isTranslated: boolean
 }
 
 export type SetHintMessageProps = EntityIds & ConversationMessage
 
 export enum MessageVariant {
-    SENT = 'sent',
-    RECEIVED = 'received',
+  SENT = 'sent',
+  RECEIVED = 'received',
 }
 
 export type ChatbotRenderer = {
-    message: string
-    variant: MessageVariant
-    withTextToSpeech: boolean
+  message: string
+  variant: MessageVariant
+  withTextToSpeech: boolean
 }

package/src/features/feedback/types.ts

@@ -2,6 +2,7 @@ import { EMPTY_COMMENT_ID } from './constants'
 
 export type GetCommentsPayload = {
   id: string
+  userId: string
 }
 
 export type GetCommentsResponse = {