@studious-lms/server 1.2.53 → 1.3.0

package/src/routers/assignment.ts

@@ -4,9 +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 "../server/pipelines/gradeWorksheet.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
@@ -149,2065 +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
-// Updated to batch updates to prevent timeouts with large lists
-async function normalizeUnifiedList(tx: any, classId: string, orderedItems: Array<{ id: string; type: 'section' | 'assignment' }>) {
-  const BATCH_SIZE = 10; // Process 10 items at a time to avoid overwhelming the transaction
-
-  // Group items by type for more efficient updates
-  const sections: Array<{ id: string; order: number }> = [];
-  const assignments: Array<{ id: string; order: number }> = [];
-
-  orderedItems.forEach((item, index) => {
-    const orderData = { id: item.id, order: index + 1 };
-    if (item.type === 'section') {
-      sections.push(orderData);
-    } else {
-      assignments.push(orderData);
-    }
-  });
-
-  // Process updates in batches
-  const processBatch = async (items: Array<{ id: string; order: number }>, type: 'section' | 'assignment') => {
-    for (let i = 0; i < items.length; i += BATCH_SIZE) {
-      const batch = items.slice(i, i + BATCH_SIZE);
-      await Promise.all(
-        batch.map(item => {
-          if (type === 'section') {
-            return tx.section.update({ where: { id: item.id }, data: { order: item.order } });
-          } else {
-            return tx.assignment.update({ where: { id: item.id }, data: { order: item.order } });
-          }
-        })
-      );
-    }
-  };
-
-  // Process sections and assignments sequentially to avoid transaction overload
-  await processBatch(sections, 'section');
-  await processBatch(assignments, 'assignment');
-}
-
 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 } });
