@studious-lms/server 1.1.24 → 1.2.6

package/dist/routers/assignment.js

@@ -1,9 +1,11 @@
+
+!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]="6ca6683e-2a89-5dab-a4c5-bf0292654572")}catch(e){}}();
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure, protectedClassMemberProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { createDirectUploadFiles, confirmDirectUpload, updateUploadProgress } from "../lib/fileUpload.js";
-import { deleteFile } from "../lib/googleCloudStorage.js";
+import { assignmentExists, getDueToday, getAssignment, getSubmission, getSubmissionById, getSubmissions, createAssignmentRecord, updateAssignmentRecord, deleteAssignmentRecord, updateSubmissionRecord, updateSubmissionAsTeacherRecord, attachAssignmentToEventRecord, detachAssignmentFromEventRecord, getAvailableEventsForAssignment, attachMarkSchemeRecord, detachMarkSchemeRecord, attachGradingBoundaryRecord, detachGradingBoundaryRecord, reorderAssignmentRecord, moveAssignmentRecord, } from "../services/assignment.js";
 // DEPRECATED: This schema is no longer used - files are uploaded directly to GCS
 // Use directFileSchema instead
 // New schema for direct file uploads (no base64 data)
@@ -15,11 +17,19 @@ const directFileSchema = z.object({
 });
 const createAssignmentSchema = z.object({
     classId: z.string(),
+    id: z.string().optional(),
     title: z.string(),
     instructions: z.string(),
     dueDate: z.string(),
     files: z.array(directFileSchema).optional(), // Use direct file schema
     existingFileIds: z.array(z.string()).optional(),
+    aiPolicyLevel: z.number().default(0),
+    acceptFiles: z.boolean().optional(),
+    acceptExtendedResponse: z.boolean().optional(),
+    acceptWorksheet: z.boolean().optional(),
+    worksheetIds: z.array(z.string()).optional(),
+    gradeWithAI: z.boolean().optional(),
+    studentIds: z.array(z.string()).optional(),
     maxGrade: z.number().optional(),
     graded: z.boolean().optional(),
     weight: z.number().optional(),
@@ -36,6 +46,13 @@ const updateAssignmentSchema = z.object({
     instructions: z.string().optional(),
     dueDate: z.string().optional(),
     files: z.array(directFileSchema).optional(), // Use direct file schema
+    aiPolicyLevel: z.number().default(0),
+    acceptFiles: z.boolean().optional(),
+    acceptExtendedResponse: z.boolean().optional(),
+    acceptWorksheet: z.boolean().optional(),
+    worksheetIds: z.array(z.string()).optional(),
+    gradeWithAI: z.boolean().optional(),
+    studentIds: z.array(z.string()).optional(),
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
     maxGrade: z.number().optional(),
@@ -59,6 +76,7 @@ const submissionSchema = z.object({
     submissionId: z.string(),
     submit: z.boolean().optional(),
     newAttachments: z.array(directFileSchema).optional(), // Use direct file schema
+    extendedResponse: z.string().optional(),
     existingFileIds: z.array(z.string()).optional(),
     removedAttachments: z.array(z.string()).optional(),
 });
@@ -115,1584 +133,109 @@ const updateUploadProgressSchema = z.object({
     progress: z.number().min(0).max(100),
 });
 export const assignmentRouter = createTRPCRouter({
-    order: protectedTeacherProcedure
+    reorder: protectedTeacherProcedure
         .input(z.object({
-        id: z.string(),
         classId: z.string(),
-        order: z.number(),
+        movedId: z.string(),
+        position: z.enum(['start', 'end', 'before', 'after']),
+        targetId: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { id, order } = input;
-        const assignment = await prisma.assignment.update({
-            where: { id },
-            data: { order },
-        });
-        return assignment;
-    }),
+        .mutation(({ ctx, input }) => reorderAssignmentRecord(ctx.user.id, {
+        classId: input.classId,
+        movedId: input.movedId,
+        position: input.position,
+        targetId: input.targetId,
+    })),
+    exists: protectedClassMemberProcedure
+        .input(z.object({ id: z.string() }))
+        .query(({ input }) => assignmentExists(input.id)),
     move: protectedTeacherProcedure
         .input(z.object({
         id: z.string(),
         classId: z.string(),
-        targetSectionId: z.string(),
+        targetSectionId: z.string().nullable().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { id, targetSectionId } = input;
-        const assignments = await prisma.assignment.findMany({
-            where: { sectionId: targetSectionId },
-        });
-        const stack = assignments.sort((a, b) => (a.order || 0) - (b.order || 0)).map((assignment, index) => ({
-            id: assignment.id,
-            order: index + 1,
-        })).map((assignment) => ({
-            where: { id: assignment.id },
-            data: { order: assignment.order },
-        }));
-        await Promise.all(stack.map(({ where, data }) => prisma.assignment.update({ where, data })));
-        const assignment = await prisma.assignment.update({
-            where: { id },
-            data: { sectionId: targetSectionId, order: 0 },
-        });
-        return assignment;
-    }),
-    create: protectedProcedure
+        .mutation(({ ctx, input }) => moveAssignmentRecord(ctx.user.id, {
+        id: input.id,
+        classId: input.classId,
+        targetSectionId: (input.targetSectionId ?? null) || null,
+    })),
+    create: protectedTeacherProcedure
         .input(createAssignmentSchema)
-        .mutation(async ({ ctx, input }) => {
-        const { classId, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Get all students in the class
-        const classData = await prisma.class.findUnique({
-            where: { id: classId },
-            include: {
-                students: {
-                    select: { id: true }
-                }
-            }
-        });
-        if (!classData) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Class not found",
-            });
-        }
-        let computedMaxGrade = maxGrade;
-        if (markSchemeId) {
-            const rubric = await prisma.markScheme.findUnique({
-                where: { id: markSchemeId },
-                select: {
-                    structured: true,
-                }
-            });
-            const parsedRubric = JSON.parse(rubric?.structured || "{}");
-            // Calculate max grade from rubric criteria levels
-            computedMaxGrade = parsedRubric.criteria.reduce((acc, criterion) => {
-                const maxPoints = Math.max(...criterion.levels.map((level) => level.points));
-                return acc + maxPoints;
-            }, 0);
-        }
-        console.log(markSchemeId, gradingBoundaryId);
-        // find all assignments in the section it is in (or none) and reorder them
-        const assignments = await prisma.assignment.findMany({
-            where: {
-                classId: classId,
-                ...(sectionId && {
-                    sectionId: sectionId,
-                }),
-            },
-        });
-        const stack = assignments.sort((a, b) => (a.order || 0) - (b.order || 0)).map((assignment, index) => ({
-            id: assignment.id,
-            order: index + 1,
-        })).map((assignment) => ({
-            where: { id: assignment.id },
-            data: { order: assignment.order },
-        }));
-        // Create assignment with submissions for all students
-        const assignment = await prisma.assignment.create({
-            data: {
-                title,
-                instructions,
-                dueDate: new Date(dueDate),
-                maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
-                graded,
-                weight,
-                type,
-                order: 0,
-                inProgress: inProgress || false,
-                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
-                    }
-                }
-            }
-        });
-        await Promise.all(stack.map(({ where, data }) => prisma.assignment.update({ where, data })));
-        // NOTE: Files are now handled via direct upload endpoints
-        // The files field in the schema is for metadata only
-        // Actual file uploads should use getAssignmentUploadUrls endpoint
-        let uploadedFiles = [];
-        if (files && files.length > 0) {
-            // Create direct upload files instead of processing base64
-            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, assignment.id);
-        }
-        // Update assignment with new file attachments
-        if (uploadedFiles.length > 0) {
-            await 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 }
-                                }
-                            })
-                        }))
-                    }
-                }
-            });
-        }
-        // Connect existing files if provided
-        if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.assignment.update({
-                where: { id: assignment.id },
-                data: {
-                    attachments: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }
-            });
-        }
-        return assignment;
-    }),
-    update: protectedProcedure
+        .mutation(({ ctx, input }) => createAssignmentRecord(ctx.user.id, input)),
+    update: protectedTeacherProcedure
         .input(updateAssignmentSchema)
