@magmamath/students-features 0.2.0 → 0.2.1

package/src/features/feedback/model/teacherFeedback.model.ts

@@ -1,7 +1,16 @@
-import { createEffect, createEvent, createStore, Effect, restore, sample, StoreWritable } from 'effector'
+import {
+  createEffect,
+  createEvent,
+  createStore,
+  Effect,
+  restore,
+  sample,
+  StoreWritable,
+} from 'effector'
 import {
   CommentsEntity,
   GetCommentsByIdProps,
+  GetCommentsByIdResponse,
   Locale,
   TeacherComment,
   UpdateCommentSeenStatusProps,
@@ -10,28 +19,32 @@ import { EMPTY_COMMENT_ID, getEmptyComment } from '../constants'
 
 type TeacherFeedbackModelProps = {
   credits: {
+    assignmentId: StoreWritable<string>
     problemId: StoreWritable<string>
     locale: StoreWritable<Locale | null>
   }
   api: {
-    getCommentsByAssignmentId: (props: GetCommentsByIdProps) => Promise<Record<string, { comments: TeacherComment[] }>>
+    getCommentsByAssignmentId: (
+      props: GetCommentsByIdProps,
+    ) => Promise<Record<string, { comments: TeacherComment[] }>>
     updateCommentSeenStatus: (props: UpdateCommentSeenStatusProps) => Promise<void>
   }
 }
 
 export class TeacherFeedbackModel {
+  $assignmentId: StoreWritable<string>
   $currentProblemId: StoreWritable<string>
   $locale: StoreWritable<Locale | null>
 
-  setCommentsSeen = createEvent<{ ids: string[]; currentProblemId: string }>()
-  $comments = createStore<Map<string, CommentsEntity>>(new Map())
+  setCommentsSeen = createEvent<{ ids: string[]; currentProblemId: string; assignmentId: string }>()
+  $comments = createStore<Map<string, Record<string, CommentsEntity>>>(new Map())
 
   setIsOpened = createEvent<boolean>()
   $isOpened = restore(this.setIsOpened, false)
   setIsVisible = createEvent<boolean>()
   $isVisible = restore(this.setIsVisible, false)
 
-  getCommentsByAssignmentIdFx: Effect<GetCommentsByIdProps, Record<string, { comments: TeacherComment[] }>>
+  getCommentsByAssignmentIdFx: Effect<GetCommentsByIdProps, GetCommentsByIdResponse>
   updateCommentSeenFx: Effect<UpdateCommentSeenStatusProps, void>
 
   sockets = {
@@ -40,8 +53,15 @@ export class TeacherFeedbackModel {
   }
 
   constructor({ api, credits }: TeacherFeedbackModelProps) {
-    this.getCommentsByAssignmentIdFx = createEffect(api.getCommentsByAssignmentId)
+    this.getCommentsByAssignmentIdFx = createEffect(async ({ id }: GetCommentsByIdProps) => {
+      const response = await api.getCommentsByAssignmentId({ id })
+      return {
+        data: response,
+        assignmentId: id,
+      }
+    })
     this.updateCommentSeenFx = createEffect(api.updateCommentSeenStatus)
+    this.$assignmentId = credits.assignmentId
     this.$currentProblemId = credits.problemId
     this.$locale = credits.locale
 
@@ -53,10 +73,13 @@ export class TeacherFeedbackModel {
 
     sample({
       clock: this.sockets.onCreate,
-      source: [this.$isOpened, this.$currentProblemId] as const,
-      filter: ([isOpen]) => isOpen,
-      fn: ([_, currentProblemId], { _id }) => ({
+      source: [this.$isOpened, this.$currentProblemId, this.$assignmentId] as const,
+      filter: ([isOpen, currentProblemId], payload) => {
+        return isOpen && currentProblemId === payload.problemId
+      },
+      fn: ([_, currentProblemId, assignmentId], { _id }) => ({
         currentProblemId,
+        assignmentId,
         ids: [_id],
       }),
       target: [this.setCommentsSeen, this.updateCommentSeenFx],
@@ -64,46 +87,54 @@ export class TeacherFeedbackModel {
 
     sample({
       clock: this.$isOpened,
-      source: [this.$comments, this.$currentProblemId] as const,
-      filter: ([feedback, currentProblemId], isOpen) => {
-        const comments = feedback.get(currentProblemId)?.comments ?? []
-        const hasUnreadComments = comments.some((comment) => !comment.isRead)
+      source: [this.$comments, this.$currentProblemId, this.$assignmentId] as const,
+      filter: ([feedback, currentProblemId, assignmentId], isOpen) => {
+        const assignmentComments = feedback.get(assignmentId) || {}
+        const comments = assignmentComments[currentProblemId]?.comments ?? []
+        const hasUnreadComments = comments.some(comment => !comment.isRead)
         return isOpen && hasUnreadComments
       },
-      fn: ([feedback, currentProblemId]) => {
-        const comments = feedback.get(currentProblemId)?.comments ?? []
+      fn: ([feedback, currentProblemId, assignmentId]) => {
+        const assignmentComments = feedback.get(assignmentId) || {}
+        const comments = assignmentComments[currentProblemId]?.comments ?? []
         return {
           currentProblemId,
-          ids: comments.filter((comment) => !comment.isRead).map((comment) => comment._id),
+          assignmentId,
+          ids: comments.filter(comment => !comment.isRead).map(comment => comment._id),
         }
       },
       target: [this.setCommentsSeen, this.updateCommentSeenFx],
     })
 
-    this.$isVisible.on(this.getCommentsByAssignmentIdFx.doneData, (_, payload) => {
-      return Object.values(payload).some((problemFeedback) => problemFeedback.comments?.length > 0)
+    this.$isVisible.on(this.getCommentsByAssignmentIdFx.doneData, (_, { data }) => {
+      return Object.values(data).some(problemFeedback => problemFeedback.comments?.length > 0)
     })
 
     this.$comments
-      .on(this.getCommentsByAssignmentIdFx.doneData, (_, payload) => {
-        const state = new Map()
+      .on(this.getCommentsByAssignmentIdFx.doneData, (state, { assignmentId, data }) => {
+        const problemsMap: Record<string, CommentsEntity> = {}
 
-        for (const [problemId, { comments }] of Object.entries(payload)) {
-          const unreadMessages = comments.filter((comment) => !comment.isRead)
-          state.set(problemId, {
+        for (const [problemId, { comments }] of Object.entries(data)) {
+          const unreadMessages = comments.filter(comment => !comment.isRead)
+          problemsMap[problemId] = {
             comments,
             unreadMessagesCount: unreadMessages.length,
-          })
+          }
         }
 
-        return state
+        const updatedState = new Map(state)
+        updatedState.set(assignmentId, problemsMap)
+        return updatedState
       })
-      .on(this.setCommentsSeen, (state, { ids, currentProblemId }) => {
-        const feedback = state.get(currentProblemId)
+      .on(this.setCommentsSeen, (state, { ids, currentProblemId, assignmentId }) => {
+        const assignmentComments = state.get(assignmentId)
+        if (!assignmentComments) return state
+
+        const feedback = assignmentComments[currentProblemId]
         if (!feedback) return state
 
-        const updatedComments = feedback.comments.map((comment) =>
-          ids.includes(comment._id) ? { ...comment, isRead: true } : comment
+        const updatedComments = feedback.comments.map(comment =>
+          ids.includes(comment._id) ? { ...comment, isRead: true } : comment,
         )
 
         const updatedFeedback = {
@@ -112,13 +143,22 @@ export class TeacherFeedbackModel {
           unreadMessagesCount: 0,
         }
 
+        const updatedAssignmentComments = {
+          ...assignmentComments,
+          [currentProblemId]: updatedFeedback,
+        }
+
         const updatedState = new Map(state)
-        updatedState.set(currentProblemId, updatedFeedback)
+        updatedState.set(assignmentId, updatedAssignmentComments)
 
         return updatedState
       })
       .on(this.sockets.onCreate, (state, payload) => {
-        const feedback = state.get(payload.problemId) ?? { comments: [], unreadMessagesCount: 0 }
+        const assignmentComments = state.get(payload.exerciseId) || {}
+        const feedback = assignmentComments[payload.problemId] ?? {
+          comments: [],
+          unreadMessagesCount: 0,
+        }
 
         const updatedFeedback = {
           ...feedback,
@@ -126,53 +166,91 @@ export class TeacherFeedbackModel {
           unreadMessagesCount: feedback.unreadMessagesCount + 1,
         }
 
+        const updatedAssignmentComments = {
+          ...assignmentComments,
+          [payload.problemId]: updatedFeedback,
+        }
+
         const updatedState = new Map(state)
-        updatedState.set(payload.problemId, updatedFeedback)
+        updatedState.set(payload.exerciseId, updatedAssignmentComments)
 
         return updatedState
       })
       .on(this.sockets.onDeleted, (state, payload) => {
-        const feedback = state.get(payload.problemId)
+        const assignmentId = this.$assignmentId.getState()
+        const assignmentComments = state.get(assignmentId)
+        if (!assignmentComments) return state
+
+        const feedback = assignmentComments[payload.problemId]
         if (!feedback) return state
 
         const isDeleteMessageUnread = feedback.comments.some(
-          (comment) => comment._id === payload._id && !comment.isRead
+          comment => comment._id === payload._id && !comment.isRead,
         )
 
         const updatedFeedback = {
-          comments: feedback.comments.filter((comment) => comment._id !== payload._id),
-          unreadMessagesCount: isDeleteMessageUnread ? feedback.unreadMessagesCount - 1 : feedback.unreadMessagesCount,
+          comments: feedback.comments.filter(comment => comment._id !== payload._id),
+          unreadMessagesCount: isDeleteMessageUnread
+            ? feedback.unreadMessagesCount - 1
+            : feedback.unreadMessagesCount,
         }
 
-        const updatedState = new Map(state)
-        const isOpen = this.$isOpened.getState()
-
         if (updatedFeedback.comments.length === 0) {
+          const updatedAssignmentComments = { ...assignmentComments }
+          const isOpen = this.$isOpened.getState()
+
           if (!isOpen) {
-            updatedState.delete(payload.problemId)
-            return updatedState
+            delete updatedAssignmentComments[payload.problemId]
+
+            if (Object.keys(updatedAssignmentComments).length === 0) {
+              const updatedState = new Map(state)
+              updatedState.delete(assignmentId)
+              return updatedState
+            }
           }
 
-          const feedbackWithCustomMessage = { ...updatedFeedback }
-          feedbackWithCustomMessage.comments = [getEmptyComment(payload.problemId, this.$locale.getState())]
-          updatedState.set(payload.problemId, feedbackWithCustomMessage)
+          updatedAssignmentComments[payload.problemId] = {
+            ...updatedFeedback,
+            comments: [getEmptyComment(payload.problemId, this.$locale.getState())],
+          }
 
+          const updatedState = new Map(state)
+          updatedState.set(assignmentId, updatedAssignmentComments)
           return updatedState
         }
 
-        updatedState.set(payload.problemId, updatedFeedback)
+        const updatedAssignmentComments = {
+          ...assignmentComments,
+          [payload.problemId]: updatedFeedback,
+        }
+
+        const updatedState = new Map(state)
+        updatedState.set(assignmentId, updatedAssignmentComments)
         return updatedState
       })
       .on(this.setIsOpened, (state, isOpen) => {
         if (isOpen) return state
 
+        const assignmentId = this.$assignmentId.getState()
         const problemId = this.$currentProblemId.getState()
-        const feedback = state.get(problemId)
+        const assignmentComments = state.get(assignmentId)
+        if (!assignmentComments) return state
+
+        const feedback = assignmentComments[problemId]
         if (!feedback) return state
 
         if (feedback.comments.length === 1 && feedback.comments[0]._id === EMPTY_COMMENT_ID) {
+          const updatedAssignmentComments = { ...assignmentComments }
+          delete updatedAssignmentComments[problemId]
+
+          if (Object.keys(updatedAssignmentComments).length === 0) {
+            const updatedState = new Map(state)
+            updatedState.delete(assignmentId)
+            return updatedState
+          }
+
           const updatedState = new Map(state)
-          updatedState.delete(problemId)
+          updatedState.set(assignmentId, updatedAssignmentComments)
           return updatedState
         }
 

package/src/features/feedback/types/teacherFeedback.types.ts

@@ -1,4 +1,9 @@
 export type GetCommentsByIdProps = { id: string }
+export type GetCommentsByIdResponse = {
+  data: Record<string, { comments: TeacherComment[] }>
+  assignmentId: string
+}
+
 export type UpdateCommentSeenStatusProps = { ids: string[] }
 
 export type TeacherComment = {