-      }, {
-        maxWait: 10000, // 10 seconds max wait time
-        timeout: 30000, // 30 seconds timeout for reordering operations
-      });
-
-      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 } });
-      }, {
-        maxWait: 10000, // 10 seconds max wait time
-        timeout: 30000, // 30 seconds timeout for reordering operations
-      });
-
-      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(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({ code: 'UNAUTHORIZED', message: 'User must be authenticated' });
-      }
-      const assignment = await prisma.assignment.findUnique({
-        where: { id: input.id },
-      });
-      
-      return assignment ? true : false;
-    }),
+    .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 } });
-      }, {
-        maxWait: 5000, // 5 seconds max wait time
-        timeout: 10000, // 10 seconds timeout
-      });
-
-      return updated;
-    }),
+    .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, id, title, instructions, dueDate, files, existingFileIds, aiPolicyLevel, acceptFiles, acceptExtendedResponse, acceptWorksheet, worksheetIds, gradeWithAI, studentIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
-
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Pre-fetch data needed for the transaction (outside transaction scope)
-      const [classData, rubricData] = await Promise.all([
-        prisma.class.findUnique({
-          where: { id: classId },
-          include: {
-            students: {
-              select: { id: true }
-            }
-          }
-        }),
-        markSchemeId ? prisma.markScheme.findUnique({
-          where: { id: markSchemeId },
-          select: {
-            structured: true,
-          }
-        }) : null
-      ]);
-
-      if (!classData) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Class not found",
-        });
-      }
-
-      // Calculate max grade outside transaction
-      let computedMaxGrade = maxGrade;
-      if (markSchemeId && rubricData) {
-        const parsedRubric = JSON.parse(rubricData.structured || "{}");
-        computedMaxGrade = parsedRubric.criteria.reduce((acc: number, criterion: any) => {
-          const maxPoints = Math.max(...criterion.levels.map((level: any) => level.points));
-          return acc + maxPoints;
-        }, 0);
-      }
-
-      // Prepare submission data outside transaction
-      const submissionData = studentIds && studentIds.length > 0
-        ? studentIds.map((studentId) => ({
-          student: { connect: { id: studentId } }
-        }))
-        : classData.students.map((student) => ({
-          student: { connect: { id: student.id } }
-        }));
-
-      const teacherId = ctx.user.id;
-
-      // Minimal transaction - only for critical operations
-      const assignment = await prisma.$transaction(async (tx) => {
-        // Create assignment with order 0 (will be at top)
-        const created = await tx.assignment.create({
-          data: {
-            ...(id && { id }),
-            title,
-            instructions,
-            dueDate: new Date(dueDate),
-            maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
-            graded,
-            weight,
-            type,
-            ...(aiPolicyLevel && { aiPolicyLevel }),
-            acceptFiles,
-            acceptExtendedResponse,
-            acceptWorksheet,
-            ...(worksheetIds && {
-              worksheets: {
-                connect: worksheetIds.map(id => ({ id }))
-              }
-            }),
-            gradeWithAI,
-            ...(studentIds && {
-              assignedTo: {
-                connect: studentIds.map(id => ({ id }))
-              }
-            }),
-            order: 0, // Set to 0 to place at top
-            inProgress: inProgress || false,
-            class: {
-              connect: { id: classId }
-            },
-            ...(sectionId && {
-              section: {
-                connect: { id: sectionId }
-              }
-            }),
-            ...(markSchemeId && {
-              markScheme: {
-                connect: { id: markSchemeId }
-              }
-            }),
-            ...(gradingBoundaryId && {
-              gradingBoundary: {
-                connect: { id: gradingBoundaryId }
-              }
-            }),
-            submissions: {
-              create: submissionData
-            },
-            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
-              }
-            }
-          }
-        });
-
-        // Optimized reordering - only increment existing items by 1
-        // This is much faster than reordering everything
-        await tx.assignment.updateMany({
-          where: {
-            classId: classId,
-            id: { not: created.id },
-          },
-          data: {
-            order: { increment: 1 }
-          }
-        });
-
-        await tx.section.updateMany({
-          where: {
-            classId: classId,
-          },
-          data: {
-            order: { increment: 1 }
-          }
-        });
-
-        // Update the created assignment to have order 1
-        await tx.assignment.update({
-          where: { id: created.id },
-          data: { order: 1 }
-        });
-
-        return created;
-      }, {
-        maxWait: 10000, // Increased to 10 seconds max wait time
-        timeout: 20000, // Increased to 20 seconds timeout for safety
-      });
-
-      // Handle file operations outside transaction
-      const fileOperations: Promise<any>[] = [];
-
-      // Process direct upload files
-      if (files && files.length > 0) {
-        fileOperations.push(
-          createDirectUploadFiles(files, ctx.user.id, undefined, assignment.id)
-            .then(uploadedFiles => {
-              if (uploadedFiles.length > 0) {
-                return 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,
-                      }))
-                    }
-                  }
-                });
-              }
-            })
-        );
-      }
-
-      // Connect existing files
-      if (existingFileIds && existingFileIds.length > 0) {
-        fileOperations.push(
-          prisma.assignment.update({
-            where: { id: assignment.id },
-            data: {
-              attachments: {
-                connect: existingFileIds.map(fileId => ({ id: fileId }))
-              }
-            }
-          })
-        );
-      }
-
-      // Execute file operations in parallel
-      await Promise.all(fileOperations);
-
-      // Send notifications asynchronously (non-blocking)
-      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:', error);
-      });
-
-      return assignment;
-    }),
+    .mutation(({ ctx, input }) => createAssignmentRecord(ctx.user!.id, input)),
   update: protectedTeacherProcedure
     .input(updateAssignmentSchema)
