@studious-lms/server 1.1.26 → 1.2.6

package/dist/routers/class.js

@@ -1,226 +1,13 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="43c06b92-74d9-5f52-a500-f14b511e48a2")}catch(e){}}();
 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: {
-                            id: true,
-                            title: true,
-                            type: true,
-                            dueDate: 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,
-                        },
-                    },
-                },
-            }),
-        ]);
-        return {
-            teacherInClass: teacherClasses.map(cls => ({
-                id: cls.id,
-                name: cls.name,
-                section: cls.section,
-                subject: cls.subject,
-                dueToday: cls.assignments,
-                assignments: cls.assignments,
-                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,
-                color: cls.color,
-            })),
-        };
-    }),
+    getAll: protectedProcedure.query(({ ctx }) => getAllClasses(ctx.user?.id ?? "")),
     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,
-                        teacher: {
-                            select: {
-                                id: true,
-                                username: true,
-                                profile: {
-                                    select: {
-                                        displayName: true,
-                                        profilePicture: true,
-                                        profilePictureThumbnail: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                assignments: {
-                    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,
-                                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.some(submission => submission.studentId === ctx.user?.id),
-                returned: assignment.submissions.some(submission => submission.studentId === ctx.user?.id && submission.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(),
@@ -228,23 +15,9 @@ export const classRouter = createTRPCRouter({
         section: z.string().optional(),
         subject: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
+        .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({
@@ -255,310 +28,43 @@ export const classRouter = createTRPCRouter({
         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;
-        }
-        const newClass = await prisma.class.create({
-            data: {
-                name,
-                section,
-                subject,
-                color,
-                teachers: {
-                    connect: {
-                        id: ctx.user?.id,
-                    },
-                },
-            },
-        });
-        return newClass;
-    }),
+        .mutation(({ ctx, input }) => createClass(ctx.user?.id ?? "", input)),
     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,
-            },
-        });
-        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,
-        };
-    }),
+        .input(z.object({ classId: z.string(), studentId: z.string() }))
+        .mutation(({ input }) => addStudent(input.classId, input.studentId)),
     changeRole: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
         userId: z.string(),
-        type: z.enum(['teacher', 'student']),
+        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 },
-                },
-            },
-        });
-        return {
-            updatedClass,
-            user: {
-                ...user,
-                type,
-            },
-        };
-    }),
+        .mutation(({ input }) => changeRole(input.classId, input.userId, input.type)),
     removeMember: protectedTeacherProcedure
-        .input(z.object({
-        classId: z.string(),
-        userId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { classId, userId } = input;
-        const updatedClass = await prisma.class.update({
-            where: { id: classId },
-            data: {
-                teachers: {
-                    disconnect: { id: userId },
-                },
-                students: {
-                    disconnect: { id: userId },
-                },
-            },
-        });
-        return {
-            updatedClass,
-            removedUserId: userId,
-        };
-    }),
-    join: protectedProcedure
-        .input(z.object({
-        classCode: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { classCode } = input;
-        const session = await prisma.session.findFirst({
-            where: {
-                id: classCode,
-            },
-        });
-        if (!session || !session.classId) {
-            throw new Error("Class not found");
-        }
-        if (session.expiresAt && session.expiresAt < new Date()) {
-            throw new Error("Session expired");
+        .input(z.object({ classId: z.string(), userId: z.string() }))
+        .mutation(({ input }) => removeMember(input.classId, input.userId)),
+    leaveClass: protectedProcedure
+        .input(z.object({ classId: z.string() }))
+        .mutation(({ ctx, input }) => {
+        if (!ctx.user?.id) {
+            throw new Error("User not authenticated");
         }
-        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,
-            },
-        });
-        return {
-            joinedClass: updatedClass,
-        };
+        return leaveClass(ctx.user.id, input.classId);
     }),
+    join: protectedProcedure
+        .input(z.object({ classCode: z.string() }))
+        .mutation(({ ctx, input }) => joinClass(ctx.user?.id ?? "", input.classCode)),
     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,
-            };
-        }
-        return {
-            code: session?.id,
-        };
-    }),
+        .input(z.object({ classId: z.string() }))
+        .query(({ input }) => getInviteCode(input.classId)),
     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',
