@studious-lms/server 1.2.27 → 1.2.28

package/dist/routers/worksheet.js

@@ -0,0 +1,365 @@
+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(),
+        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, 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,
+                markScheme,
+            },
+        });
+        return newQuestion;
+    }),
+    updateQuestion: protectedProcedure
+        .input(z.object({
+        worksheetId: z.string(),
+        questionId: z.string(),
+        question: z.string().optional(),
+        answer: z.string().optional(),
+        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, 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;
+    }),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.2.27",
+  "version": "1.2.28",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/schema.prisma

@@ -42,6 +42,15 @@ enum UploadStatus {
   CANCELLED
 }
 
+enum WorksheetQuestionType {
+  MULTIPLE_CHOICE
+  TRUE_FALSE
+  SHORT_ANSWER
+  LONG_ANSWER
+  MATH_EXPRESSION
+  ESSAY
+}
+
 enum ReactionType {
   THUMBSUP
   CELEBRATE
@@ -85,6 +94,8 @@ model User {
   announcements Announcement[]
   notificationsSent Notification[] @relation("SentNotifications")
   notificationsReceived Notification[] @relation("ReceivedNotifications")
+  studentQuestionProgress StudentQuestionProgress[]
+  studentWorksheetResponses StudentWorksheetResponse[]
 
   presentAttendance  Attendance[] @relation("PresentAttendance")
   lateAttendance    Attendance[] @relation("LateAttendance")
@@ -132,6 +143,7 @@ model Class {
   events        Event[]
   sections      Section[]
   sessions      Session[]
+  worksheets Worksheet[]
   students      User[]         @relation("UserStudentToClass")
   teachers      User[]         @relation("UserTeacherToClass")
   markSchemes   MarkScheme[] @relation("ClassToMarkScheme")
@@ -255,6 +267,8 @@ model Assignment {
   order         Int?
   gradingBoundary GradingBoundary? @relation(fields: [gradingBoundaryId], references: [id], onDelete: Cascade)
   gradingBoundaryId String?
+  worksheet Worksheet? @relation(fields: [worksheetId], references: [id], onDelete: Cascade)
+  worksheetId String?
 }
 
 
@@ -318,7 +332,8 @@ model Submission {
 
   attachments File[]  @relation("SubmissionFile")
   annotations File[]  @relation("SubmissionAnnotations")
-
+  worksheetResponses StudentWorksheetResponse[]
+  
   gradeReceived Int?
 
   rubricState String?
@@ -471,6 +486,60 @@ model Mention {
   @@unique([messageId, userId])
 }
 
+model Worksheet {
+  id String @id @default(uuid())
+  name String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  classId String
+  class Class? @relation(fields: [classId], references: [id], onDelete: Cascade)
+  assignments Assignment[]
+  questions WorksheetQuestion[]
+  studentWorksheetResponses StudentWorksheetResponse[]
+}
+
+model WorksheetQuestion {
+  id String @id @default(uuid())
+  worksheetId String
+  worksheet Worksheet @relation(fields: [worksheetId], references: [id], onDelete: Cascade)
+  type WorksheetQuestionType
+  question String
+  answer String
+  markScheme Json?  @default("{}")
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  studentResponses StudentQuestionProgress[]
+}
+
+model StudentWorksheetResponse {
+  id String @id @default(uuid())
+  studentId String
+  student User @relation(fields: [studentId], references: [id], onDelete: Cascade)
+  worksheetId String
+  worksheet Worksheet @relation(fields: [worksheetId], references: [id], onDelete: Cascade)
+  responses StudentQuestionProgress[]
+  submission Submission? @relation(fields: [submissionId], references: [id], onDelete: Cascade)
+  submissionId String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  submittedAt DateTime?
+  submitted Boolean @default(false)
+}
+
+model StudentQuestionProgress {
+  id String @id @default(uuid())
+  studentId String
+  student User @relation(fields: [studentId], references: [id], onDelete: Cascade)
+  questionId String
+  question WorksheetQuestion @relation(fields: [questionId], references: [id], onDelete: Cascade)
+  response String
+  isCorrect Boolean @default(false)
+  feedback String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  studentWorksheetResponseId String?
+  studentWorksheetResponse StudentWorksheetResponse? @relation(fields: [studentWorksheetResponseId], references: [id], onDelete: Cascade)
+}
 
 model SchoolDevelopementProgram {
   id String @id

package/src/routers/_app.ts

@@ -17,6 +17,7 @@ import { conversationRouter } from "./conversation.js";
 import { messageRouter } from "./message.js";
 import { labChatRouter } from "./labChat.js";
 import { marketingRouter } from "./marketing.js";
+import { worksheetRouter } from "./worksheet.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -35,6 +36,7 @@ export const appRouter = createTRPCRouter({
   message: messageRouter,
   labChat: labChatRouter,
   marketing: marketingRouter,
+  worksheet: worksheetRouter,
 }); 
 
 // Export type router type definition

package/src/routers/auth.ts

@@ -142,7 +142,7 @@ export const authRouter = createTRPCRouter({
       if (!user) {
         throw new TRPCError({
           code: "UNAUTHORIZED",
-          message: "user doesn't exists.",
+          message: "Invalid username or password",
         });
       }
 

package/src/routers/class.ts

@@ -195,6 +195,9 @@ export const classRouter = createTRPCRouter({
                   studentId: true,
                   id: true,
                   submitted: true,
+                  gradeReceived: true,
+                  rubricState: true,
+                  teacherComments: true,
                   returned: true,
                   submittedAt: true,
                 },