@studious-lms/server 1.2.27 → 1.2.29

package/src/routers/worksheet.ts

@@ -0,0 +1,422 @@
+import { TRPCError } from "@trpc/server";
+import { createTRPCRouter, protectedProcedure } from "src/trpc";
+import { z } from "zod";
+import { prisma } from "src/lib/prisma";
+
+export const worksheetRouter = createTRPCRouter({
+  // Get a single worksheet with all questions
+  getWorksheet: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const { worksheetId } = input;
+
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: worksheetId },
+        include: {
+          questions: {
+            orderBy: { createdAt: 'asc' },
+          },
+          class: true,
+        },
+      });
+
+      if (!worksheet) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet not found' });
+      }
+
+      return worksheet;
+    }),
+
+  // List all worksheets for a class
+  listWorksheets: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const { classId } = input;
+
+      const worksheets = await prisma.worksheet.findMany({
+        where: { classId },
+        include: {
+          questions: {
+            select: { id: true },
+          },
+        },
+        orderBy: { createdAt: 'desc' },
+      });
+
+      return worksheets.map(worksheet => ({
+        ...worksheet,
+        questionCount: worksheet.questions.length,
+      }));
+    }),
+
+  // Update worksheet metadata
+  updateWorksheet: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      name: z.string().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId, name } = input;
+
+      const worksheet = await prisma.worksheet.update({
+        where: { id: worksheetId },
+        data: {
+          ...(name !== undefined && { name }),
+        },
+      });
+
+      return worksheet;
+    }),
+
+  // Delete a worksheet
+  deleteWorksheet: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId } = input;
+
+      // This will cascade delete all questions and responses
+      const deletedWorksheet = await prisma.worksheet.delete({
+        where: { id: worksheetId },
+      });
+
+      return deletedWorksheet;
+    }),
+
+  create: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+      name: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { classId, name } = input;
+
+      // Create the worksheet
+      const worksheet = await prisma.worksheet.create({
+        data: {
+          name,
+          classId,
+        },
+      });
+
+      return worksheet;
+    }),
+  addQuestion: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      question: z.string(),
+      answer: z.string(),
+      options: z.any().optional(), // JSON field
+      markScheme: z.any().optional(), // JSON field
+      type: z.enum(['MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY']),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId, question, answer, options, markScheme, type } = input;
+
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: worksheetId },
+      });
+
+      if (!worksheet) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet not found' });
+      }
+
+      const newQuestion = await prisma.worksheetQuestion.create({
+        data: {
+          worksheetId,
+          type,
+          question,
+          answer,
+          options,
+          markScheme,
+        },
+      });
+
+      return newQuestion;
+    }),
+  updateQuestion: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      questionId: z.string(),
+      question: z.string().optional(),
+      answer: z.string().optional(),
+      options: z.any().optional(), // JSON field
+      markScheme: z.any().optional(), // JSON field
+      type: z.enum(['MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY']).optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId, questionId, question, answer, options, markScheme, type } = input;
+
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: worksheetId },
+      });
+
+      if (!worksheet) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet not found' });
+      }
+
+      const updatedQuestion = await prisma.worksheetQuestion.update({
+        where: { id: questionId },
+        data: {
+          ...(question !== undefined && { question }),
+          ...(answer !== undefined && { answer }),
+          ...(markScheme !== undefined && { markScheme }),
+          ...(type !== undefined && { type }),
+        },
+      });
+
+      return updatedQuestion;
+    }),
+  deleteQuestion: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      questionId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId, questionId } = input;
+
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: worksheetId },
+      });
+
+      if (!worksheet) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet not found' });
+      }
+
+      const deletedQuestion = await prisma.worksheetQuestion.delete({
+        where: { id: questionId },
+      });
+
+      return deletedQuestion;
+    }),
+
+  getWorksheetSubmission: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      submissionId: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const { worksheetId, submissionId } = input;
+
+      const submission = await prisma.submission.findUnique({
+        where: { id: submissionId },
+      });
+
+      if (!submission) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Submission not found' });
+      }
+
+      const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
+        where: { submissionId },
+        include: {
+          responses: true,
+        },
+      });
+
+      return worksheetResponses;
+    }),
+  answerQuestion: protectedProcedure
+    .input(z.object({
+      worksheetResponseId: z.string(),
+      questionId: z.string(),
+      response: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetResponseId, questionId, response } = input;
+
+      const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+          responses: {
+            where: { questionId },
+          },
+        },
+      });
+
+      if (!worksheetResponse) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet response not found' });
+      }
+
+      // Check if a response already exists for this question
+      const existingResponse = worksheetResponse.responses[0];
+
+      if (existingResponse) {
+        // Update existing response
+        await prisma.studentQuestionProgress.update({
+          where: { id: existingResponse.id },
+          data: { response },
+        });
+      } else {
+        // Create new response
+        await prisma.studentQuestionProgress.create({
+          data: {
+            studentId: worksheetResponse.studentId,
+            questionId,
+            response,
+            studentWorksheetResponseId: worksheetResponseId,
+          },
+        });
+      }
+
+      // Return the updated worksheet response with all responses
+      const updatedWorksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+          responses: true,
+        },
+      });
+
+      return updatedWorksheetResponse;
+    }),
+    submitWorksheet: protectedProcedure
+    .input(z.object({
+      worksheetResponseId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetResponseId } = input;
+
+      const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+          worksheet: {
+            include: {
+              questions: true,
+            },
+          },
+          responses: true,
+        },
+      });
+
+      if (!worksheetResponse) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet response not found' });
+      }
+
+      if (worksheetResponse.submitted) {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Worksheet already submitted' });
+      }
+
+      // Mark worksheet as submitted
+      const submittedWorksheet = await prisma.studentWorksheetResponse.update({
+        where: { id: worksheetResponseId },
+        data: {
+          submitted: true,
+          submittedAt: new Date(),
+        },
+        include: {
+          responses: true,
+        },
+      });
+
+      // TODO: Implement AI grading here
+      // For now, we'll just mark all answers as pending review
+      // You could integrate with an AI service to auto-grade certain question types
+      
+      return submittedWorksheet;
+    }),
+
+  // Get or create a student's worksheet response
+  getOrCreateWorksheetResponse: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      studentId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId, studentId } = input;
+
+      // Try to find existing response
+      let worksheetResponse = await prisma.studentWorksheetResponse.findFirst({
+        where: {
+          worksheetId,
+          studentId,
+          submitted: false, // Only get unsubmitted responses
+        },
+        include: {
+          responses: {
+            include: {
+              question: true,
+            },
+          },
+        },
+      });
+
+      // Create new response if none exists
+      if (!worksheetResponse) {
+        worksheetResponse = await prisma.studentWorksheetResponse.create({
+          data: {
+            worksheetId,
+            studentId,
+          },
+          include: {
+            responses: {
+              include: {
+                question: true,
+              },
+            },
+          },
+        });
+      }
+
+      return worksheetResponse;
+    }),
+
+  // Get all student responses for a worksheet (teacher view)
+  getWorksheetResponses: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const { worksheetId } = input;
+
+      const responses = await prisma.studentWorksheetResponse.findMany({
+        where: { worksheetId },
+        include: {
+          student: {
+            select: {
+              id: true,
+              username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                },
+              },
+            },
+          },
+          responses: {
+            include: {
+              question: true,
+            },
+          },
+        },
+        orderBy: { submittedAt: 'desc' },
+      });
+
+      return responses;
+    }),
+
+  // Grade a student's answer
+  gradeAnswer: protectedProcedure
+    .input(z.object({
+      responseId: z.string(), // StudentQuestionProgress ID
+      isCorrect: z.boolean(),
+      feedback: z.string().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { responseId, isCorrect, feedback } = input;
+
+      const gradedResponse = await prisma.studentQuestionProgress.update({
+        where: { id: responseId },
+        data: {
+          isCorrect,
+          ...(feedback !== undefined && { feedback }),
+        },
+      });
+
+      return gradedResponse;
+    }),
+});