-        .mutation(async ({ ctx, input }) => {
-        const { id, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, inProgress } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Get the assignment with current attachments
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id,
-                teacherId: ctx.user.id,
-            },
-            include: {
-                attachments: {
-                    select: {
-                        id: true,
-                        name: true,
-                        type: true,
-                        path: true,
-                        size: true,
-                        thumbnail: {
-                            select: {
-                                path: true
-                            }
-                        }
-                    },
-                },
-                class: {
-                    select: {
-                        id: true,
-                        name: true
-                    }
-                },
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // NOTE: Files are now handled via direct upload endpoints
-        let uploadedFiles = [];
-        if (files && files.length > 0) {
-            // Create direct upload files instead of processing base64
-            uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, input.id);
-        }
-        // Update assignment
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id },
-            data: {
-                ...(title && { title }),
-                ...(instructions && { instructions }),
-                ...(dueDate && { dueDate: new Date(dueDate) }),
-                ...(maxGrade && { maxGrade }),
-                ...(graded !== undefined && { graded }),
-                ...(weight && { weight }),
-                ...(type && { type }),
-                ...(inProgress !== undefined && { inProgress }),
-                ...(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 }
-                                }
-                            })
-                        }))
-                    }
-                }),
-                ...(existingFileIds && existingFileIds.length > 0 && {
-                    attachments: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }),
-                ...(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,
-                        size: true,
-                        path: true,
-                        uploadedAt: true,
-                        thumbnailId: true,
-                    }
-                },
-                section: true,
-                teacher: true,
-                class: true
-            }
-        });
-        if (assignment.markSchemeId) {
-            const rubric = await 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.assignment.update({
-                where: { id },
-                data: {
-                    maxGrade: computedMaxGrade,
-                }
-            });
-        }
-        return updatedAssignment;
-    }),
+        .mutation(({ ctx, input }) => updateAssignmentRecord(ctx.user.id, input)),
     delete: protectedProcedure
         .input(deleteAssignmentSchema)
