@studious-lms/server 1.1.26 → 1.2.6

package/dist/routers/assignment.js

@@ -1,11 +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 { sendNotifications } from "../lib/notificationHandler.js";
-import { logger } from "../utils/logger.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)
@@ -17,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(),
@@ -38,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(),
@@ -61,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(),
 });
@@ -116,1717 +132,110 @@ const updateUploadProgressSchema = z.object({
     fileId: z.string(),
     progress: z.number().min(0).max(100),
 });
-// Helper function to get unified list of sections and assignments for a class
-async function getUnifiedList(tx, classId) {
-    const [sections, assignments] = await Promise.all([
-        tx.section.findMany({
-            where: { classId },
-            select: { id: true, order: true },
-        }),
-        tx.assignment.findMany({
-            where: { classId },
-            select: { id: true, order: true },
-        }),
-    ]);
-    // Combine and sort by order
-    const unified = [
-        ...sections.map((s) => ({ id: s.id, order: s.order, type: 'section' })),
-        ...assignments.map((a) => ({ id: a.id, order: a.order, type: 'assignment' })),
-    ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-    return unified;
-}
-// Helper function to normalize unified list to 1..n
-async function normalizeUnifiedList(tx, classId, orderedItems) {
-    await Promise.all(orderedItems.map((item, index) => {
-        if (item.type === 'section') {
-            return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-        }
-        else {
-            return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-        }
-    }));
-}
 export const assignmentRouter = createTRPCRouter({
-    // Reorder an assignment within the unified list (sections + assignments)
     reorder: protectedTeacherProcedure
         .input(z.object({
         classId: z.string(),
         movedId: z.string(),
-        // One of: place at start/end of unified list, or relative to targetId (can be section or assignment)
         position: z.enum(['start', 'end', 'before', 'after']),
-        targetId: z.string().optional(), // Can be a section ID or assignment ID
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const { classId, movedId, position, targetId } = input;
-        const moved = await prisma.assignment.findFirst({
-            where: { id: movedId, classId },
-            select: { id: true, classId: true },
-        });
-        if (!moved) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found' });
-        }
-        if ((position === 'before' || position === 'after') && !targetId) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId required for before/after' });
-        }
-        const result = await prisma.$transaction(async (tx) => {
-            const unified = await getUnifiedList(tx, classId);
-            // Find moved item and target in unified list
-            const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'assignment');
-            if (movedIdx === -1) {
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found in unified list' });
-            }
-            // Build list without moved item
-            const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'assignment'));
-            let next = [];
-            if (position === 'start') {
-                next = [{ id: movedId, type: 'assignment' }, ...withoutMoved.map(item => ({ id: item.id, type: item.type }))];
-            }
-            else if (position === 'end') {
-                next = [...withoutMoved.map(item => ({ id: item.id, type: item.type })), { id: movedId, type: 'assignment' }];
-            }
-            else {
-                const targetIdx = withoutMoved.findIndex(item => item.id === targetId);
-                if (targetIdx === -1) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId not found in unified list' });
-                }
-                if (position === 'before') {
-                    next = [
-                        ...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id, type: item.type })),
-                        { id: movedId, type: 'assignment' },
-                        ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id, type: item.type })),
-                    ];
-                }
-                else {
-                    next = [
-                        ...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-                        { id: movedId, type: 'assignment' },
-                        ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-                    ];
-                }
-            }
-            // Normalize to 1..n
-            await normalizeUnifiedList(tx, classId, next);
-            return tx.assignment.findUnique({ where: { id: movedId } });
-        });
-        return result;
-    }),
-    order: protectedTeacherProcedure
-        .input(z.object({
-        id: z.string(),
-        classId: z.string(),
-        order: z.number(),
+        targetId: z.string().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        // Deprecated: prefer `reorder`. For backward-compatibility, set the order then normalize unified list.
-        const { id, order } = input;
-        const current = await prisma.assignment.findUnique({
-            where: { id },
-            select: { id: true, classId: true },
-        });
-        if (!current) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found' });
-        }
-        const updated = await prisma.$transaction(async (tx) => {
-            await tx.assignment.update({ where: { id }, data: { order } });
-            // Normalize entire unified list
-            const unified = await getUnifiedList(tx, current.classId);
-            await normalizeUnifiedList(tx, current.classId, unified.map(item => ({ id: item.id, type: item.type })));
-            return tx.assignment.findUnique({ where: { id } });
-        });
-        return updated;
-    }),
+        .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().nullable().optional(),
     }))
