@studious-lms/server 1.0.4 → 1.0.7

package/dist/routers/class.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classRouter = void 0;
-const zod_1 = require("zod");
-const trpc_1 = require("../trpc");
-const prisma_1 = require("../lib/prisma");
-const server_1 = require("@trpc/server");
-const generateInviteCode_1 = require("../utils/generateInviteCode");
-exports.classRouter = (0, trpc_1.createTRPCRouter)({
-    getAll: trpc_1.protectedProcedure
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure, protectedClassMemberProcedure } from "../trpc";
+import { prisma } from "../lib/prisma";
+import { TRPCError } from "@trpc/server";
+import { generateInviteCode } from "../utils/generateInviteCode";
+export const classRouter = createTRPCRouter({
+    getAll: protectedProcedure
         .query(async ({ ctx }) => {
         const [teacherClasses, studentClasses] = await Promise.all([
-            prisma_1.prisma.class.findMany({
+            prisma.class.findMany({
                 where: {
                     teachers: {
                         some: {
@@ -22,17 +19,19 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
                     assignments: {
                         where: {
                             dueDate: {
-                                equals: new Date(new Date().setHours(0, 0, 0, 0)),
+                                lte: new Date(new Date().setHours(23, 59, 59, 999)),
                             },
+                            template: false,
                         },
                         select: {
                             id: true,
                             title: true,
+                            type: true,
                         },
                     },
                 },
             }),
-            prisma_1.prisma.class.findMany({
+            prisma.class.findMany({
                 where: {
                     students: {
                         some: {
@@ -44,39 +43,19 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
                     assignments: {
                         where: {
                             dueDate: {
-                                equals: new Date(new Date().setHours(0, 0, 0, 0)),
+                                lte: new Date(new Date().setHours(23, 59, 59, 999)),
                             },
+                            template: false,
                         },
                         select: {
                             id: true,
                             title: true,
+                            type: true,
                         },
                     },
                 },
             }),
         ]);
-        const adminClasses = await prisma_1.prisma.class.findMany({
-            where: {
-                teachers: {
-                    some: {
-                        id: ctx.user?.id,
-                    },
-                },
-            },
-            include: {
-                assignments: {
-                    where: {
-                        dueDate: {
-                            equals: new Date(new Date().setHours(0, 0, 0, 0)),
-                        },
-                    },
-                    select: {
-                        id: true,
-                        title: true,
-                    },
-                },
-            },
-        });
         return {
             teacherInClass: teacherClasses.map(cls => ({
                 id: cls.id,
@@ -84,6 +63,7 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
                 section: cls.section,
                 subject: cls.subject,
                 dueToday: cls.assignments,
+                assignments: cls.assignments,
                 color: cls.color,
             })),
             studentInClass: studentClasses.map(cls => ({
@@ -92,25 +72,18 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
                 section: cls.section,
                 subject: cls.subject,
                 dueToday: cls.assignments,
-                color: cls.color,
-            })),
-            adminInClass: adminClasses.map(cls => ({
-                id: cls.id,
-                name: cls.name,
-                section: cls.section,
-                subject: cls.subject,
-                dueToday: cls.assignments,
+                assignments: cls.assignments,
                 color: cls.color,
             })),
         };
     }),
-    get: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
+    get: protectedProcedure
+        .input(z.object({
+        classId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const { classId } = input;
-        const classData = await prisma_1.prisma.class.findUnique({
+        const classData = await prisma.class.findUnique({
             where: {
                 id: classId,
             },
@@ -154,6 +127,8 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
                         graded: true,
                         maxGrade: true,
                         instructions: true,
+                        inProgress: true,
+                        template: false,
                         section: {
                             select: {
                                 id: true,
@@ -188,7 +163,7 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
                 },
             },
         });
-        const sections = await prisma_1.prisma.section.findMany({
+        const sections = await prisma.section.findMany({
             where: {
                 classId: classId,
             },
@@ -209,16 +184,16 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             },
         };
     }),
-    update: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        name: zod_1.z.string().optional(),
-        section: zod_1.z.string().optional(),
-        subject: zod_1.z.string().optional(),
+    update: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        name: z.string().optional(),
+        section: z.string().optional(),
+        subject: z.string().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, ...updateData } = input;
-        const updatedClass = await prisma_1.prisma.class.update({
+        const updatedClass = await prisma.class.update({
             where: {
                 id: classId,
             },
@@ -234,22 +209,24 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             updatedClass,
         };
     }),
-    create: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        students: zod_1.z.array(zod_1.z.string()).optional(),
-        teachers: zod_1.z.array(zod_1.z.string()).optional(),
-        name: zod_1.z.string(),
-        section: zod_1.z.string(),
-        subject: zod_1.z.string(),
+    create: protectedProcedure
+        .input(z.object({
+        students: z.array(z.string()).optional(),
+        teachers: z.array(z.string()).optional(),
+        name: z.string(),
+        section: z.string(),
+        subject: z.string(),
+        color: z.string().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { students, teachers, name, section, subject } = input;
+        const { students, teachers, name, section, subject, color } = input;
         if (teachers && teachers.length > 0 && students && students.length > 0) {
-            const newClass = await prisma_1.prisma.class.create({
+            const newClass = await prisma.class.create({
                 data: {
                     name,
                     section,
                     subject,
+                    color,
                     teachers: {
                         connect: teachers.map(teacher => ({ id: teacher })),
                     },
@@ -264,11 +241,12 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             });
             return newClass;
         }
-        const newClass = await prisma_1.prisma.class.create({
+        const newClass = await prisma.class.create({
             data: {
                 name,
                 section,
                 subject,
+                color,
                 teachers: {
                     connect: {
                         id: ctx.user?.id,
@@ -278,14 +256,14 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         });
         return newClass;
     }),
-    delete: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        id: zod_1.z.string(),
+    delete: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        id: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         // Verify user is the teacher of this class
-        const classToDelete = await prisma_1.prisma.class.findFirst({
+        const classToDelete = await prisma.class.findFirst({
             where: {
                 id: input.id,
             },
@@ -293,7 +271,7 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         if (!classToDelete) {
             throw new Error("Class not found or you don't have permission to delete it");
         }
-        await prisma_1.prisma.class.delete({
+        await prisma.class.delete({
             where: {
                 id: input.id,
             },
@@ -304,14 +282,14 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             }
         };
     }),
-    addStudent: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        studentId: zod_1.z.string(),
+    addStudent: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        studentId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, studentId } = input;
-        const student = await prisma_1.prisma.user.findUnique({
+        const student = await prisma.user.findUnique({
             where: {
                 id: studentId,
             },
@@ -319,7 +297,7 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         if (!student) {
             throw new Error("Student not found");
         }
-        const updatedClass = await prisma_1.prisma.class.update({
+        const updatedClass = await prisma.class.update({
             where: {
                 id: classId,
             },
@@ -342,15 +320,15 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             newStudent: student,
         };
     }),
-    changeRole: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        userId: zod_1.z.string(),
-        type: zod_1.z.enum(['teacher', 'student']),
+    changeRole: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        userId: z.string(),
+        type: z.enum(['teacher', 'student']),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, userId, type } = input;
-        const user = await prisma_1.prisma.user.findUnique({
+        const user = await prisma.user.findUnique({
             where: { id: userId },
             select: {
                 id: true,
@@ -360,7 +338,7 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         if (!user) {
             throw new Error("User not found");
         }
-        const updatedClass = await prisma_1.prisma.class.update({
+        const updatedClass = await prisma.class.update({
             where: { id: classId },
             data: {
                 [type === 'teacher' ? 'teachers' : 'students']: {
@@ -379,14 +357,14 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             },
         };
     }),
-    removeMember: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        userId: zod_1.z.string(),
+    removeMember: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        userId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, userId } = input;
-        const updatedClass = await prisma_1.prisma.class.update({
+        const updatedClass = await prisma.class.update({
             where: { id: classId },
             data: {
                 teachers: {
@@ -402,13 +380,13 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             removedUserId: userId,
         };
     }),
-    join: trpc_1.protectedProcedure
-        .input(zod_1.z.object({
-        classCode: zod_1.z.string(),
+    join: protectedProcedure
+        .input(z.object({
+        classCode: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classCode } = input;
-        const session = await prisma_1.prisma.session.findFirst({
+        const session = await prisma.session.findFirst({
             where: {
                 id: classCode,
             },
@@ -419,7 +397,7 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         if (session.expiresAt && session.expiresAt < new Date()) {
             throw new Error("Session expired");
         }
-        const updatedClass = await prisma_1.prisma.class.update({
+        const updatedClass = await prisma.class.update({
             where: { id: session.classId },
             data: {
                 students: {
@@ -437,21 +415,21 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             joinedClass: updatedClass,
         };
     }),
-    getInviteCode: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
+    getInviteCode: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const { classId } = input;
-        const session = await prisma_1.prisma.session.findFirst({
+        const session = await prisma.session.findFirst({
             where: {
                 classId,
             },
         });
         if ((session?.expiresAt && session.expiresAt < new Date()) || !session) {
-            const newSession = await prisma_1.prisma.session.create({
+            const newSession = await prisma.session.create({
                 data: {
-                    id: (0, generateInviteCode_1.generateInviteCode)(),
+                    id: generateInviteCode(),
                     classId,
                     expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
                 }
@@ -464,16 +442,16 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             code: session?.id,
         };
     }),
-    createInviteCode: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
+    createInviteCode: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId } = input;
         // Create a new session for the invite code
-        const session = await prisma_1.prisma.session.create({
+        const session = await prisma.session.create({
             data: {
-                id: (0, generateInviteCode_1.generateInviteCode)(),
+                id: generateInviteCode(),
                 classId,
                 expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
             }
@@ -482,14 +460,14 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             code: session.id,
         };
     }),
-    getGrades: trpc_1.protectedClassMemberProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        userId: zod_1.z.string(),
+    getGrades: protectedClassMemberProcedure
+        .input(z.object({
+        classId: z.string(),
+        userId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const { classId, userId } = input;
-        const isTeacher = await prisma_1.prisma.class.findFirst({
+        const isTeacher = await prisma.class.findFirst({
             where: {
                 id: classId,
                 teachers: {
@@ -499,12 +477,12 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         });
         // If student, only allow viewing their own grades
         if (ctx.user?.id !== userId && !isTeacher) {
-            throw new server_1.TRPCError({
+            throw new TRPCError({
                 code: 'UNAUTHORIZED',
                 message: 'You can only view your own grades',
             });
         }
-        const grades = await prisma_1.prisma.submission.findMany({
+        const grades = await prisma.submission.findMany({
             where: {
                 studentId: userId,
                 assignment: {
@@ -527,17 +505,17 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
             grades,
         };
     }),
-    updateGrade: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        assignmentId: zod_1.z.string(),
-        submissionId: zod_1.z.string(),
-        gradeReceived: zod_1.z.number().nullable(),
+    updateGrade: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        assignmentId: z.string(),
+        submissionId: z.string(),
+        gradeReceived: z.number().nullable(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, assignmentId, submissionId, gradeReceived } = input;
         // Update the grade
-        const updatedSubmission = await prisma_1.prisma.submission.update({
+        const updatedSubmission = await prisma.submission.update({
             where: {
                 id: submissionId,
                 assignmentId: assignmentId,
@@ -558,13 +536,13 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         });
         return updatedSubmission;
     }),
-    getEvents: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
+    getEvents: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const { classId } = input;
-        const events = await prisma_1.prisma.event.findMany({
+        const events = await prisma.event.findMany({
             where: {
                 class: {
                     id: classId,
@@ -578,28 +556,28 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         });
         return events;
     }),
-    listMarkSchemes: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
+    listMarkSchemes: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const { classId } = input;
-        const markSchemes = await prisma_1.prisma.markScheme.findMany({
+        const markSchemes = await prisma.markScheme.findMany({
             where: {
                 classId: classId,
             },
         });
         return markSchemes;
     }),
-    createMarkScheme: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        structure: zod_1.z.string(),
+    createMarkScheme: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        structure: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, structure } = input;
         const validatedStructure = structure.replace(/\\n/g, '\n');
-        const markScheme = await prisma_1.prisma.markScheme.create({
+        const markScheme = await prisma.markScheme.create({
             data: {
                 classId: classId,
                 structured: validatedStructure,
@@ -607,55 +585,55 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         });
         return markScheme;
     }),
-    updateMarkScheme: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        markSchemeId: zod_1.z.string(),
-        structure: zod_1.z.string(),
+    updateMarkScheme: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        markSchemeId: z.string(),
+        structure: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, markSchemeId, structure } = input;
         const validatedStructure = structure.replace(/\\n/g, '\n');
-        const markScheme = await prisma_1.prisma.markScheme.update({
+        const markScheme = await prisma.markScheme.update({
             where: { id: markSchemeId },
             data: { structured: validatedStructure },
         });
         return markScheme;
     }),
-    deleteMarkScheme: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        markSchemeId: zod_1.z.string(),
+    deleteMarkScheme: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        markSchemeId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, markSchemeId } = input;
-        const markScheme = await prisma_1.prisma.markScheme.delete({
+        const markScheme = await prisma.markScheme.delete({
             where: { id: markSchemeId },
         });
         return markScheme;
     }),
-    listGradingBoundaries: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
+    listGradingBoundaries: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const { classId } = input;
-        const gradingBoundaries = await prisma_1.prisma.gradingBoundary.findMany({
+        const gradingBoundaries = await prisma.gradingBoundary.findMany({
             where: {
                 classId: classId,
             },
         });
         return gradingBoundaries;
     }),
-    createGradingBoundary: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        structure: zod_1.z.string(),
+    createGradingBoundary: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        structure: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, structure } = input;
         const validatedStructure = structure.replace(/\\n/g, '\n');
-        const gradingBoundary = await prisma_1.prisma.gradingBoundary.create({
+        const gradingBoundary = await prisma.gradingBoundary.create({
             data: {
                 classId: classId,
                 structured: validatedStructure,
@@ -663,31 +641,324 @@ exports.classRouter = (0, trpc_1.createTRPCRouter)({
         });
         return gradingBoundary;
     }),
-    updateGradingBoundary: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        gradingBoundaryId: zod_1.z.string(),
-        structure: zod_1.z.string(),
+    updateGradingBoundary: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        gradingBoundaryId: z.string(),
+        structure: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, gradingBoundaryId, structure } = input;
         const validatedStructure = structure.replace(/\\n/g, '\n');
-        const gradingBoundary = await prisma_1.prisma.gradingBoundary.update({
+        const gradingBoundary = await prisma.gradingBoundary.update({
             where: { id: gradingBoundaryId },
             data: { structured: validatedStructure },
         });
         return gradingBoundary;
     }),
-    deleteGradingBoundary: trpc_1.protectedTeacherProcedure
-        .input(zod_1.z.object({
-        classId: zod_1.z.string(),
-        gradingBoundaryId: zod_1.z.string(),
+    deleteGradingBoundary: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        gradingBoundaryId: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const { classId, gradingBoundaryId } = input;
-        const gradingBoundary = await prisma_1.prisma.gradingBoundary.delete({
+        const gradingBoundary = await prisma.gradingBoundary.delete({
             where: { id: gradingBoundaryId },
         });
         return gradingBoundary;
     }),
+    getSyllabus: protectedClassMemberProcedure
+        .input(z.object({
+        classId: z.string(),
+    }))
+        .query(async ({ input }) => {
+        const { classId } = input;
+        const syllabus = (await prisma.class.findUnique({
+            where: {
+                id: classId,
+            },
+        }))?.syllabus;
+        const markSchemes = await prisma.markScheme.findMany({
+            where: {
+                classId,
+            }
+        });
+        const gradingBoundaries = await prisma.gradingBoundary.findMany({
+            where: {
+                classId,
+            }
+        });
+        return { syllabus, gradingBoundaries, markSchemes };
+    }),
+    updateSyllabus: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        contents: z.string(),
+    }))
+        .mutation(async ({ input }) => {
+        const { contents, classId } = input;
+        if (!contents)
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: "Missing key contents",
+            });
+        const updated = await prisma.class.update({
+            where: {
+                id: classId
+            },
+            data: {
+                syllabus: contents,
+            }
+        });
+        return updated;
+    }),
+    // Lab Management Endpoints (Assignment-based)
+    listLabDrafts: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        const labDrafts = await prisma.assignment.findMany({
+            where: {
+                classId: classId,
+                teacherId: ctx.user?.id,
+                inProgress: true,
+            },
+            orderBy: {
+                modifiedAt: 'desc',
+            },
+        });
+        return labDrafts;
+    }),
+    createLabDraft: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        title: z.string(),
+        type: z.enum(['LAB', 'HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'OTHER']),
+        instructions: z.string(),
+        dueDate: z.date().optional(),
+        maxGrade: z.number().optional(),
+        weight: z.number().optional(),
+        graded: z.boolean().optional(),
+        sectionId: z.string().optional(),
+        markSchemeId: z.string().optional(),
+        gradingBoundaryId: z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, ...draftData } = input;
+        const labDraft = await prisma.assignment.create({
+            data: {
+                classId: classId,
+                teacherId: ctx.user?.id,
+                inProgress: true,
+                graded: draftData.graded ?? false,
+                maxGrade: draftData.maxGrade ?? 0,
+                weight: draftData.weight ?? 1,
+                dueDate: draftData.dueDate || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // Default 1 week from now
+                title: draftData.title,
+                instructions: draftData.instructions,
+                type: draftData.type,
+                ...(draftData.sectionId && { sectionId: draftData.sectionId }),
+                ...(draftData.markSchemeId && { markSchemeId: draftData.markSchemeId }),
+                ...(draftData.gradingBoundaryId && { gradingBoundaryId: draftData.gradingBoundaryId }),
+            },
+        });
+        return labDraft;
+    }),
+    updateLabDraft: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        draftId: z.string(),
+        title: z.string().optional(),
+        instructions: z.string().optional(),
+        dueDate: z.date().optional(),
+        maxGrade: z.number().optional(),
+        weight: z.number().optional(),
+        graded: z.boolean().optional(),
+        sectionId: z.string().optional(),
+        markSchemeId: z.string().optional(),
+        gradingBoundaryId: z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, draftId, ...updateData } = input;
+        const labDraft = await prisma.assignment.update({
+            where: {
+                id: draftId,
+                classId: classId,
+                teacherId: ctx.user?.id,
+                inProgress: true,
+            },
+            data: {
+                ...(updateData.title && { title: updateData.title }),
+                ...(updateData.instructions && { instructions: updateData.instructions }),
+                ...(updateData.dueDate && { dueDate: updateData.dueDate }),
+                ...(updateData.maxGrade !== undefined && { maxGrade: updateData.maxGrade }),
+                ...(updateData.weight !== undefined && { weight: updateData.weight }),
+                ...(updateData.graded !== undefined && { graded: updateData.graded }),
+                ...(updateData.sectionId !== undefined && { sectionId: updateData.sectionId }),
+                ...(updateData.markSchemeId !== undefined && { markSchemeId: updateData.markSchemeId }),
+                ...(updateData.gradingBoundaryId !== undefined && { gradingBoundaryId: updateData.gradingBoundaryId }),
+                modifiedAt: new Date(),
+            },
+        });
+        return labDraft;
+    }),
+    deleteLabDraft: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        draftId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, draftId } = input;
+        const labDraft = await prisma.assignment.delete({
+            where: {
+                id: draftId,
+                classId: classId,
+                teacherId: ctx.user?.id,
+                inProgress: true,
+            },
+        });
+        return labDraft;
+    }),
+    publishLabDraft: protectedTeacherProcedure
+        .input(z.object({
+        classId: z.string(),
+        draftId: z.string(),
+        dueDate: z.date().optional(),
+        maxGrade: z.number().optional(),
+        weight: z.number().optional(),
+        graded: z.boolean().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { classId, draftId, ...publishData } = input;
+        // Get the lab draft
+        const labDraft = await prisma.assignment.findUnique({
+            where: {
+                id: draftId,
+                classId: classId,
+                teacherId: ctx.user?.id,
+                inProgress: true,
+            },
+        });
+        if (!labDraft) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Lab draft not found',
+            });
+        }
+        // Publish the draft by updating it to not be in progress
+        const publishedAssignment = await prisma.assignment.update({
+            where: { id: draftId },
+            data: {
+                inProgress: false,
+                dueDate: publishData.dueDate || labDraft.dueDate,
+                maxGrade: publishData.maxGrade || labDraft.maxGrade || 100,
+                weight: publishData.weight || labDraft.weight || 1,
+                graded: publishData.graded !== undefined ? publishData.graded : true,
+                modifiedAt: new Date(),
+            },
+        });
+        return publishedAssignment;
+    }),
+    getFiles: protectedClassMemberProcedure
+        .input(z.object({
+        classId: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { classId } = input;
+        // Get all assignments with their files and submissions
+        const assignments = await prisma.assignment.findMany({
+            where: {
+                classId: classId,
+            },
+            include: {
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                        size: true,
+                        path: true,
+                        thumbnailId: true,
+                        uploadedAt: true,
+                        user: {
+                            select: {
+                                id: true,
+                                username: true,
+                            },
+                        },
+                    },
+                },
+                submissions: {
+                    include: {
+                        attachments: {
+                            select: {
+                                id: true,
+                                name: true,
+                                type: true,
+                                size: true,
+                                path: true,
+                                thumbnailId: true,
+                                uploadedAt: true,
+                                user: {
+                                    select: {
+                                        id: true,
+                                        username: true,
+                                    },
+                                },
+                            },
+                        },
+                        annotations: {
+                            select: {
+                                id: true,
+                                name: true,
+                                type: true,
+                                size: true,
+                                path: true,
+                                thumbnailId: true,
+                                uploadedAt: true,
+                                user: {
+                                    select: {
+                                        id: true,
+                                        username: true,
+                                    },
+                                },
+                            },
+                        },
+                        student: {
+                            select: {
+                                id: true,
+                                username: true,
+                            },
+                        },
+                    },
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+            },
+            orderBy: {
+                createdAt: 'desc',
+            },
+        });
+        // Organize files by assignment structure
+        const organizedFiles = assignments.map(assignment => ({
+            id: assignment.id,
+            title: assignment.title,
+            teacher: assignment.teacher,
+            teacherAttachments: assignment.attachments,
+            students: assignment.submissions.map(submission => ({
+                id: submission.student.id,
+                username: submission.student.username,
+                attachments: submission.attachments,
+                annotations: submission.annotations,
+            })),
+        }));
+        return organizedFiles;
+    }),
 });