@studious-lms/server 1.1.26 → 1.2.6

package/src/models/class.ts

@@ -0,0 +1,598 @@
+
+/**
+ * Class model – classes, members, assignments, grades, mark schemes,
+ * grading boundaries, syllabus, lab drafts, invite codes.
+ */
+
+import { Assignment, Class, Folder, GradingBoundary, MarkScheme, Section, Worksheet } from "@prisma/client";
+import type { PrismaClient } from "@prisma/client";
+
+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,
+        },
+      },
+    },
+  },
+} as const;
+
+/** @returns Classes where user is a teacher. */
+export function findTeacherClasses(userId: string) {
+  return prisma.class.findMany({
+    where: { teachers: { some: { id: userId } } },
+    include: classIncludeForGetAll,
+  });
+}
+
+/** @returns Classes where user is a student. */
+export function findStudentClasses(userId: string) {
+  return prisma.class.findMany({
+    where: { students: { some: { id: userId } } },
+    include: classIncludeForGetAll,
+  });
+}
+
+/** @returns Class if user is a teacher. */
+export function isTeacherInClass(classId: string, userId: string) {
+  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" as const },
+    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,
+        },
+      },
+    },
+  },
+} as const;
+
+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,
+    },
+  },
+} as const;
+
+/** @returns Class with assignments. Students see only assigned; teachers see all. */
+export function findClassWithAssignments(
+  classId: string,
+  options: { isTeacher: boolean; userId?: string }
+) {
+  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: string) {
+  return prisma.class.findUnique({
+    where: { id: classId },
+  });
+}
+
+/** @returns Sections for a class. */
+export function findSectionsByClassId(classId: string) {
+  return prisma.section.findMany({
+    where: { classId },
+  });
+}
+
+/** @returns User by ID (id, username only). */
+export function findUserById(userId: string) {
+  return prisma.user.findUnique({
+    where: { id: userId },
+    select: { id: true, username: true },
+  });
+}
+
+/** @returns Session by class invite code. */
+export function findSessionByClassCode(classCode: string) {
+  return prisma.session.findFirst({
+    where: {
+      id: { equals: classCode, mode: "insensitive" },
+    },
+  });
+}
+
+/** @returns Session for a class. */
+export function findSessionByClassId(classId: string) {
+  return prisma.session.findFirst({
+    where: { classId },
+  });
+}
+
+/** @returns User's graded submissions for grade calculation. */
+export function findSubmissionsForGrades(userId: string, classId: string) {
+  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: string) {
+  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: string) {
+  return prisma.markScheme.findMany({
+    where: { class: { id: classId } },
+  });
+}
+
+/** @returns Grading boundaries for a class. */
+export function findGradingBoundariesByClassId(classId: string) {
+  return prisma.gradingBoundary.findMany({
+    where: { class: { id: classId } },
+  });
+}
+
+/** @returns Class syllabus. */
+export function findClassSyllabus(classId: string) {
+  return prisma.class.findUnique({
+    where: { id: classId },
+    select: { syllabus: true },
+  });
+}
+
+/** @returns In-progress lab drafts for a teacher. */
+export function findLabDraftsByClass(classId: string, teacherId: string) {
+  return prisma.assignment.findMany({
+    where: {
+      classId,
+      teacherId,
+      inProgress: true,
+    },
+    orderBy: { modifiedAt: "desc" as const },
+  });
+}
+
+/** @returns Assignments with attachments and submissions. */
+export function findAssignmentsWithFiles(classId: string) {
+  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" as const },
+  });
+}
+
+async function recursivelyIncludeFiles(folderId: string) {
+  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))),
+  };
+}
+
+async function recursivelyCreateFiles(
+  tx: PrismaClient | Omit<PrismaClient, "$connect" | "$disconnect" | "$on" | "$transaction" | "$use" | "$extends">,
+  folderId: string,
+  targetFolderId?: string
+) {
+  if (!folderId.length) {
+    return null;
+  }
+
+  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 null;
+  }
+
+  const createdFiles: { count: number } = { count: 0 };
+  for (const file of parentFolder.files) {
+    const ext = file.name.split('.').pop() || '';
+    const newPath = `imported/${uuidv4()}${ext ? `.${ext}` : ''}`;
+    await copyFile(file.path, newPath);
+    await tx.file.create({
+      data: {
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        path: newPath,
+        uploadStatus: 'COMPLETED',
+        ...(targetFolderId && { folder: { connect: { id: targetFolderId } } }),
+      },
+    });
+    createdFiles.count += 1;
+  }
+
+  const childFolders: { files: { count: number }; childFolders: unknown[] }[] = [];
+  for (const childFolder of parentFolder.childFolders) {
+    const newFolder = await tx.folder.create({
+      data: {
+        name: childFolder.name,
+        color: childFolder.color,
+        parentFolderId: targetFolderId ?? parentFolder.id,
+      },
+    });
+    const result = await recursivelyCreateFiles(tx, childFolder.id, newFolder.id);
+    if (result) childFolders.push(result);
+  }
+
+  return {
+    files: createdFiles,
+    childFolders,
+  };
+}
+
+
+export async function findFullExportableClass(classId: string) {
+  const baseClass = await prisma.class.findUnique({
+    where: { id: classId },
+    include: {
+      assignments: {
+        select: {
+          ...assignmentSelect,
+          submissions: false,
+        },
+      },
+      classFiles: {
+        select: {
+          id: true,
+        },
+      },
+      worksheets: true,
+      markSchemes: true,
+      gradingBoundaries: true,
+      sections: true,
+    },
+  });
+
+  if (!baseClass) {
+    return null;
+  }
+
+  const classFiles = await recursivelyIncludeFiles(baseClass.classFiles?.id ?? "");
+
+  const formattedClass = {
+    ...baseClass,
+    classFiles,
+  };
+
+  return formattedClass;
+}
+
+export async function createClassByImport(classId: string, userId: string, year: number, classData: Class & { classFiles: Folder | null }): Promise<string | null> {
+  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 assignments = await prisma.assignment.createMany({
+      data: (classData as unknown as Class & { assignments: Assignment[] }).assignments.map((assignment) => {
+        const newDate = new Date(assignment.dueDate).setFullYear(year);
+        return {
+          ...assignment,
+          id: assignment.id,
+          title: assignment.title,
+          type: assignment.type,
+          dueDate: newDate as unknown as Date,
+        };
+      })
+    });
+
+    const worksheets = await prisma.worksheet.createMany({
+      data: (classData as unknown as Class & { worksheets: Worksheet[] }).worksheets.map((worksheet) => {
+        return {
+          ...worksheet,
+          id: worksheet.id,
+          name: worksheet.name,
+        };
+      })
+    });
+
+    const markSchemes = await prisma.markScheme.createMany({
+      data: (classData as unknown as Class & { markSchemes: MarkScheme[] }).markSchemes.map((markScheme) => {
+        return {
+          ...markScheme,
+          id: markScheme.id,
+          structured: markScheme.structured,
+        };
+      })
+    });
+
+    const gradingBoundaries = await prisma.gradingBoundary.createMany({
+      data: (classData as unknown as Class & { gradingBoundaries: GradingBoundary[] }).gradingBoundaries.map((gradingBoundary) => {
+        return {
+          ...gradingBoundary,
+          id: gradingBoundary.id,
+          structured: gradingBoundary.structured,
+        };
+      })
+    });
+
+    const sections = await prisma.section.createMany({
+      data: (classData as unknown as Class & { sections: Section[] }).sections.map((section) => {
+        return {
+          ...section,
+          id: section.id,
+          name: section.name,
+        };
+      })
+    });
+
+    const classFiles = await recursivelyCreateFiles(tx, classData.classFiles?.id ?? uuidv4(), createdClass.classFiles?.id);
+    if (!classFiles) {
+      return null;
+    }
+
+    return createdClass.id;
+
+  });
+
+  return newClassId;
+}