@studious-lms/server 1.2.53 → 1.4.0

package/dist/services/assignment.js

@@ -0,0 +1,898 @@
+/**
+ * Assignment service – create, read, update, delete assignments and submissions.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="9f048e12-9c8f-592d-82cb-74a5ccf39c12")}catch(e){}}();
+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 } 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) {
+    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, _classId) {
+    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, studentId) {
+    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, classId, userId) {
+    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, teacherId) {
+    const submissions = await findSubmissionsByAssignmentForTeacher(assignmentId, teacherId);
+    return submissions.map((s) => ({
+        ...s,
+        late: s.assignment.dueDate < new Date(),
+    }));
+}
+export async function createAssignmentRecord(userId, 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;
+    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, criterion) => {
+            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,
+                ...(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 = [];
+    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, input) {
+    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 = [];
+    if (input.files?.length) {
+        uploadedFiles = await createDirectUploadFiles(input.files, userId, undefined, input.id);
+    }
+    const updateData = {
+        ...(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,
+            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, c) => 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, id, _classId) {
+    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, input) {
+    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 = [];
+    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, input) {
+    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, assignmentId, eventId) {
+    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, assignmentId) {
+    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, assignmentId) {
+    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, assignmentId, markSchemeId) {
+    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, assignmentId) {
+    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, assignmentId, gradingBoundaryId) {
+    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, assignmentId) {
+    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, classId) {
+    const [sections, assignments] = await Promise.all([
+        tx.section.findMany({
+            where: { classId },
+            select: { id: true, order: true },
+        }),
+        tx.assignment.findMany({
+            where: { classId },
+            select: { id: true, order: true },
+        }),
+    ]);
+    const unified = [
+        ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" })),
+        ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" })),
+    ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+    return unified;
+}
+async function normalizeUnifiedList(tx, classId, orderedItems) {
+    const BATCH_SIZE = 10;
+    const sections = [];
+    const assignments = [];
+    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, type) => {
+        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, input) {
+    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 = [];
+        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, input) {
+    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 });
+}
+//# sourceMappingURL=assignment.js.map
+//# debugId=9f048e12-9c8f-592d-82cb-74a5ccf39c12