@studious-lms/server 1.1.26 → 1.2.6

package/src/routers/assignment.ts

@@ -4,8 +4,31 @@ import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { createDirectUploadFiles, type DirectUploadFile, confirmDirectUpload, updateUploadProgress, type UploadedFile } from "../lib/fileUpload.js";
 import { deleteFile } from "../lib/googleCloudStorage.js";
-import { sendNotifications } from "../lib/notificationHandler.js";
 import { logger } from "../utils/logger.js";
+import { gradeWorksheetPipeline } from "../pipelines/gradeWorksheet.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";
+import { sendToMultiple } from "../services/notification.js";
 
 // DEPRECATED: This schema is no longer used - files are uploaded directly to GCS
 // Use directFileSchema instead
@@ -20,11 +43,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(),
@@ -42,6 +73,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(),
@@ -68,6 +106,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(),
 });
@@ -132,1869 +171,151 @@ const updateUploadProgressSchema = z.object({
   progress: z.number().min(0).max(100),
 });
 
-// Helper function to get unified list of sections and assignments for a class
-async function getUnifiedList(tx: any, classId: string) {
-  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: any) => ({ id: s.id, order: s.order, type: 'section' as const })),
-    ...assignments.map((a: any) => ({ id: a.id, order: a.order, type: 'assignment' as const })),
-  ].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: any, classId: string, orderedItems: Array<{ id: string; type: 'section' | 'assignment' }>) {
-  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: Array<{ id: string; type: 'section' | 'assignment' }> = [];
-
-        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;
-    }),
-
-    move: protectedTeacherProcedure
+    .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: number, criterion: any) => {
-          const maxPoints = Math.max(...criterion.levels.map((level: any) => 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' as const }, ...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: UploadedFile[] = [];
-      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: UploadedFile[] = [];
-      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: number, criterion: any) => {
-          const maxPoints = Math.max(...criterion.levels.map((level: any) => 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
-                }
-              }
-            }
-          }
-        }
-      });
+    .mutation(({ ctx, input }) =>
+      deleteAssignmentRecord(ctx.user!.id, input.id, input.classId)
+    ),
 
-      if (!assignment) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Assignment not found",
-        });
-      }
+  get: protectedClassMemberProcedure
+    .input(getAssignmentSchema)
+    .query(({ input }) => getAssignment(input.id, input.classId)),
 
-      // 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 },
-      });
+  getSubmission: protectedClassMemberProcedure
+    .input(z.object({ assignmentId: z.string(), classId: z.string() }))
+    .query(({ ctx, input }) =>
+      getSubmission(input.assignmentId, ctx.user!.id)
+    ),
 
-      return {
-        id,
-      };
-    }),
+  getSubmissionById: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string(), submissionId: z.string() }))
+    .query(({ ctx, input }) =>
+      getSubmissionById(input.submissionId, input.classId, ctx.user!.id)
+    ),
 
-  get: protectedProcedure
-    .input(getAssignmentSchema)
-    .query(async ({ ctx, input }) => {
-      const { id, classId } = input;
+  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,
+      })
+    ),
 
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
+  getSubmissions: protectedTeacherProcedure
+    .input(z.object({ assignmentId: z.string(), classId: z.string() }))
+    .query(({ ctx, input }) => getSubmissions(input.assignmentId, ctx.user!.id)),
 
-      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,
-            }
-          }
-        }
-      });
+  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,
+      })
+    ),
 
-      if (!assignment) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Assignment not found",
-        });
-      }
+  attachToEvent: protectedTeacherProcedure
+    .input(z.object({ assignmentId: z.string(), eventId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      attachAssignmentToEventRecord(ctx.user!.id, input.assignmentId, input.eventId)
+    ),
 
-      const sections = await prisma.section.findMany({
-        where: {
-          classId: assignment.classId,
-        },
-        select: {
-          id: true,
-          name: true,
-        },
-      });
+  detachEvent: protectedTeacherProcedure
+    .input(z.object({ assignmentId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      detachAssignmentFromEventRecord(ctx.user!.id, input.assignmentId)
+    ),
 
-      return { ...assignment, sections };
-    }),
+  getAvailableEvents: protectedTeacherProcedure
+    .input(z.object({ assignmentId: z.string() }))
+    .query(({ ctx, input }) =>
+      getAvailableEventsForAssignment(ctx.user!.id, input.assignmentId)
+    ),
 
-  getSubmission: protectedClassMemberProcedure
+  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
-    .input(z.object({
-      submissionId: z.string(),
-      classId: z.string(),
-    }))
-    .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: UploadedFile[] = [];
-      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 as unknown as boolean && { 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;
-    }),
+    .mutation(({ ctx, input }) =>
+      attachMarkSchemeRecord(ctx.user!.id, input.assignmentId, input.markSchemeId)
+    ),
   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;
-    }),
+    .input(z.object({ assignmentId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      detachMarkSchemeRecord(ctx.user!.id, input.assignmentId)
+    ),
   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