@studious-lms/server 1.3.0 → 1.4.1

package/src/models/class.ts

@@ -5,7 +5,7 @@
  */
 
 import { Assignment, Class, Folder, GradingBoundary, MarkScheme, Section, Worksheet } from "@prisma/client";
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient, WorksheetQuestion } from "@prisma/client";
 
 import { prisma } from "../lib/prisma.js";
 import { v4 as uuidv4 } from 'uuid';
@@ -417,35 +417,53 @@ async function recursivelyIncludeFiles(folderId: string) {
   };
 }
 
+/** Copy all files in folder tree to GCS (outside transaction). Returns map of sourcePath -> newPath. */
+async function recursivelyCopyFilesToGcs(folderId: string): Promise<Map<string, string>> {
+  const pathMap = new Map<string, string>();
+  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: PrismaClient | Omit<PrismaClient, "$connect" | "$disconnect" | "$on" | "$transaction" | "$use" | "$extends">,
   folderId: string,
-  targetFolderId?: string
+  targetFolderId: string | undefined,
+  pathMap: Map<string, string>
 ) {
-  if (!folderId.length) {
-    return null;
-  }
+  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 },
-      },
+      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;
-  }
+  if (!parentFolder) return;
 
-  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);
+    const newPath = pathMap.get(file.path);
+    if (!newPath) continue;
     await tx.file.create({
       data: {
         name: file.name,
@@ -456,10 +474,8 @@ async function recursivelyCreateFiles(
         ...(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: {
@@ -468,14 +484,8 @@ async function recursivelyCreateFiles(
         parentFolderId: targetFolderId ?? parentFolder.id,
       },
     });
-    const result = await recursivelyCreateFiles(tx, childFolder.id, newFolder.id);
-    if (result) childFolders.push(result);
+    await recursivelyCreateFiles(tx, childFolder.id, newFolder.id, pathMap);
   }
-
-  return {
-    files: createdFiles,
-    childFolders,
-  };
 }
 
 
@@ -487,6 +497,18 @@ export async function findFullExportableClass(classId: string) {
         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: {
@@ -494,10 +516,48 @@ export async function findFullExportableClass(classId: string) {
           id: true,
         },
       },
-      worksheets: true,
-      markSchemes: true,
-      gradingBoundaries: true,
-      sections: 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,
+        },
+      },
     },
   });
 
@@ -516,6 +576,10 @@ export async function findFullExportableClass(classId: string) {
 }
 
 export async function createClassByImport(classId: string, userId: string, year: number, classData: Class & { classFiles: Folder | null }): Promise<string | null> {
+  const pathMap = classData.classFiles?.id
+    ? await recursivelyCopyFilesToGcs(classData.classFiles.id)
+    : new Map<string, string>();
+
   const newClassId = await prisma.$transaction(async (tx) => {
     const createdClass = await tx.class.create({
       data: {
@@ -532,67 +596,108 @@ export async function createClassByImport(classId: string, userId: string, year:
       },
     });
 
-    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 oldSectionIdToNew = new Map<string, string>();
+    const oldMarkSchemeIdToNew = new Map<string, string>();
+    const oldGradingBoundaryIdToNew = new Map<string, string>();
+    const oldWorksheetIdToNew = new Map<string, string>();
+
+    const sections = (classData as unknown as Class & { sections: Section[] }).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 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 = (classData as unknown as Class & { markSchemes: MarkScheme[] }).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 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 = (classData as unknown as Class & { gradingBoundaries: GradingBoundary[] }).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 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 worksheets = (classData as unknown as Class & { worksheets: Array<Worksheet & { questions: WorksheetQuestion[] }> }).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 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 assignments = (classData as unknown as Class & { assignments: Array<Assignment & { worksheets?: { id: string }[] }> }).assignments ?? [];
+    for (const assignment of assignments) {
+      const date = new Date(assignment.dueDate);
+      date.setFullYear(year);
+      const worksheetIds = (assignment as { worksheets?: { id: string }[] }).worksheets?.map((w) => oldWorksheetIdToNew.get(w.id)).filter(Boolean) as string[] | undefined;
+      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 })) } }),
+        },
+      });
+    }
 
-    const classFiles = await recursivelyCreateFiles(tx, classData.classFiles?.id ?? uuidv4(), createdClass.classFiles?.id);
-    if (!classFiles) {
-      return null;
+    if (classData.classFiles?.id) {
+      await recursivelyCreateFiles(tx, classData.classFiles.id, createdClass.classFiles?.id, pathMap);
     }
 
     return createdClass.id;
-
-  });
+  }, { timeout: 30000 });
 
   return newClassId;
-}
+}