@studious-lms/server 1.2.53 → 1.3.0

package/src/services/assignment.ts

@@ -0,0 +1,1198 @@
+/**
+ * Assignment service – create, read, update, delete assignments and submissions.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import {
+  findAssignmentById,
+  findAssignmentWithDetails,
+  findAssignmentForDelete,
+  findAssignmentsDueToday,
+  findSubmissionByAssignmentAndStudent,
+  findSubmissionByIdForClassMember,
+  findSubmissionForUpdate,
+  findSubmissionForTeacherUpdate,
+  findSubmissionsByAssignmentForTeacher,
+  createSubmission,
+  findSectionsByClassId,
+  findAssignmentWithClassForTeacher,
+  findAvailableEventsForAssignment,
+  attachAssignmentToEvent,
+  detachAssignmentFromEvent,
+} from "../models/assignment.js";
+import { createDirectUploadFiles, type UploadedFile } from "../lib/fileUpload.js";
+import { deleteFile } from "../lib/googleCloudStorage.js";
+import { gradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
+import { sendToMultiple } from "./notification.js";
+import { logger } from "../utils/logger.js";
+
+export async function assignmentExists(id: string) {
+  const assignment = await findAssignmentById(id);
+  return !!assignment;
+}
+
+export async function getDueToday() {
+  const assignments = await findAssignmentsDueToday();
+  return assignments.map((a) => ({
+    ...a,
+    dueDate: a.dueDate.toISOString(),
+  }));
+}
+
+export async function getAssignment(id: string, _classId: string) {
+  const assignment = await findAssignmentWithDetails(id);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+  const sections = await findSectionsByClassId(assignment.classId);
+  return { ...assignment, sections };
+}
+
+export async function getSubmission(assignmentId: string, studentId: string) {
+  let submission = await findSubmissionByAssignmentAndStudent(assignmentId, studentId);
+  if (!submission) {
+    const created = await createSubmission(assignmentId, studentId);
+    return {
+      ...created,
+      late: created.assignment.dueDate < new Date(),
+    };
+  }
+  return {
+    ...submission,
+    late: submission.assignment.dueDate < new Date(),
+  };
+}
+
+export async function getSubmissionById(submissionId: string, classId: string, userId: string) {
+  const submission = await findSubmissionByIdForClassMember(submissionId, classId, userId);
+  if (!submission) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Submission not found",
+    });
+  }
+  return {
+    ...submission,
+    late: submission.assignment.dueDate < new Date(),
+  };
+}
+
+export async function getSubmissions(assignmentId: string, teacherId: string) {
+  const submissions = await findSubmissionsByAssignmentForTeacher(assignmentId, teacherId);
+  return submissions.map((s) => ({
+    ...s,
+    late: s.assignment.dueDate < new Date(),
+  }));
+}
+
+export async function createAssignmentRecord(
+  userId: string,
+  input: {
+    classId: string;
+    id?: string;
+    title: string;
+    instructions: string;
+    dueDate: string;
+    files?: { name: string; type: string; size: number }[];
+    existingFileIds?: string[];
+    aiPolicyLevel?: number;
+    acceptFiles?: boolean;
+    acceptExtendedResponse?: boolean;
+    acceptWorksheet?: boolean;
+    worksheetIds?: string[];
+    gradeWithAI?: boolean;
+    studentIds?: string[];
+    maxGrade?: number;
+    graded?: boolean;
+    weight?: number;
+    sectionId?: string;
+    type?: string;
+    markSchemeId?: string;
+    gradingBoundaryId?: string;
+    inProgress?: boolean;
+  }
+) {
+  const {
+    classId,
+    id,
+    title,
+    instructions,
+    dueDate,
+    files,
+    existingFileIds,
+    aiPolicyLevel,
+    acceptFiles,
+    acceptExtendedResponse,
+    acceptWorksheet,
+    worksheetIds,
+    gradeWithAI,
+    studentIds,
+    maxGrade,
+    graded,
+    weight,
+    sectionId,
+    type,
+    markSchemeId,
+    gradingBoundaryId,
+    inProgress,
+  } = input;
+
+  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",
+    });
+  }
+
+  let computedMaxGrade = maxGrade;
+  if (markSchemeId && rubricData) {
+    const parsedRubric = JSON.parse(rubricData.structured || "{}");
+    computedMaxGrade = parsedRubric.criteria?.reduce(
+      (acc: number, criterion: { levels: { points: number }[] }) => {
+        const maxPoints = Math.max(...criterion.levels.map((l) => l.points));
+        return acc + maxPoints;
+      },
+      0
+    );
+  }
+
+  const submissionData =
+    studentIds && studentIds.length > 0
+      ? studentIds.map((studentId) => ({ student: { connect: { id: studentId } } }))
+      : classData.students.map((student) => ({ student: { connect: { id: student.id } } }));
+
+  const assignment = await prisma.$transaction(
+    async (tx) => {
+      const created = await tx.assignment.create({
+        data: {
+          ...(id && { id }),
+          title,
+          instructions,
+          dueDate: new Date(dueDate),
+          maxGrade: markSchemeId ? computedMaxGrade : maxGrade,
+          graded,
+          weight,
+          type: type as any,
+          ...(aiPolicyLevel !== undefined && { aiPolicyLevel }),
+          acceptFiles,
+          acceptExtendedResponse,
+          acceptWorksheet,
+          ...(worksheetIds?.length && {
+            worksheets: { connect: worksheetIds.map((id) => ({ id })) },
+          }),
+          gradeWithAI,
+          ...(studentIds?.length && {
+            assignedTo: { connect: studentIds.map((id) => ({ id })) },
+          }),
+          order: 0,
+          inProgress: inProgress || false,
+          class: { connect: { id: classId } },
+          ...(sectionId && { section: { connect: { id: sectionId } } }),
+          ...(markSchemeId && { markScheme: { connect: { id: markSchemeId } } }),
+          ...(gradingBoundaryId && {
+            gradingBoundary: { connect: { id: gradingBoundaryId } },
+          }),
+          submissions: { create: submissionData },
+          teacher: { connect: { id: userId } },
+        },
+        select: {
+          id: true,
+          title: true,
+          instructions: true,
+          dueDate: true,
+          maxGrade: true,
+          graded: true,
+          weight: true,
+          type: true,
+          attachments: { select: { id: true, name: true, type: true } },
+          section: { select: { id: true, name: true } },
+          teacher: { select: { id: true, username: true } },
+          class: { select: { id: true, name: true } },
+        },
+      });
+
+      await tx.assignment.updateMany({
+        where: { classId, id: { not: created.id } },
+        data: { order: { increment: 1 } },
+      });
+      await tx.section.updateMany({
+        where: { classId },
+        data: { order: { increment: 1 } },
+      });
+      await tx.assignment.update({
+        where: { id: created.id },
+        data: { order: 1 },
+      });
+
+      return created;
+    },
+    { maxWait: 10000, timeout: 20000 }
+  );
+
+  const fileOperations: Promise<unknown>[] = [];
+  if (files?.length) {
+    fileOperations.push(
+      createDirectUploadFiles(files, userId, 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,
+                })),
+              },
+            },
+          });
+        }
+      })
+    );
+  }
+  if (existingFileIds?.length) {
+    fileOperations.push(
+      prisma.assignment.update({
+        where: { id: assignment.id },
+        data: {
+          attachments: {
+            connect: existingFileIds.map((fileId) => ({ id: fileId })),
+          },
+        },
+      })
+    );
+  }
+  await Promise.all(fileOperations);
+
+  sendToMultiple({
+    receiverIds: classData.students.map((s) => s.id),
+    title: `🔔 New assignment for ${classData.name}`,
+    content: `The assignment "${title}" has been created in ${classData.name}.\nDue date: ${new Date(dueDate).toLocaleDateString()}.\n[Link to assignment](/class/${classId}/assignments/${assignment.id})`,
+  }).catch((error) => {
+    logger.error("Failed to send assignment notifications:", error);
+  });
+
+  return assignment;
+}
+
+export async function updateAssignmentRecord(
+  userId: string,
+  input: {
+    id: string;
+    classId: string;
+    title?: string;
+    instructions?: string;
+    dueDate?: string;
+    files?: { name: string; type: string; size: number }[];
+    existingFileIds?: string[];
+    removedAttachments?: string[];
+    worksheetIds?: string[];
+    aiPolicyLevel?: number;
+    maxGrade?: number;
+    graded?: boolean;
+    weight?: number;
+    sectionId?: string | null;
+    type?: string;
+    inProgress?: boolean;
+    acceptFiles?: boolean;
+    acceptExtendedResponse?: boolean;
+    acceptWorksheet?: boolean;
+    gradeWithAI?: boolean;
+    studentIds?: string[];
+  }
+) {
+  const [assignment, classData] = await Promise.all([
+    prisma.assignment.findFirst({
+      where: { id: input.id, teacherId: userId },
+      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: input.id } } },
+      include: { students: { select: { id: true } } },
+    }),
+  ]);
+
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  const submissionData =
+    input.studentIds?.length
+      ? input.studentIds.map((studentId) => ({ student: { connect: { id: studentId } } }))
+      : classData?.students.map((student) => ({
+          student: { connect: { id: student.id } },
+        }));
+
+  if (input.removedAttachments?.length) {
+    const filesToDelete = assignment.attachments.filter((f) =>
+      input.removedAttachments!.includes(f.id)
+    );
+    await Promise.all(
+      filesToDelete.map(async (file) => {
+        if (file.uploadStatus === "COMPLETED") {
+          await deleteFile(file.path).catch(() => {});
+          if (file.thumbnail?.path) {
+            await deleteFile(file.thumbnail.path).catch(() => {});
+          }
+        }
+      })
+    );
+  }
+
+  let uploadedFiles: UploadedFile[] = [];
+  if (input.files?.length) {
+    uploadedFiles = await createDirectUploadFiles(
+      input.files,
+      userId,
+      undefined,
+      input.id
+    );
+  }
+
+  const updateData: Record<string, unknown> = {
+    ...(input.title && { title: input.title }),
+    ...(input.instructions && { instructions: input.instructions }),
+    ...(input.dueDate && { dueDate: new Date(input.dueDate) }),
+    ...(input.maxGrade && { maxGrade: input.maxGrade }),
+    ...(input.graded !== undefined && { graded: input.graded }),
+    ...(input.weight && { weight: input.weight }),
+    ...(input.type && { type: input.type }),
+    ...(input.inProgress !== undefined && { inProgress: input.inProgress }),
+    ...(input.acceptFiles !== undefined && { acceptFiles: input.acceptFiles }),
+    ...(input.acceptExtendedResponse !== undefined && {
+      acceptExtendedResponse: input.acceptExtendedResponse,
+    }),
+    ...(input.acceptWorksheet !== undefined && {
+      acceptWorksheet: input.acceptWorksheet,
+    }),
+    ...(input.gradeWithAI !== undefined && { gradeWithAI: input.gradeWithAI }),
+    ...(input.studentIds && {
+      assignedTo: {
+        set: [],
+        connect: input.studentIds.map((id) => ({ id })),
+      },
+    }),
+    ...(submissionData && {
+      submissions: {
+        deleteMany: {},
+        create: submissionData,
+      },
+    }),
+    ...(input.aiPolicyLevel !== undefined && { aiPolicyLevel: input.aiPolicyLevel }),
+    ...(input.sectionId !== undefined && {
+      section: input.sectionId
+        ? { connect: { id: input.sectionId } }
+        : { disconnect: true },
+    }),
+    ...(input.worksheetIds && {
+      worksheets: {
+        set: [],
+        connect: input.worksheetIds.map((id) => ({ id })),
+      },
+    }),
+    ...((uploadedFiles.length > 0 ||
+      input.existingFileIds?.length ||
+      input.removedAttachments?.length) && {
+      attachments: {
+        ...(uploadedFiles.length > 0 && {
+          create: uploadedFiles.map((file) => ({
+            name: file.name,
+            type: file.type,
+            size: file.size,
+            path: file.path,
+            ...(file.thumbnailId && {
+              thumbnail: { connect: { id: file.thumbnailId } },
+            }),
+          })),
+        }),
+        ...(input.existingFileIds?.length && {
+          connect: input.existingFileIds.map((fileId) => ({ id: fileId })),
+        }),
+        ...(input.removedAttachments?.length && {
+          deleteMany: { id: { in: input.removedAttachments } },
+        }),
+      },
+    }),
+  };
+
+  const updatedAssignment = await prisma.$transaction(
+    async (tx) => {
+      return tx.assignment.update({
+        where: { id: input.id },
+        data: updateData as any,
+        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, timeout: 10000 }
+  );
+
+  if (updatedAssignment.markSchemeId) {
+    prisma.markScheme
+      .findUnique({
+        where: { id: updatedAssignment.markSchemeId },
+        select: { structured: true },
+      })
+      .then((rubric) => {
+        if (rubric) {
+          const parsed = JSON.parse(rubric.structured || "{}");
+          const computedMaxGrade =
+            parsed.criteria?.reduce(
+              (acc: number, c: { levels: { points: number }[] }) =>
+                acc + Math.max(...c.levels.map((l) => l.points)),
+              0
+            ) || 0;
+          return prisma.assignment.update({
+            where: { id: input.id },
+            data: { maxGrade: computedMaxGrade },
+          });
+        }
+      })
+      .catch((error) => logger.error("Failed to update max grade from rubric:", error));
+  }
+
+  return updatedAssignment;
+}
+
+export async function deleteAssignmentRecord(userId: string, id: string, _classId: string) {
+  const assignment = await findAssignmentForDelete(id, userId);
+
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  const filesToDelete = [
+    ...assignment.attachments,
+    ...assignment.submissions.flatMap((s) => [
+      ...s.attachments,
+      ...s.annotations,
+    ]),
+  ];
+
+  await Promise.all(
+    filesToDelete.map(async (file) => {
+      try {
+        if (file.uploadStatus === "COMPLETED") {
+          await deleteFile(file.path);
+          if (file.thumbnail) {
+            await deleteFile(file.thumbnail.path);
+          }
+        }
+      } catch {
+        // ignore
+      }
+    })
+  );
+
+  await prisma.assignment.delete({
+    where: { id },
+  });
+
+  return { id };
+}
+
+export async function updateSubmissionRecord(
+  userId: string,
+  input: {
+    submissionId: string;
+    assignmentId: string;
+    classId: string;
+    submit?: boolean;
+    newAttachments?: { name: string; type: string; size: number }[];
+    extendedResponse?: string;
+    existingFileIds?: string[];
+    removedAttachments?: string[];
+  }
+) {
+  const { submissionId, submit, newAttachments, extendedResponse, existingFileIds, removedAttachments } =
+    input;
+
+  const submission = await findSubmissionForUpdate(submissionId, userId);
+
+  if (!submission) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Submission not found",
+    });
+  }
+
+  if (submit !== undefined) {
+    if (
+      submission.assignment.acceptWorksheet &&
+      submission.assignment.gradeWithAI
+    ) {
+      const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
+        where: { submissionId: submission.id },
+      });
+      for (const wr of worksheetResponses) {
+        gradeWorksheetPipeline(wr.id);
+      }
+    }
+    return 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?.length) {
+    uploadedFiles = await createDirectUploadFiles(
+      newAttachments,
+      userId,
+      undefined,
+      undefined,
+      submission.id
+    );
+  }
+
+  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 } },
+            }),
+          })),
+        },
+      },
+    });
+  }
+
+  if (existingFileIds?.length) {
+    await prisma.submission.update({
+      where: { id: submission.id },
+      data: {
+        attachments: {
+          connect: existingFileIds.map((fileId) => ({ id: fileId })),
+        },
+      },
+    });
+  }
+
+  if (removedAttachments?.length) {
+    const filesToDelete = submission.attachments.filter((f) =>
+      removedAttachments.includes(f.id)
+    );
+    await Promise.all(
+      filesToDelete.map(async (file) => {
+        try {
+          if (file.uploadStatus === "COMPLETED") {
+            await deleteFile(file.path);
+            if (file.thumbnail?.path) {
+              await deleteFile(file.thumbnail.path);
+            }
+          }
+        } catch {
+          // ignore
+        }
+      })
+    );
+  }
+
+  return prisma.submission.update({
+    where: { id: submission.id },
+    data: {
+      ...(removedAttachments?.length && {
+        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 } },
+        },
+      },
+    },
+  });
+}
+
+const submissionTeacherInclude = {
+  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 } },
+    },
+  },
+};
+
+export async function updateSubmissionAsTeacherRecord(
+  teacherId: string,
+  input: {
+    submissionId: string;
+    assignmentId: string;
+    classId: string;
+    return?: boolean;
+    gradeReceived?: number | null;
+    newAttachments?: { name: string; type: string; size: number }[];
+    existingFileIds?: string[];
+    removedAttachments?: string[];
+    rubricGrades?: { criteriaId: string; selectedLevelId: string; points: number; comments: string }[];
+    feedback?: string;
+  }
+) {
+  const {
+    submissionId,
+    return: returnSubmission,
+    gradeReceived,
+    existingFileIds,
+    removedAttachments,
+    rubricGrades,
+    feedback,
+  } = input;
+
+  const submission = await findSubmissionForTeacherUpdate(submissionId, teacherId);
+
+  if (!submission) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Submission not found",
+    });
+  }
+
+  if (input.newAttachments?.length) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Direct file upload is deprecated. Use getAnnotationUploadUrls endpoint instead.",
+    });
+  }
+
+  if (returnSubmission !== undefined) {
+    return prisma.submission.update({
+      where: { id: submissionId },
+      data: { returned: !submission.returned },
+      include: submissionTeacherInclude,
+    });
+  }
+
+  if (existingFileIds?.length) {
+    await prisma.submission.update({
+      where: { id: submission.id },
+      data: {
+        annotations: {
+          connect: existingFileIds.map((fileId) => ({ id: fileId })),
+        },
+      },
+    });
+  }
+
+  if (removedAttachments?.length) {
+    const filesToDelete = submission.annotations.filter((f) =>
+      removedAttachments.includes(f.id)
+    );
+    await Promise.all(
+      filesToDelete.map(async (file) => {
+        try {
+          if (file.uploadStatus === "COMPLETED") {
+            await deleteFile(file.path);
+            if (file.thumbnail?.path) {
+              await deleteFile(file.thumbnail.path);
+            }
+          }
+        } catch {
+          // ignore
+        }
+      })
+    );
+  }
+
+  return prisma.submission.update({
+    where: { id: submissionId },
+    data: {
+      ...(gradeReceived !== undefined && { gradeReceived }),
+      ...(rubricGrades && { rubricState: JSON.stringify(rubricGrades) }),
+      ...(feedback && { teacherComments: feedback }),
+      ...(removedAttachments?.length && {
+        annotations: {
+          deleteMany: { id: { in: removedAttachments } },
+        },
+      }),
+    },
+    include: submissionTeacherInclude,
+  });
+}
+
+export async function attachAssignmentToEventRecord(
+  teacherId: string,
+  assignmentId: string,
+  eventId: string
+) {
+  const assignment = await findAssignmentWithClassForTeacher(assignmentId, teacherId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found or you are not authorized",
+    });
+  }
+
+  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",
+    });
+  }
+
+  const updated = await attachAssignmentToEvent(assignmentId, eventId);
+  return { assignment: updated };
+}
+
+export async function detachAssignmentFromEventRecord(teacherId: string, assignmentId: string) {
+  const assignment = await findAssignmentWithClassForTeacher(assignmentId, teacherId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found or you are not authorized",
+    });
+  }
+
+  const updated = await detachAssignmentFromEvent(assignmentId);
+  return { assignment: updated };
+}
+
+export async function getAvailableEventsForAssignment(teacherId: string, assignmentId: string) {
+  const assignment = await findAssignmentWithClassForTeacher(assignmentId, teacherId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found or you are not authorized",
+    });
+  }
+
+  const events = await findAvailableEventsForAssignment(assignment.classId, assignmentId);
+  return { events };
+}
+
+export async function attachMarkSchemeRecord(
+  teacherId: string,
+  assignmentId: string,
+  markSchemeId: string | null
+) {
+  const assignment = await findAssignmentById(assignmentId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  if (markSchemeId) {
+    const markScheme = await prisma.markScheme.findFirst({
+      where: { id: markSchemeId },
+    });
+    if (!markScheme) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Mark scheme not found",
+      });
+    }
+  }
+
+  return 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,
+    },
+  });
+}
+
+export async function detachMarkSchemeRecord(teacherId: string, assignmentId: string) {
+  const assignment = await findAssignmentById(assignmentId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  return prisma.assignment.update({
+    where: { id: assignmentId },
+    data: { markScheme: { disconnect: true } },
+    include: {
+      attachments: true,
+      section: true,
+      teacher: true,
+      eventAttached: true,
+      markScheme: true,
+    },
+  });
+}
+
+export async function attachGradingBoundaryRecord(
+  teacherId: string,
+  assignmentId: string,
+  gradingBoundaryId: string | null
+) {
+  const assignment = await findAssignmentById(assignmentId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  if (gradingBoundaryId) {
+    const gradingBoundary = await prisma.gradingBoundary.findFirst({
+      where: { id: gradingBoundaryId },
+    });
+    if (!gradingBoundary) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Grading boundary not found",
+      });
+    }
+  }
+
+  return 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,
+    },
+  });
+}
+
+export async function detachGradingBoundaryRecord(teacherId: string, assignmentId: string) {
+  const assignment = await findAssignmentById(assignmentId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  return prisma.assignment.update({
+    where: { id: assignmentId },
+    data: { gradingBoundary: { disconnect: true } },
+    include: {
+      attachments: true,
+      section: true,
+      teacher: true,
+      eventAttached: true,
+      gradingBoundary: true,
+    },
+  });
+}
+
+// --- Reorder & Move (unified list of sections + assignments) ---
+
+async function getUnifiedList(
+  tx: { section: { findMany: (args: any) => Promise<any[]> }; assignment: { findMany: (args: any) => Promise<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 },
+    }),
+  ]);
+
+  const unified = [
+    ...sections.map((s: { id: string; order: number | null }) => ({ id: s.id, order: s.order, type: "section" as const })),
+    ...assignments.map((a: { id: string; order: number | null }) => ({ 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;
+}
+
+async function normalizeUnifiedList(
+  tx: { section: { update: (args: any) => Promise<any> }; assignment: { update: (args: any) => Promise<any> } },
+  classId: string,
+  orderedItems: Array<{ id: string; type: "section" | "assignment" }>
+) {
+  const BATCH_SIZE = 10;
+  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);
+    }
+  });
+
+  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) =>
+          type === "section"
+            ? tx.section.update({ where: { id: item.id }, data: { order: item.order } })
+            : tx.assignment.update({ where: { id: item.id }, data: { order: item.order } })
+        )
+      );
+    }
+  };
+
+  await processBatch(sections, "section");
+  await processBatch(assignments, "assignment");
+}
+
+export async function reorderAssignmentRecord(
+  teacherId: string,
+  input: {
+    classId: string;
+    movedId: string;
+    position: "start" | "end" | "before" | "after";
+    targetId?: string;
+  }
+) {
+  const assignment = await findAssignmentWithClassForTeacher(input.movedId, teacherId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  if ((input.position === "before" || input.position === "after") && !input.targetId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "targetId required for before/after",
+    });
+  }
+
+  return prisma.$transaction(
+    async (tx) => {
+      const unified = await getUnifiedList(tx, input.classId);
+
+      const movedIdx = unified.findIndex(
+        (item) => item.id === input.movedId && item.type === "assignment"
+      );
+      if (movedIdx === -1) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Assignment not found in unified list",
+        });
+      }
+
+      const withoutMoved = unified.filter(
+        (item) => !(item.id === input.movedId && item.type === "assignment")
+      );
+
+      let next: Array<{ id: string; type: "section" | "assignment" }> = [];
+
+      if (input.position === "start") {
+        next = [
+          { id: input.movedId, type: "assignment" },
+          ...withoutMoved.map((item) => ({ id: item.id, type: item.type })),
+        ];
+      } else if (input.position === "end") {
+        next = [
+          ...withoutMoved.map((item) => ({ id: item.id, type: item.type })),
+          { id: input.movedId, type: "assignment" },
+        ];
+      } else {
+        const targetIdx = withoutMoved.findIndex((item) => item.id === input.targetId);
+        if (targetIdx === -1) {
+          throw new TRPCError({
+            code: "BAD_REQUEST",
+            message: "targetId not found in unified list",
+          });
+        }
+        if (input.position === "before") {
+          next = [
+            ...withoutMoved.slice(0, targetIdx).map((item) => ({ id: item.id, type: item.type })),
+            { id: input.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: input.movedId, type: "assignment" },
+            ...withoutMoved.slice(targetIdx + 1).map((item) => ({ id: item.id, type: item.type })),
+          ];
+        }
+      }
+
+      await normalizeUnifiedList(tx, input.classId, next);
+
+      return tx.assignment.findUnique({ where: { id: input.movedId } });
+    },
+    { maxWait: 10000, timeout: 30000 }
+  );
+}
+
+export async function moveAssignmentRecord(
+  teacherId: string,
+  input: {
+    id: string;
+    classId: string;
+    targetSectionId: string | null;
+  }
+) {
+  const assignment = await findAssignmentWithClassForTeacher(input.id, teacherId);
+  if (!assignment) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found",
+    });
+  }
+
+  if (input.targetSectionId) {
+    const section = await prisma.section.findFirst({
+      where: {
+        id: input.targetSectionId,
+        classId: input.classId,
+      },
+    });
+    if (!section) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Section not found",
+      });
+    }
+  }
+
+  return prisma.$transaction(
+    async (tx) => {
+      await tx.assignment.update({
+        where: { id: input.id },
+        data: { sectionId: input.targetSectionId },
+      });
+      return tx.assignment.findUnique({ where: { id: input.id } });
+    },
+    { maxWait: 5000, timeout: 10000 }
+  );
+}