-        .mutation(async ({ ctx, input }) => {
-        const { id } = input;
-        const targetSectionId = (input.targetSectionId ?? null) || null; // normalize empty string to null
-        const moved = await prisma.assignment.findUnique({
-            where: { id },
-            select: { id: true, classId: true, sectionId: true },
-        });
-        if (!moved) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Assignment not found' });
-        }
-        const updated = await prisma.$transaction(async (tx) => {
-            // Update sectionId first
-            await tx.assignment.update({ where: { id }, data: { sectionId: targetSectionId } });
-            // The unified list ordering remains the same, just the assignment's sectionId changed
-            // No need to reorder since we're keeping the same position in the unified list
-            // If frontend wants to change position, they should call reorder after move
-            return tx.assignment.findUnique({ where: { id } });
-        });
-        return updated;
-    }),
-    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);
-        // Create assignment and place at top of its scope within a single transaction
-        const teacherId = ctx.user.id;
-        const assignment = await prisma.$transaction(async (tx) => {
-            const created = await tx.assignment.create({
-                data: {
-                    title,
-                    instructions,
-                    dueDate: new Date(dueDate),
-                    maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
-                    graded,
-                    weight,
-                    type,
-                    order: 1,
-                    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: teacherId }
-                    }
-                },
-                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
-                        }
-                    }
-                }
-            });
-            // Insert new assignment at top of unified list and normalize
-            const unified = await getUnifiedList(tx, classId);
-            const withoutNew = unified.filter(item => !(item.id === created.id && item.type === 'assignment'));
-            const reindexed = [{ id: created.id, type: 'assignment' }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
-            await normalizeUnifiedList(tx, classId, reindexed);
-            return created;
-        });
-        // 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 }))
-                    }
-                }
-            });
-        }
-        sendNotifications(classData.students.map(student => student.id), {
-            title: `🔔 New assignment for ${classData.name}`,
-            content: `The assignment "${title}" has been created in ${classData.name}.\n
-        Due date: ${new Date(dueDate).toLocaleDateString()}.
-        [Link to assignment](/class/${classId}/assignments/${assignment.id})`
-        }).catch(error => {
-            logger.error('Failed to send assignment notifications:');
-        });
-        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,
-                        uploadStatus: 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);
-        }
-        // Delete removed attachments from storage before updating database
-        if (input.removedAttachments && input.removedAttachments.length > 0) {
-            const filesToDelete = assignment.attachments.filter((file) => input.removedAttachments.includes(file.id));
-            // Delete files from storage (only if they were actually uploaded)
-            await Promise.all(filesToDelete.map(async (file) => {
-                try {
-                    // Only delete from GCS if the file was successfully uploaded
-                    if (file.uploadStatus === 'COMPLETED') {
-                        // 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 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 (only if they were actually uploaded)
-        await Promise.all(filesToDelete.map(async (file) => {
-            try {
-                // Only delete from GCS if the file was successfully uploaded
-                if (file.uploadStatus === 'COMPLETED') {
-                    // 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,
-                        profile: 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: 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 (only if they were actually uploaded)
-            await Promise.all(filesToDelete.map(async (file) => {
-                try {
-                    // Only delete from GCS if the file was successfully uploaded
-                    if (file.uploadStatus === 'COMPLETED') {
-                        // 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 (only if they were actually uploaded)
-            await Promise.all(filesToDelete.map(async (file) => {
-                try {
-                    // Only delete from GCS if the file was successfully uploaded
-                    if (file.uploadStatus === 'COMPLETED') {
-                        // 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)
@@ -2108,3 +517,5 @@ export const assignmentRouter = createTRPCRouter({
         };
     }),
 });
+//# sourceMappingURL=assignment.js.map
+//# debugId=6ca6683e-2a89-5dab-a4c5-bf0292654572