@studious-lms/server 1.2.53 → 1.4.0

package/src/routers/class.ts

@@ -1,1021 +1,248 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure, protectedTeacherProcedure, protectedClassMemberProcedure } from "../trpc.js";
-import { prisma } from "../lib/prisma.js";
-import { TRPCError } from "@trpc/server";
-import { generateInviteCode } from "../utils/generateInviteCode.js";
+import {
+  createTRPCRouter,
+  protectedProcedure,
+  protectedTeacherProcedure,
+  protectedClassMemberProcedure,
+} from "../trpc.js";
+import {
+  getAllClasses,
+  getClass,
+  updateClass,
+  createClass,
+  deleteClass,
+  addStudent,
+  changeRole,
+  removeMember,
+  leaveClass,
+  joinClass,
+  getInviteCode,
+  createInviteCode,
+  getGrades,
+  updateGrade,
+  getEvents,
+  listMarkSchemes,
+  createMarkScheme,
+  updateMarkScheme,
+  deleteMarkScheme,
+  listGradingBoundaries,
+  createGradingBoundary,
+  updateGradingBoundary,
+  deleteGradingBoundary,
+  getSyllabus,
+  updateSyllabus,
+  listLabDrafts,
+  createLabDraft,
+  updateLabDraft,
+  deleteLabDraft,
+  publishLabDraft,
+  getFiles,
+  exportClass,
+  importClass,
+} from "../services/class.js";
 
 export const classRouter = createTRPCRouter({
-  getAll: protectedProcedure
-  
-    .query(async ({ ctx }) => {
-      const [teacherClasses, studentClasses] = await Promise.all([
-        prisma.class.findMany({
-          where: {
-              teachers: {
-                some: {
-                  id: ctx.user?.id,
-              },
-            },
-          },
-          include: {
-            assignments: {
-              where: {
-                dueDate: {
-                  lte: new Date(new Date().setHours(23, 59, 59, 999)),
-                },
-                template: false,
-              },
-              select: {
+  getAll: protectedProcedure.query(({ ctx }) =>
+    getAllClasses(ctx.user?.id ?? "")
+  ),
 
-                id: true,
-                title: true,
-                type: true,
-                dueDate: true,
-              },
-            },
-            students: {
-              select: {
-                id: true,
-                username: true,
-                profile: {
-                  select: {
-                    displayName: true,
-                    profilePicture: true,
-                    profilePictureThumbnail: true,
-                  },
-                },
-              },
-            },
-            teachers: {
-              select: {
-                id: true,
-                username: true,
-                profile: {
-                  select: {
-                    displayName: true,
-                    profilePicture: true,
-                    profilePictureThumbnail: true,
-                  },
-                },
-              },
-            },
-          },
-        }),
-        prisma.class.findMany({
-          where: {
-            students: {
-              some: {
-                id: ctx.user?.id,
-              },
-            },
-          },
-          include: {
-            assignments: {
-              where: {
-                dueDate: {  
-                  lte: new Date(new Date().setHours(23, 59, 59, 999)),
-                },
-                template: false,
-              },
-              select: {
-                id: true,
-                title: true,
-                type: true,
-                dueDate: true,
-              },
-            },
-            students: {
-              select: {
-                id: true,
-                username: true,
-                profile: {
-                  select: {
-                    displayName: true,
-                    profilePicture: true,
-                    profilePictureThumbnail: true,
-                  },
-                },
-              },
-            },
-            teachers: {
-              select: {
-                id: true,
-                username: true,
-                profile: {
-                  select: {
-                    displayName: true,
-                    profilePicture: true,
-                    profilePictureThumbnail: true,
-                  },
-                },
-              },
-            },
-          },
-        }),
-      ]);
-
-      return {
-        teacherInClass: teacherClasses.map(cls => ({
-          id: cls.id,
-          name: cls.name,
-          section: cls.section,
-          subject: cls.subject,
-          dueToday: cls.assignments,
-          assignments: cls.assignments,
-          members: [...cls.students, ...cls.teachers],
-          color: cls.color,
-        })),
-        studentInClass: studentClasses.map(cls => ({
-          id: cls.id,
-          name: cls.name,
-          section: cls.section,
-          subject: cls.subject,
-          dueToday: cls.assignments,
-          assignments: cls.assignments,
-          members: [...cls.students, ...cls.teachers],
-          color: cls.color,
-        })),
-      };
-    }),
   get: protectedProcedure
-    .input(z.object({
-      classId: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { classId } = input;
-
-      const isTeacher = await prisma.class.findFirst({
-        where: {
-          id: classId,
-          teachers: {
-            some: { id: ctx.user?.id },
-          },
-        },
-      });
-
-      const classData = await prisma.class.findUnique({
-        where: {
-          id: classId,
-        },
-        include: {
-          teachers: {
-            select: {
-              id: true,
-              username: true,
-              profile: {
-                select: {
-                  displayName: true,
-                  profilePicture: true,
-                  profilePictureThumbnail: true,
-                }
-              }
-            },
-          },
-          students: {
-            select: {
-              id: true,
-              username: true,
-              profile: {
-                select: {
-                  displayName: true,
-                  profilePicture: true,
-                  profilePictureThumbnail: true,
-                },
-              },
-            },
-          },
-          announcements: {
-            orderBy: {
-              createdAt: 'desc',
-            },
-            select: {
-              id: true,
-              remarks: true,
-              createdAt: true,
-              modifiedAt: true,
-              teacher: {
-                select: {
-                  id: true,
-                  username: true,
-                  profile: {
-                    select: {
-                      displayName: true,
-                      profilePicture: true,
-                      profilePictureThumbnail: true,
-                    },
-                  },
-                },
-              },
-            },
-          },
-          assignments: {
-            ...(!isTeacher && {
-              where: {OR: [
-                {
-                  assignedTo: {
-                    some: {
-                      id: ctx.user?.id,
-                    },
-                  },
-                },
-                {
-                  assignedTo: {
-                    none: {},
-                  },
-                },
-              ],}
-            }),
-            select: {
-              type: true,
-              id: true,
-              title: true,
-              dueDate: true,
-              createdAt: true,
-              weight: true,
-              order: true,
-              graded: true,
-              maxGrade: true,
-              instructions: true,
-              inProgress: true,
-              template: false,
-              section: {
-                select: {
-                  id: true,
-                  name: true,
-                },
-              },
-              markScheme: {
-                select: {
-                  id: true,
-                  structured: true,
-                },
-              },
-              gradingBoundary: {
-                select: {
-                  id: true,
-                  structured: true,
-                },
-              },
-              submissions: {
-                ...(!isTeacher && {
-                  where: {
-                    studentId: ctx.user?.id,
-                  },
-                }),
-                select: {
-                  studentId: true,
-                  id: true,
-                  submitted: true,
-                  gradeReceived: true,
-                  rubricState: true,
-                  teacherComments: true,
-                  returned: true,
-                  submittedAt: true,
-                },
-              },
-            },
-          },
-        },
-      });
-
-
-      if (!classData) {
-        throw new Error('Class not found');
-      }
-      
-      const formattedClassData = {
-        ...classData,
-        assignments: classData.assignments.map(assignment => ({
-          ...assignment,
-          late: assignment.dueDate < new Date(),
-          submitted: assignment.submissions.find(submission => submission.studentId === ctx.user?.id)?.submitted,
-          returned: assignment.submissions.find(submission => submission.studentId === ctx.user?.id)?.returned,
-        })),
-      }
-
-      const sections = await prisma.section.findMany({
-        where: {
-          classId: classId,
-        },
-      });
-
-      return {
-        class: {
-          ...formattedClassData,
-          sections,
-        },
-      };
-    }),
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      getClass(ctx.user?.id ?? "", input.classId)
+    ),
   update: protectedTeacherProcedure
-    .input(z.object({
-      classId: z.string(),
-      name: z.string().optional(),
-      section: z.string().optional(),
-      subject: z.string().optional(),
-    }))
-    .mutation(async ({ ctx, input }) => {
+    .input(
+      z.object({
+        classId: z.string(),
+        name: z.string().optional(),
+        section: z.string().optional(),
+        subject: z.string().optional(),
+      })
+    )
+    .mutation(({ input }) => {
       const { classId, ...updateData } = input;
-      
-      const updatedClass = await prisma.class.update({
-        where: {
-          id: classId,
-        },
-        data: updateData,
-        select: {
-          id: true,
-          name: true,
-          section: true,
-          subject: true,
-        }
-      });
-
-      return {
-        updatedClass,
-      }
+      return updateClass(classId, updateData);
     }),
+
   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, color } = input;
-      
-      if (teachers && teachers.length > 0 && students && students.length > 0) {
-        const newClass = await prisma.class.create({
-          data: {
-            name,
-            section,
-            subject,
-            color,
-            teachers: {
-              connect: teachers.map(teacher => ({ id: teacher })),
-            },
-            students: {
-              connect: students.map(student => ({ id: student })),
-            },
-          },
-          include: {
-            teachers: true,
-            students: true,
-          },
-        });
-        return newClass;
-      }
+    .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(({ ctx, input }) =>
+      createClass(ctx.user?.id ?? "", input)
+    ),
 
-      const newClass = await prisma.class.create({
-        data: {
-          name,
-          section,
-          subject,
-          color,
-          teachers: {
-            connect: {
-              id: ctx.user?.id,
-            },
-          },
-        },
-      });
-  
-      return newClass;
-    }),
   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.class.findFirst({
-        where: {
-          id: input.id,
-        },
-      });
-
-      if (!classToDelete) {
-        throw new Error("Class not found or you don't have permission to delete it");
-      }
-
-      await prisma.class.delete({
-        where: {
-          id: input.id,
-        },
-      });
-
-      return {
-        deletedClass: {
-          id: input.id,
-        }
-      }
-    }),
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ input }) => deleteClass(input.id)),
   addStudent: protectedTeacherProcedure
