@studious-lms/server 1.2.48 → 1.2.50

package/src/routers/agenda.ts

@@ -37,6 +37,7 @@ export const agendaRouter = createTRPCRouter({
             },
           },
           include: {
+            assignmentsAttached: true,
             class: true,
           },
         }),
@@ -67,6 +68,7 @@ export const agendaRouter = createTRPCRouter({
             },
           },
           include: {
+            assignmentsAttached: true,
             class: true,
           },
         }),

package/src/routers/announcement.ts

@@ -33,6 +33,13 @@ const AnnouncementSelect = {
         select: {
             id: true,
             username: true,
+            profile: {
+                select: {
+                    displayName: true,
+                    profilePicture: true,
+                    profilePictureThumbnail: true,
+                },
+            },
         },
     },
     remarks: true,

package/src/routers/assignment.ts

@@ -1015,6 +1015,7 @@ export const assignmentRouter = createTRPCRouter({
               endTime: true,
               location: true,
               remarks: true,
+              color: true,
             }
           },
           markScheme: {
@@ -1835,6 +1836,7 @@ export const assignmentRouter = createTRPCRouter({
               name: true,
               startTime: true,
               endTime: true,
+              color: true,
             }
           }
         }
@@ -1969,6 +1971,7 @@ export const assignmentRouter = createTRPCRouter({
           endTime: true,
           location: true,
           remarks: true,
+          color: true,
         },
         orderBy: {
           startTime: 'asc'

package/src/routers/worksheet.ts

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { prisma } from "../lib/prisma.js";
 import { GenerationStatus, WorksheetQuestionType } from "@prisma/client";
 import { commentSelect } from "./comment.js";
+import { cancelGradePipeline, regradeWorksheetPipeline } from "../server/pipelines/gradeWorksheet.js";
 
 type MCQOptions = {
   id: string;
@@ -415,22 +416,24 @@ export const worksheetRouter = createTRPCRouter({
 
       return updatedWorksheetResponse;
     }),
-  cancelAutoGrading: protectedProcedure
+  cancelGrading: protectedProcedure
     .input(z.object({
       worksheetResponseId: z.string(),
-      questionId: z.string(),
+      progressId: z.string(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { worksheetResponseId, questionId } = input;
-
-      const updatedQuestion = await prisma.studentQuestionProgress.update({
-        where: { id: questionId, studentWorksheetResponseId: worksheetResponseId },
-        data: {
-          status: GenerationStatus.CANCELLED,
-        },
-      });
+      const { worksheetResponseId, progressId } = input;
 
-      return updatedQuestion;
+      return cancelGradePipeline(worksheetResponseId, progressId);
+    }),
+  regradeQuestion: protectedProcedure
+    .input(z.object({
+      worksheetResponseId: z.string(),
+      progressId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetResponseId, progressId } = input;
+      return regradeWorksheetPipeline(worksheetResponseId, progressId);
     }),
   // Grade a student's answer
   gradeAnswer: protectedProcedure

package/src/server/pipelines/gradeWorksheet.ts

@@ -6,6 +6,139 @@ import { inference } from "../../utils/inference.js";
 import { getAIUserId } from "../../utils/aiUser.js";
 import { pusher } from "../../lib/pusher.js";
 
+
+const removeAllPreviousAIComments = async (worksheetQuestionProgressId: string) => {
+    await prisma.comment.deleteMany({
+        where: {
+            studentQuestionProgressId: worksheetQuestionProgressId,
+            authorId: getAIUserId(),
+        },
+    });
+};
+
+const gradeWorksheetQuestion = async (worksheetResponseId: string) => {
+
+    const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+            worksheet: true,
+        },
+    });
+
+    if (!worksheetResponse) {
+        logger.error('Worksheet response not found');
+        throw new Error('Worksheet response not found');
+    }
+
+
+    const studentQuestionProgress = await prisma.studentQuestionProgress.findFirst({
+        where: {
+            studentWorksheetResponseId: worksheetResponseId,
+            status: {
+                not: {
+                    in: DO_NOT_INFERENCE_STATUSES,
+                },
+            },
+        },
+        include: {
+            question: true,
+            comments: true,
+        },
+    });
+
+    if (!studentQuestionProgress) {
+        logger.error('Student question progress not found');
+        throw new Error('Student question progress not found');
+    }
+
+    pusher.trigger(`class-${worksheetResponse.worksheet.classId}-worksheetSubmission-${worksheetResponse.id}`, `status-pending`, {
+        id: studentQuestionProgress.id,
+    });
+
+    const question = studentQuestionProgress.question;
+    const comments = studentQuestionProgress.comments;
+    const responseText = studentQuestionProgress.response;
+
+
+    try {
+        const apiResponse = await inference(
+            `Grade the following worksheet response:
+            
+            Question: ${question.question}
+            Response: ${responseText}
+
+            Comments: ${comments.map((comment) => comment.content).join('\n')}
+            Mark Scheme: ${JSON.stringify(question.markScheme)}
+            
+            Justify your reasoning by including comment(s) and mark the question please.         
+            Return ONLY JSON in the following format (fill in the values as per the question):
+           {
+            "isCorrect": <boolean>,
+            "points": <number>,
+            "markschemeState": [
+                { "id": <string>, "correct": <boolean> }
+            ],
+            "comments": [<string>, ...]
+            }
+            `,
+            z.object({
+                isCorrect: z.boolean(),
+                points: z.number(),
+                markschemeState: z.array(z.object({
+                    id: z.string(),
+                    correct: z.boolean(),
+                  })), // @note: this has to be converted to [id: string]: correct boolean
+                comments: z.array(z.string()),
+            }),
+        ).catch((error) => {
+            logger.error('Failed to grade worksheet response', { error });
+            throw error;
+        });
+
+        const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
+            where: { id: studentQuestionProgress.id, status: {
+                not: {
+                    in: ['CANCELLED'],
+                },
+            } },
+            data: {
+                status: GenerationStatus.COMPLETED,
+                isCorrect: (apiResponse as { isCorrect: boolean }).isCorrect,
+                points: (apiResponse as { points: number }).points,
+                markschemeState: (apiResponse as {
+                    markschemeState: { id: string; correct: boolean }[];
+                }).markschemeState.reduce((acc, curr) => {
+                    acc["item-" + curr.id] = curr.correct;
+                    return acc;
+                }, {} as Record<string, boolean>),
+                comments: {
+                    create: (apiResponse as {
+                        comments: string[];
+                    }).comments.map((commentContent) => ({
+                        content: commentContent,
+                        authorId: getAIUserId(),
+                    })),
+                },
+            },
+        });
+        pusher.trigger(`class-${worksheetResponse.worksheet.classId}-worksheetSubmission-${worksheetResponse.id}`, `set-completed`, {
+            id: updatedStudentQuestionProgress.id,
+        });
+
+        return updatedStudentQuestionProgress;
+    } catch (error) {
+        logger.error('Failed to grade worksheet response', { error, worksheetResponseId });
+        pusher.trigger(`class-${worksheetResponse.worksheet.classId}-worksheetSubmission-${worksheetResponse.id}`, `set-failed`, {
+            id: studentQuestionProgress.id,
+        });
+        await prisma.studentQuestionProgress.update({
+            where: { id: studentQuestionProgress.id },
+            data: { status: GenerationStatus.FAILED },
+        });
+        throw error;
+    }
+}
+
 /**
  * Grades and regrades worksheet (can fixed failed responses)
  * @param worksheetResponseId worksheet response id
@@ -51,9 +184,6 @@ export const gradeWorksheetPipeline = async (worksheetResponseId: string) => {
     // Use for...of instead of forEach to properly handle async operations
     for (const response of worksheetResponse.responses) {
         logger.info('Grading question', { questionId: response.questionId });
-        const question = response.question;
-        const comments = response.comments;
-        const responseText = response.response;
 
         const studentQuestionProgress = await prisma.studentQuestionProgress.update({
             where: { id: response.id, status: {
@@ -68,84 +198,59 @@ export const gradeWorksheetPipeline = async (worksheetResponseId: string) => {
             return;
         }
 
-        try {
-            const apiResponse = await inference(
-                `Grade the following worksheet response:
-                
-                Question: ${question.question}
-                Response: ${responseText}
-
-                Comments: ${comments.map((comment) => comment.content).join('\n')}
-                Mark Scheme: ${JSON.stringify(question.markScheme)}
-                
-                Justify your reasoning by including comment(s) and mark the question please.         
-                Return ONLY JSON in the following format (fill in the values as per the question):
-               {
-                "isCorrect": <boolean>,
-                "points": <number>,
-                "markschemeState": [
-                    { "id": <string>, "correct": <boolean> }
-                ],
-                "comments": [<string>, ...]
-                }
-                `,
-                z.object({
-                    isCorrect: z.boolean(),
-                    points: z.number(),
-                    markschemeState: z.array(z.object({
-                        id: z.string(),
-                        correct: z.boolean(),
-                      })), // @note: this has to be converted to [id: string]: correct boolean
-                    comments: z.array(z.string()),
-                }),
-            ).catch((error) => {
-                logger.error('Failed to grade worksheet response', { error });
-                throw error;
-            });
-
-            console.log(apiResponse);
-
-            const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
-                where: { id: studentQuestionProgress.id, status: {
-                    not: {
-                        in: ['CANCELLED'],
-                    },
-                } },
-                data: {
-                    status: GenerationStatus.COMPLETED,
-                    isCorrect: (apiResponse as { isCorrect: boolean }).isCorrect,
-                    points: (apiResponse as { points: number }).points,
-                    markschemeState: (apiResponse as {
-                        markschemeState: { id: string; correct: boolean }[];
-                    }).markschemeState.reduce((acc, curr) => {
-                        acc["item-" + curr.id] = curr.correct;
-                        return acc;
-                    }, {} as Record<string, boolean>),
-                    comments: {
-                        create: (apiResponse as {
-                            comments: string[];
-                        }).comments.map((commentContent) => ({
-                            content: commentContent,
-                            authorId: getAIUserId(),
-                        })),
-                    },
-                },
-            });
-            pusher.trigger(`class-${worksheetResponse.worksheet.classId}`, `ai-worksheet-updated-${worksheetResponse.id}`, {
-                success: true,
-            });
-
-            return updatedStudentQuestionProgress;
-        } catch (error) {
-            logger.error('Failed to grade worksheet response', { error, worksheetResponseId });
-            pusher.trigger(`class-${worksheetResponse.worksheet.classId}`, `ai-worksheet-updated-${worksheetResponse.id}`, {
-                success: false,
-            });
-            await prisma.studentQuestionProgress.update({
-                where: { id: studentQuestionProgress.id },
-                data: { status: GenerationStatus.FAILED },
-            });
-            throw error;
-        }
+        gradeWorksheetQuestion(response.id);
+
     };
-};
+};
+
+export const cancelGradePipeline = async (worksheetResponseId: string, worksheetQuestionProgressId: string) => {
+    logger.info('Cancelling auto grading', { worksheetResponseId, worksheetQuestionProgressId });
+
+    const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+            worksheet: true,
+        },
+    });
+    if (!worksheetResponse) {
+        logger.error('Worksheet response not found');
+        throw new Error('Worksheet response not found');
+    }
+    const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
+        where: { id: worksheetQuestionProgressId },
+        data: { status: GenerationStatus.CANCELLED },
+    });
+
+    await removeAllPreviousAIComments(worksheetQuestionProgressId);
+
+    pusher.trigger(`class-${worksheetResponse.worksheet.classId}-worksheetSubmission-${worksheetResponse.id}`, `set-cancelled`, {
+        id: updatedStudentQuestionProgress.id,
+    });
+
+    return updatedStudentQuestionProgress;
+};
+
+export const regradeWorksheetPipeline = async (worksheetResponseId: string, worksheetQuestionProgressId: string) => {
+    logger.info('Regrading worksheet response', { worksheetResponseId, worksheetQuestionProgressId });
+
+    const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId, },
+        include: {
+            worksheet: true,
+        },
+    });
+
+    if (!worksheetResponse) {
+        logger.error('Worksheet response not found');
+        throw new Error('Worksheet response not found');
+    }
+
+    const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
+        where: { id: worksheetQuestionProgressId },
+        data: { status: GenerationStatus.PENDING },
+    });
+
+    gradeWorksheetQuestion(worksheetQuestionProgressId);
+
+    return updatedStudentQuestionProgress;
+};