@studious-lms/server 1.2.53 → 1.4.0

package/dist/models/class.js

@@ -0,0 +1,645 @@
+/**
+ * Class model – classes, members, assignments, grades, mark schemes,
+ * grading boundaries, syllabus, lab drafts, invite codes.
+ */
+
+!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]="a5a21161-a4bb-58bf-9c4b-a48cc39cfbdb")}catch(e){}}();
+import { prisma } from "../lib/prisma.js";
+import { v4 as uuidv4 } from 'uuid';
+import { copyFile } from "../lib/googleCloudStorage.js";
+const classIncludeForGetAll = {
+    assignments: {
+        where: {
+            dueDate: { lte: new Date(new Date().setHours(23, 59, 59, 999)) },
+            template: false,
+        },
+        select: {
+            id: true,
+            title: true,
+            type: true,
+            dueDate: true,
+        },
+    },
+    students: {
+        select: {
+            id: true,
+            username: true,
+            profile: {
+                select: {
+                    displayName: true,
+                    profilePicture: true,
+                    profilePictureThumbnail: true,
+                },
+            },
+        },
+    },
+    teachers: {
+        select: {
+            id: true,
+            username: true,
+            profile: {
+                select: {
+                    displayName: true,
+                    profilePicture: true,
+                    profilePictureThumbnail: true,
+                },
+            },
+        },
+    },
+};
+/** @returns Classes where user is a teacher. */
+export function findTeacherClasses(userId) {
+    return prisma.class.findMany({
+        where: { teachers: { some: { id: userId } } },
+        include: classIncludeForGetAll,
+    });
+}
+/** @returns Classes where user is a student. */
+export function findStudentClasses(userId) {
+    return prisma.class.findMany({
+        where: { students: { some: { id: userId } } },
+        include: classIncludeForGetAll,
+    });
+}
+/** @returns Class if user is a teacher. */
+export function isTeacherInClass(classId, userId) {
+    return prisma.class.findFirst({
+        where: {
+            id: classId,
+            teachers: { some: { id: userId } },
+        },
+    });
+}
+const classIncludeForGet = {
+    teachers: {
+        select: {
+            id: true,
+            username: true,
+            profile: {
+                select: {
+                    displayName: true,
+                    profilePicture: true,
+                    profilePictureThumbnail: true,
+                },
+            },
+        },
+    },
+    students: {
+        select: {
+            id: true,
+            username: true,
+            profile: {
+                select: {
+                    displayName: true,
+                    profilePicture: true,
+                    profilePictureThumbnail: true,
+                },
+            },
+        },
+    },
+    announcements: {
+        orderBy: { createdAt: "desc" },
+        select: {
+            id: true,
+            remarks: true,
+            createdAt: true,
+            modifiedAt: true,
+            teacher: {
+                select: {
+                    id: true,
+                    username: true,
+                    profile: {
+                        select: {
+                            displayName: true,
+                            profilePicture: true,
+                            profilePictureThumbnail: true,
+                        },
+                    },
+                },
+            },
+        },
+    },
+    assignments: {
+        select: {
+            type: true,
+            id: true,
+            title: true,
+            dueDate: true,
+            createdAt: true,
+            weight: true,
+            order: true,
+            graded: true,
+            maxGrade: true,
+            instructions: true,
+            inProgress: true,
+            section: {
+                select: { id: true, name: true },
+            },
+            markScheme: {
+                select: { id: true, structured: true },
+            },
+            gradingBoundary: {
+                select: { id: true, structured: true },
+            },
+            submissions: {
+                select: {
+                    studentId: true,
+                    id: true,
+                    submitted: true,
+                    gradeReceived: true,
+                    rubricState: true,
+                    teacherComments: true,
+                    returned: true,
+                    submittedAt: true,
+                },
+            },
+        },
+    },
+};
+const assignmentSelect = {
+    type: true,
+    id: true,
+    title: true,
+    dueDate: true,
+    createdAt: true,
+    weight: true,
+    order: true,
+    graded: true,
+    maxGrade: true,
+    instructions: true,
+    inProgress: true,
+    section: { select: { id: true, name: true } },
+    markScheme: { select: { id: true, structured: true } },
+    gradingBoundary: { select: { id: true, structured: true } },
+    submissions: {
+        select: {
+            studentId: true,
+            id: true,
+            submitted: true,
+            gradeReceived: true,
+            rubricState: true,
+            teacherComments: true,
+            returned: true,
+            submittedAt: true,
+        },
+    },
+};
+/** @returns Class with assignments. Students see only assigned; teachers see all. */
+export function findClassWithAssignments(classId, options) {
+    const assignmentWhere = !options.isTeacher &&
+        options.userId
+        ? {
+            OR: [
+                { assignedTo: { some: { id: options.userId } } },
+                { assignedTo: { none: {} } },
+            ],
+        }
+        : undefined;
+    const submissionWhere = !options.isTeacher && options.userId
+        ? { studentId: options.userId }
+        : undefined;
+    return prisma.class.findUnique({
+        where: { id: classId },
+        include: {
+            teachers: classIncludeForGet.teachers,
+            students: classIncludeForGet.students,
+            announcements: classIncludeForGet.announcements,
+            assignments: {
+                ...(assignmentWhere && { where: assignmentWhere }),
+                select: {
+                    ...assignmentSelect,
+                    submissions: {
+                        ...(submissionWhere && { where: submissionWhere }),
+                        select: assignmentSelect.submissions.select,
+                    },
+                },
+            },
+        },
+    });
+}
+/** @returns Class by ID (minimal). */
+export function findClassByIdBasic(classId) {
+    return prisma.class.findUnique({
+        where: { id: classId },
+    });
+}
+/** @returns Sections for a class. */
+export function findSectionsByClassId(classId) {
+    return prisma.section.findMany({
+        where: { classId },
+    });
+}
+/** @returns User by ID (id, username only). */
+export function findUserById(userId) {
+    return prisma.user.findUnique({
+        where: { id: userId },
+        select: { id: true, username: true },
+    });
+}
+/** @returns Session by class invite code. */
+export function findSessionByClassCode(classCode) {
+    return prisma.session.findFirst({
+        where: {
+            id: { equals: classCode, mode: "insensitive" },
+        },
+    });
+}
+/** @returns Session for a class. */
+export function findSessionByClassId(classId) {
+    return prisma.session.findFirst({
+        where: { classId },
+    });
+}
+/** @returns User's graded submissions for grade calculation. */
+export function findSubmissionsForGrades(userId, classId) {
+    return prisma.submission.findMany({
+        where: {
+            studentId: userId,
+            assignment: { classId, graded: true },
+        },
+        include: {
+            assignment: {
+                select: {
+                    id: true,
+                    title: true,
+                    maxGrade: true,
+                    weight: true,
+                    markSchemeId: true,
+                    dueDate: true,
+                    markScheme: { select: { structured: true } },
+                    gradingBoundaryId: true,
+                    gradingBoundary: { select: { structured: true } },
+                },
+            },
+        },
+    });
+}
+/** @returns Events for a class. */
+export function findEventsByClassId(classId) {
+    return prisma.event.findMany({
+        where: { class: { id: classId } },
+        select: { name: true, startTime: true, endTime: true },
+    });
+}
+/** @returns Mark schemes for a class. */
+export function findMarkSchemesByClassId(classId) {
+    return prisma.markScheme.findMany({
+        where: { class: { id: classId } },
+    });
+}
+/** @returns Grading boundaries for a class. */
+export function findGradingBoundariesByClassId(classId) {
+    return prisma.gradingBoundary.findMany({
+        where: { class: { id: classId } },
+    });
+}
+/** @returns Class syllabus. */
+export function findClassSyllabus(classId) {
+    return prisma.class.findUnique({
+        where: { id: classId },
+        select: { syllabus: true },
+    });
+}
+/** @returns In-progress lab drafts for a teacher. */
+export function findLabDraftsByClass(classId, teacherId) {
+    return prisma.assignment.findMany({
+        where: {
+            classId,
+            teacherId,
+            inProgress: true,
+        },
+        orderBy: { modifiedAt: "desc" },
+    });
+}
+/** @returns Assignments with attachments and submissions. */
+export function findAssignmentsWithFiles(classId) {
+    return prisma.assignment.findMany({
+        where: { classId },
+        include: {
+            attachments: {
+                select: {
+                    id: true,
+                    name: true,
+                    type: true,
+                    size: true,
+                    path: true,
+                    thumbnailId: true,
+                    uploadedAt: true,
+                    user: { select: { id: true, username: true } },
+                },
+            },
+            submissions: {
+                include: {
+                    attachments: {
+                        select: {
+                            id: true,
+                            name: true,
+                            type: true,
+                            size: true,
+                            path: true,
+                            thumbnailId: true,
+                            uploadedAt: true,
+                            user: { select: { id: true, username: true } },
+                        },
+                    },
+                    annotations: {
+                        select: {
+                            id: true,
+                            name: true,
+                            type: true,
+                            size: true,
+                            path: true,
+                            thumbnailId: true,
+                            uploadedAt: true,
+                            user: { select: { id: true, username: true } },
+                        },
+                    },
+                    student: { select: { id: true, username: true } },
+                },
+            },
+            teacher: { select: { id: true, username: true } },
+        },
+        orderBy: { createdAt: "desc" },
+    });
+}
+async function recursivelyIncludeFiles(folderId) {
+    if (!folderId.length) {
+        return null;
+    }
+    const folder = await prisma.folder.findUnique({
+        where: { id: folderId },
+        include: {
+            files: {
+                select: { id: true, name: true, type: true, size: true, path: true },
+            },
+            childFolders: {
+                select: { id: true },
+            },
+        },
+    });
+    if (!folder) {
+        return null;
+    }
+    return {
+        ...folder,
+        files: folder.files.map(file => file.id),
+        childFolders: await Promise.all(folder.childFolders.map(folder => recursivelyIncludeFiles(folder.id))),
+    };
+}
+/** Copy all files in folder tree to GCS (outside transaction). Returns map of sourcePath -> newPath. */
+async function recursivelyCopyFilesToGcs(folderId) {
+    const pathMap = new Map();
+    if (!folderId.length)
+        return pathMap;
+    const folder = await prisma.folder.findUnique({
+        where: { id: folderId },
+        include: {
+            files: { select: { path: true, name: true } },
+            childFolders: { select: { id: true } },
+        },
+    });
+    if (!folder)
+        return pathMap;
+    for (const file of folder.files) {
+        const ext = file.name.split('.').pop() || '';
+        const newPath = `imported/${uuidv4()}${ext ? `.${ext}` : ''}`;
+        await copyFile(file.path, newPath);
+        pathMap.set(file.path, newPath);
+    }
+    for (const child of folder.childFolders) {
+        const childMap = await recursivelyCopyFilesToGcs(child.id);
+        childMap.forEach((v, k) => pathMap.set(k, v));
+    }
+    return pathMap;
+}
+async function recursivelyCreateFiles(tx, folderId, targetFolderId, pathMap) {
+    if (!folderId.length)
+        return;
+    const parentFolder = await tx.folder.findUnique({
+        where: { id: folderId },
+        include: {
+            files: { select: { id: true, name: true, type: true, size: true, path: true } },
+            childFolders: { select: { id: true, name: true, color: true, parentFolderId: true } },
+        },
+    });
+    if (!parentFolder)
+        return;
+    for (const file of parentFolder.files) {
+        const newPath = pathMap.get(file.path);
+        if (!newPath)
+            continue;
+        await tx.file.create({
+            data: {
+                name: file.name,
+                type: file.type,
+                size: file.size,
+                path: newPath,
+                uploadStatus: 'COMPLETED',
+                ...(targetFolderId && { folder: { connect: { id: targetFolderId } } }),
+            },
+        });
+    }
+    for (const childFolder of parentFolder.childFolders) {
+        const newFolder = await tx.folder.create({
+            data: {
+                name: childFolder.name,
+                color: childFolder.color,
+                parentFolderId: targetFolderId ?? parentFolder.id,
+            },
+        });
+        await recursivelyCreateFiles(tx, childFolder.id, newFolder.id, pathMap);
+    }
+}
+export async function findFullExportableClass(classId) {
+    const baseClass = await prisma.class.findUnique({
+        where: { id: classId },
+        include: {
+            assignments: {
+                select: {
+                    ...assignmentSelect,
+                    submissions: false,
+                    worksheets: { select: { id: true } },
+                    teacherId: true,
+                    classId: true,
+                    sectionId: true,
+                    markSchemeId: true,
+                    gradingBoundaryId: true,
+                    eventId: true,
+                    acceptFiles: true,
+                    acceptExtendedResponse: true,
+                    acceptWorksheet: true,
+                    gradeWithAI: true,
+                    aiPolicyLevel: true,
+                },
+            },
+            classFiles: {
+                select: {
+                    id: true,
+                },
+            },
+            worksheets: {
+                select: {
+                    id: true,
+                    name: true,
+                    classId: true,
+                    questions: {
+                        select: {
+                            type: true,
+                            question: true,
+                            answer: true,
+                            points: true,
+                            options: true,
+                            markScheme: true,
+                            order: true,
+                            worksheetId: true,
+                        },
+                    },
+                },
+            },
+            markSchemes: {
+                select: {
+                    id: true,
+                    classId: true,
+                    structured: true,
+                },
+            },
+            gradingBoundaries: {
+                select: {
+                    id: true,
+                    classId: true,
+                    structured: true,
+                },
+            },
+            sections: {
+                select: {
+                    id: true,
+                    name: true,
+                    classId: true,
+                    color: true,
+                    order: true,
+                },
+            },
+        },
+    });
+    if (!baseClass) {
+        return null;
+    }
+    const classFiles = await recursivelyIncludeFiles(baseClass.classFiles?.id ?? "");
+    const formattedClass = {
+        ...baseClass,
+        classFiles,
+    };
+    return formattedClass;
+}
+export async function createClassByImport(classId, userId, year, classData) {
+    const pathMap = classData.classFiles?.id
+        ? await recursivelyCopyFilesToGcs(classData.classFiles.id)
+        : new Map();
+    const newClassId = await prisma.$transaction(async (tx) => {
+        const createdClass = await tx.class.create({
+            data: {
+                name: classData.name,
+                subject: classData.subject,
+                color: classData.color,
+                section: classData.section,
+                syllabus: classData.syllabus,
+                teachers: { connect: { id: userId } },
+                classFiles: { create: { name: "Class Files" } },
+            },
+            include: {
+                classFiles: true,
+            },
+        });
+        const oldSectionIdToNew = new Map();
+        const oldMarkSchemeIdToNew = new Map();
+        const oldGradingBoundaryIdToNew = new Map();
+        const oldWorksheetIdToNew = new Map();
+        const sections = classData.sections ?? [];
+        await Promise.all(sections.map(async (section, index) => {
+            const newSection = await tx.section.create({
+                data: {
+                    name: section.name,
+                    classId: createdClass.id,
+                    color: section.color,
+                    order: section.order ?? index,
+                },
+            });
+            oldSectionIdToNew.set(section.id, newSection.id);
+            return newSection;
+        }));
+        const markSchemes = classData.markSchemes ?? [];
+        await Promise.all(markSchemes.map(async (ms) => {
+            const newMs = await tx.markScheme.create({
+                data: { classId: createdClass.id, structured: ms.structured },
+            });
+            oldMarkSchemeIdToNew.set(ms.id, newMs.id);
+            return newMs;
+        }));
+        const gradingBoundaries = classData.gradingBoundaries ?? [];
+        await Promise.all(gradingBoundaries.map(async (gb) => {
+            const newGb = await tx.gradingBoundary.create({
+                data: { classId: createdClass.id, structured: gb.structured },
+            });
+            oldGradingBoundaryIdToNew.set(gb.id, newGb.id);
+            return newGb;
+        }));
+        const worksheets = classData.worksheets ?? [];
+        for (const worksheet of worksheets) {
+            const newWorksheet = await tx.worksheet.create({
+                data: {
+                    name: worksheet.name,
+                    classId: createdClass.id,
+                    questions: {
+                        create: (worksheet.questions ?? []).map((q, i) => ({
+                            type: q.type,
+                            question: q.question,
+                            answer: q.answer,
+                            points: q.points ?? 0,
+                            options: q.options ?? {},
+                            markScheme: q.markScheme ?? {},
+                            order: q.order ?? i,
+                        })),
+                    },
+                },
+            });
+            oldWorksheetIdToNew.set(worksheet.id, newWorksheet.id);
+        }
+        const assignments = classData.assignments ?? [];
+        for (const assignment of assignments) {
+            const date = new Date(assignment.dueDate);
+            date.setFullYear(year);
+            const worksheetIds = assignment.worksheets?.map((w) => oldWorksheetIdToNew.get(w.id)).filter(Boolean);
+            await tx.assignment.create({
+                data: {
+                    title: assignment.title,
+                    type: assignment.type,
+                    dueDate: date,
+                    instructions: assignment.instructions,
+                    teacherId: userId,
+                    classId: createdClass.id,
+                    sectionId: assignment.sectionId ? oldSectionIdToNew.get(assignment.sectionId) ?? undefined : undefined,
+                    markSchemeId: assignment.markSchemeId ? oldMarkSchemeIdToNew.get(assignment.markSchemeId) ?? undefined : undefined,
+                    gradingBoundaryId: assignment.gradingBoundaryId ? oldGradingBoundaryIdToNew.get(assignment.gradingBoundaryId) ?? undefined : undefined,
+                    weight: assignment.weight ?? 1,
+                    maxGrade: assignment.maxGrade ?? 0,
+                    graded: assignment.graded ?? false,
+                    inProgress: assignment.inProgress ?? false,
+                    template: assignment.template ?? false,
+                    acceptFiles: assignment.acceptFiles ?? false,
+                    acceptExtendedResponse: assignment.acceptExtendedResponse ?? false,
+                    acceptWorksheet: assignment.acceptWorksheet ?? false,
+                    gradeWithAI: assignment.gradeWithAI ?? false,
+                    aiPolicyLevel: assignment.aiPolicyLevel ?? 0,
+                    ...(worksheetIds?.length && { worksheets: { connect: worksheetIds.map((id) => ({ id })) } }),
+                },
+            });
+        }
+        if (classData.classFiles?.id) {
+            await recursivelyCreateFiles(tx, classData.classFiles.id, createdClass.classFiles?.id, pathMap);
+        }
+        return createdClass.id;
+    }, { timeout: 30000 });
+    return newClassId;
+}
+//# sourceMappingURL=class.js.map
+//# debugId=a5a21161-a4bb-58bf-9c4b-a48cc39cfbdb