-    .input(z.object({
-      classId: z.string(),
-      studentId: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const { classId, studentId } = input;
-
-      const student = await prisma.user.findUnique({
-        where: {
-          id: studentId,
-        },
-      });
+    .input(z.object({ classId: z.string(), studentId: z.string() }))
+    .mutation(({ input }) => addStudent(input.classId, input.studentId)),
 
-      if (!student) {
-        throw new Error("Student not found");
-      }
-
-      const updatedClass = await prisma.class.update({
-        where: {
-          id: classId,
-        },
-        data: {
-          students: {
-            connect: {
-              id: studentId,
-            },
-          },
-        },
-        select: {
-          id: true,
-          name: true,
-          section: true,
-          subject: true,
-        }
-      });
-
-      return {
-        updatedClass,
-        newStudent: 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.user.findUnique({
-        where: { id: userId },
-        select: {
-          id: true,
-          username: true,
-        },
-      });
-
-      if (!user) {
-        throw new Error("User not found");
-      }
-
-      const updatedClass = await prisma.class.update({
-        where: { id: classId },
-        data: {
-          [type === 'teacher' ? 'teachers' : 'students']: {
-            connect: { id: userId },
-          },
-          [type === 'teacher' ? 'students' : 'teachers']: {
-            disconnect: { id: userId },
-          },
-        },
-      });
+    .input(
+      z.object({
+        classId: z.string(),
+        userId: z.string(),
+        type: z.enum(["teacher", "student"]),
+      })
+    )
+    .mutation(({ input }) =>
+      changeRole(input.classId, input.userId, input.type)
+    ),
 
-      return {
-        updatedClass,
-        user: {
-          ...user,
-          type,
-        },
-      };
-    }),
   removeMember: protectedTeacherProcedure
-    .input(z.object({
-      classId: z.string(),
-      userId: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const { classId, userId } = input;
+    .input(z.object({ classId: z.string(), userId: z.string() }))
+    .mutation(({ input }) => removeMember(input.classId, input.userId)),
 
-      const updatedClass = await prisma.class.update({
-        where: { id: classId },
-        data: {
-          teachers: {
-            disconnect: { id: userId },
-          },
-          students: {
-            disconnect: { id: userId },
-          },
-        },
-      });
-
-      return {
-        updatedClass,
-        removedUserId: userId,
-      };
-    }),
   leaveClass: protectedProcedure
-    .input(z.object({
-      classId: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const { classId } = input;
-      const userId = ctx.user?.id;
-
-      if (!userId) {
-        throw new TRPCError({
-          code: 'UNAUTHORIZED',
-          message: 'User not authenticated',
-        });
-      }
-
-      const classData = await prisma.class.findFirst({
-        where: {
-          id: classId,
-          students: {
-            some: { id: userId },
-          },
-        },
-      });
-
-      if (!classData) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: 'Class not found or you are not a student in this class',
-        });
+    .input(z.object({ classId: z.string() }))
+    .mutation(({ ctx, input }) => {
+      if (!ctx.user?.id) {
+        throw new Error("User not authenticated");
       }
-
-      await prisma.class.update({
-        where: { id: classId },
-        data: {
-          students: {
-            disconnect: { id: userId },
-          },
-        },
-      });
-
-      return {
-        success: true,
-        leftClassId: classId,
-      };
+      return leaveClass(ctx.user.id, input.classId);
     }),
-  join: protectedProcedure
-    .input(z.object({
-      classCode: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const { classCode } = input;
-
-      // Case-insensitive search for invite code
-      const session = await prisma.session.findFirst({
-        where: {
-          id: {
-            equals: classCode,
-            mode: 'insensitive',
-          },
-        },
-      });
-
-      if (!session || !session.classId) {
-        throw new Error("Class not found");
-      }
 
-      if (session.expiresAt && session.expiresAt < new Date()) {
-        throw new Error("Session expired");
-      }
-
-      const updatedClass = await prisma.class.update({
-        where: { id: session.classId },
-        data: {
-          students: {
-            connect: { id: ctx.user?.id },
-          },
-        },
-        select: {
-          id: true,
-          name: true,
-          section: true,
-          subject: true,
-        },
-      });
+  join: protectedProcedure
+    .input(z.object({ classCode: z.string() }))
+    .mutation(({ ctx, input }) =>
+      joinClass(ctx.user?.id ?? "", input.classCode)
+    ),
 
-      return {
-        joinedClass: updatedClass,
-      }
-    }),
   getInviteCode: protectedTeacherProcedure
-    .input(z.object({
-      classId: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { classId } = input;
-
-      const session = await prisma.session.findFirst({
-        where: {
-          classId,
-        },
-      });
-
-      if ((session?.expiresAt && session.expiresAt < new Date()) || !session) {
-        const newSession = await prisma.session.create({
-          data: {
-            id: generateInviteCode(),
-            classId,
-            expiresAt: new Date(Date.now() +  24 * 60 * 60 * 1000), // 24 hours from now
-          }
-        });
-        return {
-          code: newSession.id,
-        }
-      }
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => getInviteCode(input.classId)),
 
-      return {
-        code: session?.id,
-      };
-    }),
   createInviteCode: protectedTeacherProcedure
-    .input(z.object({
-      classId: z.string(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      const { classId } = input;
-
-      await prisma.session.deleteMany({
-        where: {
-          classId,
-        },
-      });
-
-      // Create a new session for the invite code
-      const session = await prisma.session.create({
-        data: {
-          id: generateInviteCode(),
-          classId,
-          expiresAt: new Date(Date.now() +  24 * 60 * 60 * 1000), // 24 hours from now
-        }
-      });
-
-      return {
-        code: session.id,
-      };
-    }),
+    .input(z.object({ classId: z.string() }))
+    .mutation(({ input }) => createInviteCode(input.classId)),
   getGrades: protectedClassMemberProcedure
-    .input(z.object({
-      classId: z.string(),
-      userId: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { classId, userId } = input;
-
-      const isTeacher = await prisma.class.findFirst({
-        where: {
-          id: classId,
-          teachers: {
-            some: { id: ctx.user?.id }
-          }
-        }
-      });
-      // If student, only allow viewing their own grades
-      if (ctx.user?.id !== userId && !isTeacher) {
-        throw new TRPCError({
-          code: 'UNAUTHORIZED',
-          message: 'You can only view your own grades',
-        });
-      }
+    .input(z.object({ classId: z.string(), userId: z.string() }))
+    .query(({ ctx, input }) =>
+      getGrades(ctx.user?.id ?? "", input.classId, input.userId)
+    ),
 
-      const grades = await prisma.submission.findMany({
-        where: {
-          studentId: userId,
-          assignment: {
-            classId: classId,
-            graded: true
-          }
-        },
-        include: {
-          assignment: {
-            select: {
-              id: true,
-              title: true,
-              maxGrade: true,
-              weight: true,
-              markSchemeId: true,
-              dueDate: true,
-              markScheme: {
-                select: {
-                  structured: true,
-                }
-              },
-              gradingBoundaryId: true,
-              gradingBoundary: {
-                select: {
-                  structured: true,
-                }
-              },
-            }
-          },
-        }
-      });
-
-      return {
-        grades,
-      };
-    }),
   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.submission.update({
-        where: {
-          id: submissionId,
-          assignmentId: assignmentId,
-        },
-        data: {
-          gradeReceived,
-        },
-        include: {
-          assignment: {
-            select: {
-              id: true,
-              title: true,
-              maxGrade: true,
-              weight: true,
-            }
-        }
-      }
-      });
-
-      return updatedSubmission;
-    }),
-    getEvents: protectedTeacherProcedure
-      .input(z.object({
-        classId: z.string(),
-      }))
-      .query(async ({ ctx, input }) => {
-        const { classId } = input;
-
-        const events = await prisma.event.findMany({
-          where: {
-            class: {
-              id: classId,
-            }
-          },
-          select: {
-            name: true,
-            startTime: true,
-            endTime: true,
-          }
-        });
-
-        return events;
-      }),
-    listMarkSchemes: protectedClassMemberProcedure
-      .input(z.object({
-        classId: z.string(),
-      }))
-      .query(async ({ ctx, input }) => {
-        const { classId } = input;
-
-        const markSchemes = await prisma.markScheme.findMany({
-          where: {
-            class: {
-              id: classId,
-            },
-          },
-        });
-
-        return markSchemes;
-      }),
-    createMarkScheme: protectedTeacherProcedure
-      .input(z.object({
+    .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.markScheme.create({
-          data: {
-            class: {
-              connect: {
-                id: classId,
-              },
-            },
-            structured: validatedStructure,
-          },
-        });
-
-        return markScheme;
-      }),
-    updateMarkScheme: protectedTeacherProcedure
-      .input(z.object({
+        assignmentId: z.string(),
+        submissionId: z.string(),
+        gradeReceived: z.number().nullable(),
+      })
+    )
+    .mutation(({ input }) =>
+      updateGrade(
+        input.assignmentId,
+        input.submissionId,
+        input.gradeReceived
+      )
+    ),
+
+  getEvents: protectedTeacherProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => getEvents(input.classId)),
+  listMarkSchemes: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => listMarkSchemes(input.classId)),
+
+  createMarkScheme: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), structure: z.string() }))
+    .mutation(({ input }) =>
+      createMarkScheme(input.classId, input.structure)
+    ),
+
+  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.markScheme.update({
-          where: { id: markSchemeId },
-          data: {
-            class: {
-              connect: {
-                id: classId,
-              },
-            },
-            structured: validatedStructure,
-          },
-        });
-
-        return markScheme;
-      }),
-    deleteMarkScheme: protectedTeacherProcedure
-      .input(z.object({
-        classId: z.string(),
-        markSchemeId: z.string(),
-      }))
-      .mutation(async ({ ctx, input }) => {
-        const { classId, markSchemeId } = input;
-
-        const markScheme = await prisma.markScheme.delete({
-          where: { id: markSchemeId },
-        });
-
-        return markScheme;
-      }),
-    listGradingBoundaries: protectedClassMemberProcedure
-      .input(z.object({
-        classId: z.string(),
-      }))
-      .query(async ({ ctx, input }) => {
-        const { classId } = input;
-
-        const gradingBoundaries = await prisma.gradingBoundary.findMany({
-          where: {
-            class: {
-              id: classId,
-            },
-          },
-        });
-
-        return gradingBoundaries;
-      }),
-    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.gradingBoundary.create({
-          data: {
-            class: {
-              connect: {
-                id: classId,
-              },
-            },
-            structured: validatedStructure,
-          },
-        });
-
-        return gradingBoundary;
-      }),
-    updateGradingBoundary: protectedTeacherProcedure
-      .input(z.object({
+      })
+    )
+    .mutation(({ input }) =>
+      updateMarkScheme(
+        input.markSchemeId,
+        input.classId,
+        input.structure
+      )
+    ),
+
+  deleteMarkScheme: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), markSchemeId: z.string() }))
+    .mutation(({ input }) => deleteMarkScheme(input.markSchemeId)),
+
+  listGradingBoundaries: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => listGradingBoundaries(input.classId)),
+
+  createGradingBoundary: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), structure: z.string() }))
+    .mutation(({ input }) =>
+      createGradingBoundary(input.classId, input.structure)
+    ),
+
+  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.gradingBoundary.update({
-          where: { id: gradingBoundaryId },
-          data: {
-            class: {
-              connect: {
-                id: classId,
-              },
-            },
-            structured: validatedStructure,
-          },
-        });
-
-        return gradingBoundary;
-      }),
-    deleteGradingBoundary: protectedTeacherProcedure
-      .input(z.object({
-        classId: z.string(),
-        gradingBoundaryId: z.string(),
-      }))
-      .mutation(async ({ ctx, input }) => {
-        const { classId, gradingBoundaryId } = input;
-
-        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({
+      })
+    )
+    .mutation(({ input }) =>
+      updateGradingBoundary(
+        input.gradingBoundaryId,
+        input.classId,
+        input.structure
+      )
+    ),
+
+  deleteGradingBoundary: protectedTeacherProcedure
+    .input(
+      z.object({ classId: z.string(), gradingBoundaryId: z.string() })
+    )
+    .mutation(({ input }) => deleteGradingBoundary(input.gradingBoundaryId)),
+  getSyllabus: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => getSyllabus(input.classId)),
+
+  updateSyllabus: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), contents: z.string() }))
+    .mutation(({ input }) =>
+      updateSyllabus(input.classId, input.contents)
+    ),
+  listLabDrafts: protectedTeacherProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      listLabDrafts(input.classId, ctx.user?.id ?? "")
+    ),
+
+  createLabDraft: protectedTeacherProcedure
+    .input(
+      z.object({
         classId: z.string(),
         title: z.string(),
-        type: z.enum(['LAB', 'HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'OTHER']),
+        type: z.enum([
+          "LAB",
+          "HOMEWORK",
+          "QUIZ",
+          "TEST",
+          "PROJECT",
+          "ESSAY",
+          "DISCUSSION",
+          "PRESENTATION",
+          "OTHER",
+        ]),
         instructions: z.string(),
         dueDate: z.date().optional(),
         maxGrade: z.number().optional(),
@@ -1024,32 +251,16 @@ export const classRouter = createTRPCRouter({
         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 }),
-          },
-        });
+      })
+    )
+    .mutation(({ ctx, input }) => {
+      const { classId, ...draftData } = input;
+      return createLabDraft(classId, ctx.user?.id ?? "", draftData);
+    }),
 
