@studious-lms/server 1.0.0

package/dist/routers/assignment.js

@@ -0,0 +1,1497 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignmentRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const server_1 = require("@trpc/server");
+const prisma_1 = require("@lib/prisma");
+const fileUpload_1 = require("@lib/fileUpload");
+const googleCloudStorage_1 = require("@lib/googleCloudStorage");
+const fileSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    type: zod_1.z.string(),
+    size: zod_1.z.number(),
+    data: zod_1.z.string(), // base64 encoded file data
+});
+const createAssignmentSchema = zod_1.z.object({
+    classId: zod_1.z.string(),
+    title: zod_1.z.string(),
+    instructions: zod_1.z.string(),
+    dueDate: zod_1.z.string(),
+    files: zod_1.z.array(fileSchema).optional(),
+    maxGrade: zod_1.z.number().optional(),
+    graded: zod_1.z.boolean().optional(),
+    weight: zod_1.z.number().optional(),
+    sectionId: zod_1.z.string().optional(),
+    type: zod_1.z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
+    markSchemeId: zod_1.z.string().optional(),
+    gradingBoundaryId: zod_1.z.string().optional(),
+});
+const updateAssignmentSchema = zod_1.z.object({
+    classId: zod_1.z.string(),
+    id: zod_1.z.string(),
+    title: zod_1.z.string().optional(),
+    instructions: zod_1.z.string().optional(),
+    dueDate: zod_1.z.string().optional(),
+    files: zod_1.z.array(fileSchema).optional(),
+    removedAttachments: zod_1.z.array(zod_1.z.string()).optional(),
+    maxGrade: zod_1.z.number().optional(),
+    graded: zod_1.z.boolean().optional(),
+    weight: zod_1.z.number().optional(),
+    sectionId: zod_1.z.string().nullable().optional(),
+    type: zod_1.z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']).optional(),
+});
+const deleteAssignmentSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    classId: zod_1.z.string(),
+});
+const getAssignmentSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    classId: zod_1.z.string(),
+});
+const submissionSchema = zod_1.z.object({
+    assignmentId: zod_1.z.string(),
+    classId: zod_1.z.string(),
+    submissionId: zod_1.z.string(),
+    submit: zod_1.z.boolean().optional(),
+    newAttachments: zod_1.z.array(fileSchema).optional(),
+    removedAttachments: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const updateSubmissionSchema = zod_1.z.object({
+    assignmentId: zod_1.z.string(),
+    classId: zod_1.z.string(),
+    submissionId: zod_1.z.string(),
+    return: zod_1.z.boolean().optional(),
+    gradeReceived: zod_1.z.number().nullable().optional(),
+    newAttachments: zod_1.z.array(fileSchema).optional(),
+    removedAttachments: zod_1.z.array(zod_1.z.string()).optional(),
+    rubricGrades: zod_1.z.array(zod_1.z.object({
+        criteriaId: zod_1.z.string(),
+        selectedLevelId: zod_1.z.string(),
+        points: zod_1.z.number(),
+        comments: zod_1.z.string(),
+    })).optional(),
+});
+exports.assignmentRouter = (0, trpc_1.createTRPCRouter)({
+    create: trpc_1.protectedProcedure
+        .input(createAssignmentSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { classId, title, instructions, dueDate, files, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId } = input;
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Get all students in the class
+        const classData = await prisma_1.prisma.class.findUnique({
+            where: { id: classId },
+            include: {
+                students: {
+                    select: { id: true }
+                }
+            }
+        });
+        if (!classData) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Class not found",
+            });
+        }
+        const rubric = await prisma_1.prisma.markScheme.findUnique({
+            where: { id: markSchemeId },
+            select: {
+                structured: true,
+            }
+        });
+        const parsedRubric = JSON.parse(rubric?.structured || "{}");
+        // Calculate max grade from rubric criteria levels
+        const computedMaxGrade = parsedRubric.criteria.reduce((acc, criterion) => {
+            const maxPoints = Math.max(...criterion.levels.map((level) => level.points));
+            return acc + maxPoints;
+        }, 0);
+        // Create assignment with submissions for all students
+        const assignment = await prisma_1.prisma.assignment.create({
+            data: {
+                title,
+                instructions,
+                dueDate: new Date(dueDate),
+                maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
+                graded,
+                weight,
+                type,
+                class: {
+                    connect: { id: classId }
+                },
+                ...(sectionId && {
+                    section: {
+                        connect: { id: sectionId }
+                    }
+                }),
+                ...(markSchemeId && {
+                    markScheme: {
+                        connect: { id: markSchemeId }
+                    }
+                }),
+                ...(gradingBoundaryId && {
+                    gradingBoundary: {
+                        connect: { id: gradingBoundaryId }
+                    }
+                }),
+                submissions: {
+                    create: classData.students.map((student) => ({
+                        student: {
+                            connect: { id: student.id }
+                        }
+                    }))
+                },
+                teacher: {
+                    connect: { id: ctx.user.id }
+                }
+            },
+            select: {
+                id: true,
+                title: true,
+                instructions: true,
+                dueDate: true,
+                maxGrade: true,
+                graded: true,
+                weight: true,
+                type: true,
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                    }
+                },
+                section: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                },
+                class: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                }
+            }
+        });
+        // Upload files if provided
+        let uploadedFiles = [];
+        if (files && files.length > 0) {
+            // Store files in a class and assignment specific directory
+            uploadedFiles = await (0, fileUpload_1.uploadFiles)(files, ctx.user.id, `class/${classId}/assignment/${assignment.id}`);
+        }
+        // Update assignment with new file attachments
+        if (uploadedFiles.length > 0) {
+            await prisma_1.prisma.assignment.update({
+                where: { id: assignment.id },
+                data: {
+                    attachments: {
+                        create: uploadedFiles.map(file => ({
+                            name: file.name,
+                            type: file.type,
+                            size: file.size,
+                            path: file.path,
+                            ...(file.thumbnailId && {
+                                thumbnail: {
+                                    connect: { id: file.thumbnailId }
+                                }
+                            })
+                        }))
+                    }
+                }
+            });
+        }
+        return assignment;
+    }),
+    update: trpc_1.protectedProcedure
+        .input(updateAssignmentSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { id, title, instructions, dueDate, files, maxGrade, graded, weight, sectionId, type } = input;
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Get the assignment with current attachments
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id,
+                teacherId: ctx.user.id,
+            },
+            include: {
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                        thumbnail: {
+                            select: {
+                                path: true
+                            }
+                        }
+                    },
+                },
+                class: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+            },
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        // Upload new files if provided
+        let uploadedFiles = [];
+        if (files && files.length > 0) {
+            // Store files in a class and assignment specific directory
+            uploadedFiles = await (0, fileUpload_1.uploadFiles)(files, ctx.user.id, `class/${assignment.classId}/assignment/${id}`);
+        }
+        // Update assignment
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id },
+            data: {
+                ...(title && { title }),
+                ...(instructions && { instructions }),
+                ...(dueDate && { dueDate: new Date(dueDate) }),
+                ...(maxGrade && { maxGrade }),
+                ...(graded !== undefined && { graded }),
+                ...(weight && { weight }),
+                ...(type && { type }),
+                ...(sectionId !== undefined && {
+                    section: sectionId ? {
+                        connect: { id: sectionId }
+                    } : {
+                        disconnect: true
+                    }
+                }),
+                ...(uploadedFiles.length > 0 && {
+                    attachments: {
+                        create: uploadedFiles.map(file => ({
+                            name: file.name,
+                            type: file.type,
+                            size: file.size,
+                            path: file.path,
+                            ...(file.thumbnailId && {
+                                thumbnail: {
+                                    connect: { id: file.thumbnailId }
+                                }
+                            })
+                        }))
+                    }
+                }),
+                ...(input.removedAttachments && input.removedAttachments.length > 0 && {
+                    attachments: {
+                        deleteMany: {
+                            id: { in: input.removedAttachments }
+                        }
+                    }
+                }),
+            },
+            select: {
+                id: true,
+                title: true,
+                instructions: true,
+                dueDate: true,
+                maxGrade: true,
+                graded: true,
+                weight: true,
+                type: true,
+                createdAt: true,
+                submissions: {
+                    select: {
+                        student: {
+                            select: {
+                                id: true,
+                                username: true
+                            }
+                        }
+                    }
+                },
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                        thumbnail: true
+                    }
+                },
+                section: true,
+                teacher: true,
+                class: true
+            }
+        });
+        if (assignment.markSchemeId) {
+            const rubric = await prisma_1.prisma.markScheme.findUnique({
+                where: { id: assignment.markSchemeId },
+                select: {
+                    structured: true,
+                }
+            });
+            const parsedRubric = JSON.parse(rubric?.structured || "{}");
+            const computedMaxGrade = parsedRubric.criteria.reduce((acc, criterion) => {
+                const maxPoints = Math.max(...criterion.levels.map((level) => level.points));
+                return acc + maxPoints;
+            }, 0);
+            await prisma_1.prisma.assignment.update({
+                where: { id },
+                data: {
+                    maxGrade: computedMaxGrade,
+                }
+            });
+        }
+        return updatedAssignment;
+    }),
+    delete: trpc_1.protectedProcedure
+        .input(deleteAssignmentSchema)
+        .mutation(async ({ ctx, input }) => {
+        const { id, classId } = input;
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        // Get the assignment with all related files
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id,
+                teacherId: ctx.user.id,
+            },
+            include: {
+                attachments: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                submissions: {
+                    include: {
+                        attachments: {
+                            include: {
+                                thumbnail: true
+                            }
+                        },
+                        annotations: {
+                            include: {
+                                thumbnail: true
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        // Delete all files from storage
+        const filesToDelete = [
+            ...assignment.attachments,
+            ...assignment.submissions.flatMap(sub => [...sub.attachments, ...sub.annotations])
+        ];
+        // Delete files from storage
+        await Promise.all(filesToDelete.map(async (file) => {
+            try {
+                // Delete the main file
+                await (0, googleCloudStorage_1.deleteFile)(file.path);
+                // Delete thumbnail if it exists
+                if (file.thumbnail) {
+                    await (0, googleCloudStorage_1.deleteFile)(file.thumbnail.path);
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to delete file ${file.path}:`, error);
+            }
+        }));
+        // Delete the assignment (this will cascade delete all related records)
+        await prisma_1.prisma.assignment.delete({
+            where: { id },
+        });
+        return {
+            id,
+        };
+    }),
+    get: trpc_1.protectedProcedure
+        .input(getAssignmentSchema)
+        .query(async ({ ctx, input }) => {
+        const { id, classId } = input;
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const assignment = await prisma_1.prisma.assignment.findUnique({
+            where: {
+                id,
+                // classId,
+            },
+            include: {
+                submissions: {
+                    select: {
+                        student: {
+                            select: {
+                                id: true,
+                                username: true
+                            }
+                        }
+                    }
+                },
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                        size: true,
+                        path: true,
+                        thumbnailId: true,
+                    }
+                },
+                section: {
+                    select: {
+                        id: true,
+                        name: true,
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                },
+                class: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                eventAttached: {
+                    select: {
+                        id: true,
+                        name: true,
+                        startTime: true,
+                        endTime: true,
+                        location: true,
+                        remarks: true,
+                    }
+                },
+                markScheme: {
+                    select: {
+                        id: true,
+                        structured: true,
+                    }
+                },
+                gradingBoundary: {
+                    select: {
+                        id: true,
+                        structured: true,
+                    }
+                }
+            }
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        const sections = await prisma_1.prisma.section.findMany({
+            where: {
+                classId: assignment.classId,
+            },
+            select: {
+                id: true,
+                name: true,
+            },
+        });
+        return { ...assignment, sections };
+    }),
+    getSubmission: trpc_1.protectedClassMemberProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { assignmentId } = input;
+        const submission = await prisma_1.prisma.submission.findFirst({
+            where: {
+                assignmentId,
+                studentId: ctx.user.id,
+            },
+            include: {
+                attachments: true,
+                student: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+                annotations: true,
+            },
+        });
+        if (!submission) {
+            // Create a new submission if it doesn't exist
+            return await prisma_1.prisma.submission.create({
+                data: {
+                    assignment: {
+                        connect: { id: assignmentId },
+                    },
+                    student: {
+                        connect: { id: ctx.user.id },
+                    },
+                },
+                include: {
+                    attachments: true,
+                    annotations: true,
+                    student: {
+                        select: {
+                            id: true,
+                            username: true,
+                        },
+                    },
+                    assignment: {
+                        include: {
+                            class: true,
+                            markScheme: {
+                                select: {
+                                    id: true,
+                                    structured: true,
+                                }
+                            },
+                            gradingBoundary: {
+                                select: {
+                                    id: true,
+                                    structured: true,
+                                }
+                            }
+                        },
+                    },
+                },
+            });
+        }
+        return {
+            ...submission,
+            late: submission.assignment.dueDate < new Date(),
+        };
+    }),
+    getSubmissionById: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        submissionId: zod_1.z.string(),
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { submissionId, classId } = input;
+        const submission = await prisma_1.prisma.submission.findFirst({
+            where: {
+                id: submissionId,
+                assignment: {
+                    classId,
+                    class: {
+                        teachers: {
+                            some: {
+                                id: ctx.user.id
+                            }
+                        }
+                    }
+                },
+            },
+            include: {
+                attachments: true,
+                annotations: true,
+                student: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+            },
+        });
+        if (!submission) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Submission not found",
+            });
+        }
+        return {
+            ...submission,
+            late: submission.assignment.dueDate < new Date(),
+        };
+    }),
+    updateSubmission: trpc_1.protectedClassMemberProcedure
+        .input(submissionSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { submissionId, submit, newAttachments, removedAttachments } = input;
+        const submission = await prisma_1.prisma.submission.findFirst({
+            where: {
+                id: submissionId,
+                OR: [
+                    {
+                        student: {
+                            id: ctx.user.id,
+                        },
+                    },
+                    {
+                        assignment: {
+                            class: {
+                                teachers: {
+                                    some: {
+                                        id: ctx.user.id,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+            include: {
+                attachments: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+            },
+        });
+        if (!submission) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Submission not found",
+            });
+        }
+        if (submit !== undefined) {
+            // Toggle submission status
+            return await prisma_1.prisma.submission.update({
+                where: { id: submission.id },
+                data: {
+                    submitted: !submission.submitted,
+                    submittedAt: new Date(),
+                },
+                include: {
+                    attachments: true,
+                    student: {
+                        select: {
+                            id: true,
+                            username: true,
+                        },
+                    },
+                    assignment: {
+                        include: {
+                            class: true,
+                            markScheme: {
+                                select: {
+                                    id: true,
+                                    structured: true,
+                                }
+                            },
+                            gradingBoundary: {
+                                select: {
+                                    id: true,
+                                    structured: true,
+                                }
+                            }
+                        },
+                    },
+                },
+            });
+        }
+        let uploadedFiles = [];
+        if (newAttachments && newAttachments.length > 0) {
+            // Store files in a class and assignment specific directory
+            uploadedFiles = await (0, fileUpload_1.uploadFiles)(newAttachments, ctx.user.id, `class/${submission.assignment.classId}/assignment/${submission.assignmentId}/submission/${submission.id}`);
+        }
+        // Update submission with new file attachments
+        if (uploadedFiles.length > 0) {
+            await prisma_1.prisma.submission.update({
+                where: { id: submission.id },
+                data: {
+                    attachments: {
+                        create: uploadedFiles.map(file => ({
+                            name: file.name,
+                            type: file.type,
+                            size: file.size,
+                            path: file.path,
+                            ...(file.thumbnailId && {
+                                thumbnail: {
+                                    connect: { id: file.thumbnailId }
+                                }
+                            })
+                        }))
+                    }
+                }
+            });
+        }
+        // Delete removed attachments if any
+        if (removedAttachments && removedAttachments.length > 0) {
+            const filesToDelete = submission.attachments.filter((file) => removedAttachments.includes(file.id));
+            // Delete files from storage
+            await Promise.all(filesToDelete.map(async (file) => {
+                try {
+                    // Delete the main file
+                    await (0, googleCloudStorage_1.deleteFile)(file.path);
+                    // Delete thumbnail if it exists
+                    if (file.thumbnail?.path) {
+                        await (0, googleCloudStorage_1.deleteFile)(file.thumbnail.path);
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to delete file ${file.path}:`, error);
+                }
+            }));
+        }
+        // Update submission with attachments
+        return await prisma_1.prisma.submission.update({
+            where: { id: submission.id },
+            data: {
+                ...(removedAttachments && removedAttachments.length > 0 && {
+                    attachments: {
+                        deleteMany: {
+                            id: { in: removedAttachments },
+                        },
+                    },
+                }),
+            },
+            include: {
+                attachments: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                student: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+            },
+        });
+    }),
+    getSubmissions: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+        classId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { assignmentId } = input;
+        const submissions = await prisma_1.prisma.submission.findMany({
+            where: {
+                assignment: {
+                    id: assignmentId,
+                    class: {
+                        teachers: {
+                            some: { id: ctx.user.id },
+                        },
+                    },
+                },
+            },
+            include: {
+                attachments: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                student: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+            },
+        });
+        return submissions.map(submission => ({
+            ...submission,
+            late: submission.assignment.dueDate < new Date(),
+        }));
+    }),
+    updateSubmissionAsTeacher: trpc_1.protectedTeacherProcedure
+        .input(updateSubmissionSchema)
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { submissionId, return: returnSubmission, gradeReceived, newAttachments, removedAttachments, rubricGrades } = input;
+        const submission = await prisma_1.prisma.submission.findFirst({
+            where: {
+                id: submissionId,
+                assignment: {
+                    class: {
+                        teachers: {
+                            some: { id: ctx.user.id },
+                        },
+                    },
+                },
+            },
+            include: {
+                attachments: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                annotations: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+            },
+        });
+        if (!submission) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Submission not found",
+            });
+        }
+        if (returnSubmission !== undefined) {
+            // Toggle return status
+            return await prisma_1.prisma.submission.update({
+                where: { id: submissionId },
+                data: {
+                    returned: !submission.returned,
+                },
+                include: {
+                    attachments: true,
+                    student: {
+                        select: {
+                            id: true,
+                            username: true,
+                        },
+                    },
+                    assignment: {
+                        include: {
+                            class: true,
+                            markScheme: {
+                                select: {
+                                    id: true,
+                                    structured: true,
+                                }
+                            },
+                            gradingBoundary: {
+                                select: {
+                                    id: true,
+                                    structured: true,
+                                }
+                            }
+                        },
+                    },
+                },
+            });
+        }
+        let uploadedFiles = [];
+        if (newAttachments && newAttachments.length > 0) {
+            // Store files in a class and assignment specific directory
+            uploadedFiles = await (0, fileUpload_1.uploadFiles)(newAttachments, ctx.user.id, `class/${submission.assignment.classId}/assignment/${submission.assignmentId}/submission/${submission.id}/annotations`);
+        }
+        // Update submission with new file attachments
+        if (uploadedFiles.length > 0) {
+            await prisma_1.prisma.submission.update({
+                where: { id: submission.id },
+                data: {
+                    annotations: {
+                        create: uploadedFiles.map(file => ({
+                            name: file.name,
+                            type: file.type,
+                            size: file.size,
+                            path: file.path,
+                            ...(file.thumbnailId && {
+                                thumbnail: {
+                                    connect: { id: file.thumbnailId }
+                                }
+                            })
+                        }))
+                    }
+                }
+            });
+        }
+        // Delete removed attachments if any
+        if (removedAttachments && removedAttachments.length > 0) {
+            const filesToDelete = submission.annotations.filter((file) => removedAttachments.includes(file.id));
+            // Delete files from storage
+            await Promise.all(filesToDelete.map(async (file) => {
+                try {
+                    // Delete the main file
+                    await (0, googleCloudStorage_1.deleteFile)(file.path);
+                    // Delete thumbnail if it exists
+                    if (file.thumbnail?.path) {
+                        await (0, googleCloudStorage_1.deleteFile)(file.thumbnail.path);
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to delete file ${file.path}:`, error);
+                }
+            }));
+        }
+        // Update submission with grade and attachments
+        return await prisma_1.prisma.submission.update({
+            where: { id: submissionId },
+            data: {
+                ...(gradeReceived !== undefined && { gradeReceived }),
+                ...(rubricGrades && { rubricState: JSON.stringify(rubricGrades) }),
+                ...(removedAttachments && removedAttachments.length > 0 && {
+                    annotations: {
+                        deleteMany: {
+                            id: { in: removedAttachments },
+                        },
+                    },
+                }),
+            },
+            include: {
+                attachments: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                annotations: {
+                    include: {
+                        thumbnail: true
+                    }
+                },
+                student: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+                assignment: {
+                    include: {
+                        class: true,
+                        markScheme: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        },
+                        gradingBoundary: {
+                            select: {
+                                id: true,
+                                structured: true,
+                            }
+                        }
+                    },
+                },
+            },
+        });
+    }),
+    attachToEvent: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+        eventId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { assignmentId, eventId } = input;
+        // Check if assignment exists and user is a teacher of the class
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+                class: {
+                    teachers: {
+                        some: { id: ctx.user.id },
+                    },
+                },
+            },
+            include: {
+                class: true,
+            },
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found or you are not authorized",
+            });
+        }
+        // Check if event exists and belongs to the same class
+        const event = await prisma_1.prisma.event.findFirst({
+            where: {
+                id: eventId,
+                classId: assignment.classId,
+            },
+        });
+        if (!event) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Event not found or does not belong to the same class",
+            });
+        }
+        // Attach assignment to event
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: assignmentId },
+            data: {
+                eventAttached: {
+                    connect: { id: eventId }
+                }
+            },
+            include: {
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                    }
+                },
+                section: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                },
+                eventAttached: {
+                    select: {
+                        id: true,
+                        name: true,
+                        startTime: true,
+                        endTime: true,
+                    }
+                }
+            }
+        });
+        return { assignment: updatedAssignment };
+    }),
+    detachEvent: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { assignmentId } = input;
+        // Check if assignment exists and user is a teacher of the class
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+                class: {
+                    teachers: {
+                        some: { id: ctx.user.id },
+                    },
+                },
+            },
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found or you are not authorized",
+            });
+        }
+        // Detach assignment from event
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: assignmentId },
+            data: {
+                eventAttached: {
+                    disconnect: true
+                }
+            },
+            include: {
+                attachments: {
+                    select: {
+                        id: true,
+                        name: true,
+                        type: true,
+                    }
+                },
+                section: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                teacher: {
+                    select: {
+                        id: true,
+                        username: true
+                    }
+                },
+                eventAttached: {
+                    select: {
+                        id: true,
+                        name: true,
+                        startTime: true,
+                        endTime: true,
+                    }
+                }
+            }
+        });
+        return { assignment: updatedAssignment };
+    }),
+    getAvailableEvents: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const { assignmentId } = input;
+        // Get the assignment to find the class
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+                class: {
+                    teachers: {
+                        some: { id: ctx.user.id },
+                    },
+                },
+            },
+            select: { classId: true }
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found or you are not authorized",
+            });
+        }
+        // Get all events for the class that don't already have this assignment attached
+        const events = await prisma_1.prisma.event.findMany({
+            where: {
+                classId: assignment.classId,
+                assignmentsAttached: {
+                    none: {
+                        id: assignmentId
+                    }
+                }
+            },
+            select: {
+                id: true,
+                name: true,
+                startTime: true,
+                endTime: true,
+                location: true,
+                remarks: true,
+            },
+            orderBy: {
+                startTime: 'asc'
+            }
+        });
+        return { events };
+    }),
+    dueToday: trpc_1.protectedProcedure
+        .query(async ({ ctx }) => {
+        if (!ctx.user) {
+            throw new server_1.TRPCError({
+                code: "UNAUTHORIZED",
+                message: "User must be authenticated",
+            });
+        }
+        const assignments = await prisma_1.prisma.assignment.findMany({
+            where: {
+                dueDate: {
+                    equals: new Date(),
+                },
+            },
+            select: {
+                id: true,
+                title: true,
+                dueDate: true,
+                type: true,
+                graded: true,
+                maxGrade: true,
+                class: {
+                    select: {
+                        id: true,
+                        name: true,
+                    }
+                }
+            }
+        });
+        return assignments.map(assignment => ({
+            ...assignment,
+            dueDate: assignment.dueDate.toISOString(),
+        }));
+    }),
+    attachMarkScheme: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+        markSchemeId: zod_1.z.string().nullable(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { assignmentId, markSchemeId } = input;
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+            },
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        // If markSchemeId is provided, verify it exists
+        if (markSchemeId) {
+            const markScheme = await prisma_1.prisma.markScheme.findFirst({
+                where: {
+                    id: markSchemeId,
+                },
+            });
+            if (!markScheme) {
+                throw new server_1.TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Mark scheme not found",
+                });
+            }
+        }
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: assignmentId },
+            data: {
+                markScheme: markSchemeId ? {
+                    connect: { id: markSchemeId },
+                } : {
+                    disconnect: true,
+                },
+            },
+            include: {
+                attachments: true,
+                section: true,
+                teacher: true,
+                eventAttached: true,
+                markScheme: true,
+            },
+        });
+        return updatedAssignment;
+    }),
+    detachMarkScheme: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { assignmentId } = input;
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+            },
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: assignmentId },
+            data: {
+                markScheme: {
+                    disconnect: true,
+                },
+            },
+            include: {
+                attachments: true,
+                section: true,
+                teacher: true,
+                eventAttached: true,
+                markScheme: true,
+            },
+        });
+        return updatedAssignment;
+    }),
+    attachGradingBoundary: trpc_1.protectedTeacherProcedure
+        .input(zod_1.z.object({
+        assignmentId: zod_1.z.string(),
+        gradingBoundaryId: zod_1.z.string().nullable(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { assignmentId, gradingBoundaryId } = input;
+        const assignment = await prisma_1.prisma.assignment.findFirst({
+            where: {
+                id: assignmentId,
+            },
+        });
+        if (!assignment) {
+            throw new server_1.TRPCError({
+                code: "NOT_FOUND",
+                message: "Assignment not found",
+            });
+        }
+        // If gradingBoundaryId is provided, verify it exists
+        if (gradingBoundaryId) {
+            const gradingBoundary = await prisma_1.prisma.gradingBoundary.findFirst({
+                where: {
+                    id: gradingBoundaryId,
+                },
+            });
+            if (!gradingBoundary) {
+                throw new server_1.TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Grading boundary not found",
+                });
+            }
+        }
+        const updatedAssignment = await prisma_1.prisma.assignment.update({
+            where: { id: assignmentId },
+            data: {
+                gradingBoundary: gradingBoundaryId ? {
+                    connect: { id: gradingBoundaryId },
+                } : {
+                    disconnect: true,
+                },
+            },
+            include: {
+                attachments: true,
+                section: true,
+                teacher: true,
+                eventAttached: true,
+                gradingBoundary: true,
+            },
+        });
+        return updatedAssignment;
+    }),
+});