-    .mutation(async ({ ctx, input }) => {
-      const { id, title, instructions, dueDate, files, existingFileIds, worksheetIds, aiPolicyLevel, maxGrade, graded, weight, sectionId, type, inProgress, acceptFiles, acceptExtendedResponse, acceptWorksheet, gradeWithAI, studentIds } = input;
-
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Pre-fetch all necessary data outside transaction
-      const [assignment, classData] = await Promise.all([
-        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
-              }
-            },
-            markScheme: true,
-          },
-        }),
-        prisma.class.findFirst({
-          where: {
-            assignments: {
-              some: { id }
-            }
-          },
-          include: {
-            students: {
-              select: { id: true }
-            }
-          }
-        })
-      ]);
-
-      if (!assignment) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Assignment not found",
-        });
-      }
-
-      // Prepare submission data outside transaction if needed
-      const submissionData = studentIds && studentIds.length > 0
-        ? studentIds.map((studentId) => ({
-          student: { connect: { id: studentId } }
-        }))
-        : classData?.students.map((student) => ({
-          student: { connect: { id: student.id } }
-        }));
-
-      // Handle file deletion operations outside transaction
-      const fileDeletionPromises: Promise<void>[] = [];
-      if (input.removedAttachments && input.removedAttachments.length > 0) {
-        const filesToDelete = assignment.attachments.filter((file) =>
-          input.removedAttachments!.includes(file.id)
-        );
-
-        filesToDelete.forEach((file) => {
-          if (file.uploadStatus === 'COMPLETED') {
-            fileDeletionPromises.push(
-              deleteFile(file.path).catch(error => {
-                console.warn(`Failed to delete file ${file.path}:`, error);
-              })
-            );
-            if (file.thumbnail?.path) {
-              fileDeletionPromises.push(
-                deleteFile(file.thumbnail.path).catch(error => {
-                  console.warn(`Failed to delete thumbnail ${file.thumbnail!.path}:`, error);
-                })
-              );
-            }
-          }
-        });
-      }
-
-      // Execute file deletions in parallel
-      await Promise.all(fileDeletionPromises);
-
-      // Prepare file upload operations
-      let uploadedFiles: UploadedFile[] = [];
-      if (files && files.length > 0) {
-        uploadedFiles = await createDirectUploadFiles(files, ctx.user.id, undefined, input.id);
-      }
-
-      // Minimal transaction for database update
-      const updatedAssignment = await prisma.$transaction(async (tx) => {
-        return tx.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 }),
-            ...(acceptFiles !== undefined && { acceptFiles }),
-            ...(acceptExtendedResponse !== undefined && { acceptExtendedResponse }),
-            ...(acceptWorksheet !== undefined && { acceptWorksheet }),
-            ...(gradeWithAI !== undefined && { gradeWithAI }),
-            ...(studentIds && {
-              assignedTo: {
-                set: [], // Clear existing
-                connect: studentIds.map(id => ({ id }))
-              }
-            }),
-            ...(submissionData && {
-              submissions: {
-                deleteMany: {}, // Clear existing submissions
-                create: submissionData
-              }
-            }),
-            ...(aiPolicyLevel !== undefined && { aiPolicyLevel }),
-            ...(sectionId !== undefined && {
-              section: sectionId ? {
-                connect: { id: sectionId }
-              } : {
-                disconnect: true
-              }
-            }),
-            ...(worksheetIds && {
-              worksheets: {
-                set: [], // Clear existing
-                connect: worksheetIds.map(id => ({ id }))
-              }
-            }),
-            ...(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,
-            markSchemeId: 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
-          }
-        });
-      }, {
-        maxWait: 5000, // 5 seconds max wait time
-        timeout: 10000, // 10 seconds timeout
-      });
-
-      // Handle rubric max grade calculation outside transaction
-      if (updatedAssignment.markSchemeId) {
-        prisma.markScheme.findUnique({
-          where: { id: updatedAssignment.markSchemeId },
-          select: {
-            structured: true,
-          }
-        }).then(rubric => {
-          if (rubric) {
-            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) || 0;
-
-            return prisma.assignment.update({
-              where: { id },
-              data: {
-                maxGrade: computedMaxGrade,
-              }
-            });
-          }
-        }).catch(error => {
-          logger.error('Failed to update max grade from rubric:', error);
-        });
-      }
-
-      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: protectedClassMemberProcedure
-    .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
-            }
-          },
-          worksheets: {
-            select: {
-              id: true,
-              name: true,
-            }
-          },
-          class: {
-            select: {
-              id: true,
-              name: true
-            }
-          },
-          eventAttached: {
-            select: {
-              id: true,
-              name: true,
-              startTime: true,
-              endTime: true,
-              location: true,
-              remarks: true,
-              color: 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,
-                }
-              },
-              worksheets: {
-                select: {
-                  id: true,
-                  name: 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: protectedClassMemberProcedure
-    .input(z.object({
-      classId: z.string(),
-      submissionId: z.string(),
-    }))
-    .query(async ({ ctx, input }) => {
-      const { submissionId, classId } = input;
-
-      const submission = await prisma.submission.findFirst({
-        where: {
-          id: submissionId,
-          assignment: {
-            classId,
-            class: {
-              OR: [
-                {
-                  teachers: {
-                    some: {
-                      id: ctx.user?.id
-                    }
-                  }
-                },
-                {
-                  students: {
-                    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,
-                }
-              },
-              worksheets: {
-                select: {
-                  id: true,
-                  name: 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, extendedResponse } = 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
-        if (submission.assignment.acceptWorksheet && submission.assignment.gradeWithAI) {
-
-          // Grade the submission with AI
-          const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
-            where: {
-              submissionId: submission.id,
-            },
-          });
-
-          for (const worksheetResponse of worksheetResponses) {
-            // Run it in the background, non-blocking
-            gradeWorksheetPipeline(worksheetResponse.id);
-          }
-        }
-        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 },
-              },
-            },
-          }),
-          ...(extendedResponse !== undefined && { extendedResponse }),
-        },
-        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,
-              color: 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,
-          color: 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