-        return labDraft;
-      }),
-    updateLabDraft: protectedTeacherProcedure
-      .input(z.object({
+  updateLabDraft: protectedTeacherProcedure
+    .input(
+      z.object({
         classId: z.string(),
         draftId: z.string(),
         title: z.string().optional(),
@@ -1061,196 +272,61 @@ export const classRouter = createTRPCRouter({
         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;
+      })
+    )
+    .mutation(({ ctx, input }) => {
+      const { classId, draftId, ...updateData } = input;
+      return updateLabDraft(
+        classId,
+        ctx.user?.id ?? "",
+        draftId,
+        updateData
+      );
+    }),
 
-        const labDraft = await prisma.assignment.delete({
-          where: {
-            id: draftId,
-            classId: classId,
-            teacherId: ctx.user?.id!,
-            inProgress: true,
-          },
-        });
+  deleteLabDraft: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), draftId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteLabDraft(input.classId, ctx.user?.id ?? "", input.draftId)
+    ),
 
-        return labDraft;
-      }),
-    publishLabDraft: protectedTeacherProcedure
-      .input(z.object({
+  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',
-          });
-        }
+      })
+    )
+    .mutation(({ ctx, input }) => {
+      const { classId, draftId, ...publishData } = input;
+      return publishLabDraft(
+        classId,
+        ctx.user?.id ?? "",
+        draftId,
+        publishData
+      );
+    }),
 
-        // 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(),
-          },
-        });
+  getFiles: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => getFiles(input.classId)),
+  exportClass: protectedTeacherProcedure
+    .input(z.object({ classId: z.string() }))
+    .mutation(({ ctx, input }) => exportClass(input.classId, ctx.user?.id ?? "")),
 
-        return publishedAssignment;
-      }),
-    getFiles: protectedClassMemberProcedure
-      .input(z.object({
+  importClass: protectedProcedure
+    .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;
-      }),
+        year: z.number(),
+        classData: z.any(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      importClass(input.classId, ctx.user?.id ?? "", input.year, input.classData)
+    ),
 });