-        .mutation(async ({ ctx, input }) => {
-        const { id, classId } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        // Get the assignment with all related files
-        const assignment = await 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 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 deleteFile(file.path);
-                // Delete thumbnail if it exists
-                if (file.thumbnail) {
-                    await 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.assignment.delete({
-            where: { id },
-        });
-        return {
-            id,
-        };
-    }),
-    get: protectedProcedure
+        .mutation(({ ctx, input }) => deleteAssignmentRecord(ctx.user.id, input.id, input.classId)),
+    get: protectedClassMemberProcedure
         .input(getAssignmentSchema)
-        .query(async ({ ctx, input }) => {
-        const { id, classId } = input;
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const assignment = await 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,
-                        uploadedAt: 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 TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        const sections = await prisma.section.findMany({
-            where: {
-                classId: assignment.classId,
-            },
-            select: {
-                id: true,
-                name: true,
-            },
-        });
-        return { ...assignment, sections };
-    }),
+        .query(({ input }) => getAssignment(input.id, input.classId)),
     getSubmission: protectedClassMemberProcedure
+        .input(z.object({ assignmentId: z.string(), classId: z.string() }))
+        .query(({ ctx, input }) => getSubmission(input.assignmentId, ctx.user.id)),
+    getSubmissionById: protectedClassMemberProcedure
+        .input(z.object({ classId: z.string(), submissionId: z.string() }))
+        .query(({ ctx, input }) => getSubmissionById(input.submissionId, input.classId, ctx.user.id)),
+    updateSubmission: protectedClassMemberProcedure
+        .input(submissionSchema)
+        .mutation(({ ctx, input }) => updateSubmissionRecord(ctx.user.id, {
+        submissionId: input.submissionId,
+        assignmentId: input.assignmentId,
+        classId: input.classId,
+        submit: input.submit,
+        newAttachments: input.newAttachments,
+        extendedResponse: input.extendedResponse,
+        existingFileIds: input.existingFileIds,
+        removedAttachments: input.removedAttachments,
+    })),
+    getSubmissions: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string(), classId: z.string() }))
+        .query(({ ctx, input }) => getSubmissions(input.assignmentId, ctx.user.id)),
+    updateSubmissionAsTeacher: protectedTeacherProcedure
+        .input(updateSubmissionSchema)
+        .mutation(({ ctx, input }) => updateSubmissionAsTeacherRecord(ctx.user.id, {
+        submissionId: input.submissionId,
+        assignmentId: input.assignmentId,
+        classId: input.classId,
+        return: input.return,
+        gradeReceived: input.gradeReceived,
+        newAttachments: input.newAttachments,
+        existingFileIds: input.existingFileIds,
+        removedAttachments: input.removedAttachments,
+        rubricGrades: input.rubricGrades,
+        feedback: input.feedback,
+    })),
+    attachToEvent: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string(), eventId: z.string() }))
+        .mutation(({ ctx, input }) => attachAssignmentToEventRecord(ctx.user.id, input.assignmentId, input.eventId)),
+    detachEvent: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string() }))
+        .mutation(({ ctx, input }) => detachAssignmentFromEventRecord(ctx.user.id, input.assignmentId)),
+    getAvailableEvents: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string() }))
+        .query(({ ctx, input }) => getAvailableEventsForAssignment(ctx.user.id, input.assignmentId)),
+    dueToday: protectedProcedure
+        .query(() => getDueToday()),
+    attachMarkScheme: protectedTeacherProcedure
         .input(z.object({
         assignmentId: z.string(),
-        classId: z.string(),
+        markSchemeId: z.string().nullable(),
     }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        const submission = await 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.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: protectedTeacherProcedure
+        .mutation(({ ctx, input }) => attachMarkSchemeRecord(ctx.user.id, input.assignmentId, input.markSchemeId)),
+    detachMarkScheme: protectedTeacherProcedure
+        .input(z.object({ assignmentId: z.string() }))
+        .mutation(({ ctx, input }) => detachMarkSchemeRecord(ctx.user.id, input.assignmentId)),
+    attachGradingBoundary: protectedTeacherProcedure
         .input(z.object({
-        submissionId: z.string(),
-        classId: z.string(),
+        assignmentId: z.string(),
+        gradingBoundaryId: z.string().nullable(),
     }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { submissionId, classId } = input;
-        const submission = await 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,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                            }
-                        }
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-        if (!submission) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Submission not found",
-            });
-        }
-        return {
-            ...submission,
-            late: submission.assignment.dueDate < new Date(),
-        };
-    }),
-    updateSubmission: protectedClassMemberProcedure
-        .input(submissionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { submissionId, submit, newAttachments, existingFileIds, removedAttachments } = input;
-        const submission = await 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 TRPCError({
-                code: "NOT_FOUND",
-                message: "Submission not found",
-            });
-        }
-        if (submit !== undefined) {
-            // Toggle submission status
-            return await 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 createDirectUploadFiles(newAttachments, ctx.user.id, undefined, undefined, submission.id);
-        }
-        // Update submission with new file attachments
-        if (uploadedFiles.length > 0) {
-            await 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 }
-                                }
-                            })
-                        }))
-                    }
-                }
-            });
-        }
-        // Connect existing files if provided
-        if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.submission.update({
-                where: { id: submission.id },
-                data: {
-                    attachments: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }
-            });
-        }
-        // 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 deleteFile(file.path);
-                    // Delete thumbnail if it exists
-                    if (file.thumbnail?.path) {
-                        await deleteFile(file.thumbnail.path);
-                    }
-                }
-                catch (error) {
-                    console.warn(`Failed to delete file ${file.path}:`, error);
-                }
-            }));
-        }
-        // Update submission with attachments
-        return await 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: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        classId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        const submissions = await 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,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                                profilePictureThumbnail: 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: protectedTeacherProcedure
-        .input(updateSubmissionSchema)
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { submissionId, return: returnSubmission, gradeReceived, newAttachments, existingFileIds, removedAttachments, rubricGrades, feedback } = input;
-        const submission = await 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 TRPCError({
-                code: "NOT_FOUND",
-                message: "Submission not found",
-            });
-        }
-        if (returnSubmission !== undefined) {
-            // Toggle return status
-            return await prisma.submission.update({
-                where: { id: submissionId },
-                data: {
-                    returned: !submission.returned,
-                },
-                include: {
-                    attachments: true,
-                    student: {
-                        select: {
-                            id: true,
-                            username: true,
-                            profile: {
-                                select: {
-                                    displayName: true,
-                                    profilePicture: true,
-                                    profilePictureThumbnail: true,
-                                },
-                            },
-                        },
-                    },
-                    assignment: {
-                        include: {
-                            class: true,
-                            markScheme: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            },
-                            gradingBoundary: {
-                                select: {
-                                    id: true,
-                                    structured: true,
-                                }
-                            }
-                        },
-                    },
-                },
-            });
-        }
-        // NOTE: Teacher annotation files are now handled via direct upload endpoints
-        // Use getAnnotationUploadUrls and confirmAnnotationUpload endpoints instead
-        // The newAttachments field is deprecated for annotations
-        if (newAttachments && newAttachments.length > 0) {
-            throw new TRPCError({
-                code: "BAD_REQUEST",
-                message: "Direct file upload is deprecated. Use getAnnotationUploadUrls endpoint instead.",
-            });
-        }
-        // Connect existing files if provided
-        if (existingFileIds && existingFileIds.length > 0) {
-            await prisma.submission.update({
-                where: { id: submission.id },
-                data: {
-                    annotations: {
-                        connect: existingFileIds.map(fileId => ({ id: fileId }))
-                    }
-                }
-            });
-        }
-        // 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 deleteFile(file.path);
-                    // Delete thumbnail if it exists
-                    if (file.thumbnail?.path) {
-                        await deleteFile(file.thumbnail.path);
-                    }
-                }
-                catch (error) {
-                    console.warn(`Failed to delete file ${file.path}:`, error);
-                }
-            }));
-        }
-        // Update submission with grade and attachments
-        return await prisma.submission.update({
-            where: { id: submissionId },
-            data: {
-                ...(gradeReceived !== undefined && { gradeReceived }),
-                ...(rubricGrades && { rubricState: JSON.stringify(rubricGrades) }),
-                ...(feedback && { teacherComments: feedback }),
-                ...(removedAttachments && removedAttachments.length > 0 && {
-                    annotations: {
-                        deleteMany: {
-                            id: { in: removedAttachments },
-                        },
-                    },
-                }),
-                ...(returnSubmission && { returned: returnSubmission }),
-            },
-            include: {
-                attachments: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                annotations: {
-                    include: {
-                        thumbnail: true
-                    }
-                },
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                                profilePictureThumbnail: true,
-                            },
-                        },
-                    },
-                },
-                assignment: {
-                    include: {
-                        class: true,
-                        markScheme: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        },
-                        gradingBoundary: {
-                            select: {
-                                id: true,
-                                structured: true,
-                            }
-                        }
-                    },
-                },
-            },
-        });
-    }),
-    attachToEvent: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        eventId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new 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.assignment.findFirst({
-            where: {
-                id: assignmentId,
-                class: {
-                    teachers: {
-                        some: { id: ctx.user.id },
-                    },
-                },
-            },
-            include: {
-                class: true,
-            },
-        });
-        if (!assignment) {
-            throw new 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.event.findFirst({
-            where: {
-                id: eventId,
-                classId: assignment.classId,
-            },
-        });
-        if (!event) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Event not found or does not belong to the same class",
-            });
-        }
-        // Attach assignment to event
-        const updatedAssignment = await 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: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new 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.assignment.findFirst({
-            where: {
-                id: assignmentId,
-                class: {
-                    teachers: {
-                        some: { id: ctx.user.id },
-                    },
-                },
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found or you are not authorized",
-            });
-        }
-        // Detach assignment from event
-        const updatedAssignment = await 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: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const { assignmentId } = input;
-        // Get the assignment to find the class
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-                class: {
-                    teachers: {
-                        some: { id: ctx.user.id },
-                    },
-                },
-            },
-            select: { classId: true }
-        });
-        if (!assignment) {
-            throw new 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.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: protectedProcedure
-        .query(async ({ ctx }) => {
-        if (!ctx.user) {
-            throw new TRPCError({
-                code: "UNAUTHORIZED",
-                message: "User must be authenticated",
-            });
-        }
-        const assignments = await 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: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        markSchemeId: z.string().nullable(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId, markSchemeId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // If markSchemeId is provided, verify it exists
-        if (markSchemeId) {
-            const markScheme = await prisma.markScheme.findFirst({
-                where: {
-                    id: markSchemeId,
-                },
-            });
-            if (!markScheme) {
-                throw new TRPCError({
-                    code: "NOT_FOUND",
-                    message: "Mark scheme not found",
-                });
-            }
-        }
-        const updatedAssignment = await 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: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                markScheme: {
-                    disconnect: true,
-                },
-            },
-            include: {
-                attachments: true,
-                section: true,
-                teacher: true,
-                eventAttached: true,
-                markScheme: true,
-            },
-        });
-        return updatedAssignment;
-    }),
-    attachGradingBoundary: protectedTeacherProcedure
-        .input(z.object({
-        assignmentId: z.string(),
-        gradingBoundaryId: z.string().nullable(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId, gradingBoundaryId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        // If gradingBoundaryId is provided, verify it exists
-        if (gradingBoundaryId) {
-            const gradingBoundary = await prisma.gradingBoundary.findFirst({
-                where: {
-                    id: gradingBoundaryId,
-                },
-            });
-            if (!gradingBoundary) {
-                throw new TRPCError({
-                    code: "NOT_FOUND",
-                    message: "Grading boundary not found",
-                });
-            }
-        }
-        const updatedAssignment = await 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;
-    }),
+        .mutation(({ ctx, input }) => attachGradingBoundaryRecord(ctx.user.id, input.assignmentId, input.gradingBoundaryId)),
     detachGradingBoundary: protectedTeacherProcedure
-        .input(z.object({
-        classId: z.string(),
-        assignmentId: z.string(),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { assignmentId } = input;
-        const assignment = await prisma.assignment.findFirst({
-            where: {
-                id: assignmentId,
-            },
-        });
-        if (!assignment) {
-            throw new TRPCError({
-                code: "NOT_FOUND",
-                message: "Assignment not found",
-            });
-        }
-        const updatedAssignment = await prisma.assignment.update({
-            where: { id: assignmentId },
-            data: {
-                gradingBoundary: {
-                    disconnect: true,
-                },
-            },
-            include: {
-                attachments: true,
-                section: true,
-                teacher: true,
-                eventAttached: true,
-                gradingBoundary: true,
-            },
-        });
-        return updatedAssignment;
-    }),
+        .input(z.object({ classId: z.string(), assignmentId: z.string() }))
+        .mutation(({ ctx, input }) => detachGradingBoundaryRecord(ctx.user.id, input.assignmentId)),
     // New direct upload endpoints
     getAssignmentUploadUrls: protectedTeacherProcedure
         .input(getAssignmentUploadUrlsSchema)
@@ -1974,3 +517,5 @@ export const assignmentRouter = createTRPCRouter({
         };
     }),
 });
+//# sourceMappingURL=assignment.js.map
+//# debugId=6ca6683e-2a89-5dab-a4c5-bf0292654572