-            });
-        }
-        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,
-                        markScheme: {
-                            select: {
-                                structured: true,
-                            }
-                        },
-                        gradingBoundaryId: true,
-                        gradingBoundary: {
-                            select: {
-                                structured: true,
-                            }
-                        },
-                    }
-                },
-            }
-        });
-        return {
-            grades,
-        };
-    }),
+        .input(z.object({ classId: z.string(), userId: z.string() }))
+        .query(({ ctx, input }) => getGrades(ctx.user?.id ?? "", input.classId, input.userId)),
     updateGrade: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
@@ -566,231 +72,66 @@ export const classRouter = createTRPCRouter({
         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;
-    }),
+        .mutation(({ input }) => updateGrade(input.assignmentId, input.submissionId, input.gradeReceived)),
     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: protectedTeacherProcedure
-        .input(z.object({
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { classId } = input;
-        const markSchemes = await prisma.markScheme.findMany({
-            where: {
-                classId: classId,
-            },
-        });
-        return markSchemes;
-    }),
+        .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(async ({ ctx, input }) => {
-        const { classId, structure } = input;
-        const validatedStructure = structure.replace(/\\n/g, '\n');
-        const markScheme = await prisma.markScheme.create({
-            data: {
-                classId: classId,
-                structured: validatedStructure,
-            },
-        });
-        return markScheme;
-    }),
+        .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: { structured: validatedStructure },
-        });
-        return markScheme;
-    }),
+        .mutation(({ input }) => updateMarkScheme(input.markSchemeId, input.classId, input.structure)),
     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: protectedTeacherProcedure
-        .input(z.object({
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { classId } = input;
-        const gradingBoundaries = await prisma.gradingBoundary.findMany({
-            where: {
-                classId: classId,
-            },
-        });
-        return gradingBoundaries;
-    }),
+        .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(async ({ ctx, input }) => {
-        const { classId, structure } = input;
-        const validatedStructure = structure.replace(/\\n/g, '\n');
-        const gradingBoundary = await prisma.gradingBoundary.create({
-            data: {
-                classId: classId,
-                structured: validatedStructure,
-            },
-        });
-        return gradingBoundary;
-    }),
+        .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: { structured: validatedStructure },
-        });
-        return gradingBoundary;
-    }),
+        .mutation(({ input }) => updateGradingBoundary(input.gradingBoundaryId, input.classId, input.structure)),
     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;
-    }),
+        .input(z.object({ classId: z.string(), gradingBoundaryId: z.string() }))
+        .mutation(({ input }) => deleteGradingBoundary(input.gradingBoundaryId)),
     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 };
-    }),
+        .input(z.object({ classId: z.string() }))
+        .query(({ input }) => getSyllabus(input.classId)),
     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)
+        .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(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;
-    }),
+        .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(),
@@ -800,26 +141,9 @@ export const classRouter = createTRPCRouter({
         markSchemeId: z.string().optional(),
         gradingBoundaryId: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
+        .mutation(({ 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;
+        return createLabDraft(classId, ctx.user?.id ?? "", draftData);
     }),
     updateLabDraft: protectedTeacherProcedure
         .input(z.object({
@@ -835,47 +159,13 @@ export const classRouter = createTRPCRouter({
         markSchemeId: z.string().optional(),
         gradingBoundaryId: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
+        .mutation(({ 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;
+        return updateLabDraft(classId, ctx.user?.id ?? "", draftId, updateData);
     }),
     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;
-    }),
+        .input(z.object({ classId: z.string(), draftId: z.string() }))
+        .mutation(({ ctx, input }) => deleteLabDraft(input.classId, ctx.user?.id ?? "", input.draftId)),
     publishLabDraft: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
@@ -885,134 +175,23 @@ export const classRouter = createTRPCRouter({
         weight: z.number().optional(),
         graded: z.boolean().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
+        .mutation(({ 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;
+        return publishLabDraft(classId, ctx.user?.id ?? "", draftId, publishData);
     }),
     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 ?? "")),
+    importClass: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
+        year: z.number(),
+        classData: z.any(),
     }))
-        .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;
-    }),
+        .mutation(({ ctx, input }) => importClass(input.classId, ctx.user?.id ?? "", input.year, input.classData)),
 });
+//# sourceMappingURL=class.js.map
+//# debugId=43c06b92-74d9-5f52-a500-f14b511e48a2