@studious-lms/server 1.23.0 → 1.24.0

package/src/services/assignment.ts

@@ -28,6 +28,7 @@ import { enqueueRunJob } from "../workers/queues.js";
 import { logger } from "../utils/logger.js";
 import { invalidateStudentProgressInferenceCache } from "./studentProgressInferenceCache.js";
 import { enqueueEmbedding } from "./embedding.js";
+import { resolveAssignmentBehavior } from "../lib/assignmentTypeDefaults.js";
 
 export async function assignmentExists(id: string) {
   const assignment = await findAssignmentById(id);
@@ -117,6 +118,10 @@ export async function createAssignmentRecord(
     gradingBoundaryId?: string;
     inProgress?: boolean;
     sourceAssignmentId?: string;
+    timeLimitMinutes?: number | null;
+    singleAttempt?: boolean;
+    allowLateSubmissions?: boolean;
+    applyTypeDefaults?: boolean;
   }
 ) {
   const {
@@ -128,9 +133,6 @@ export async function createAssignmentRecord(
     files,
     existingFileIds,
     aiPolicyLevel,
-    acceptFiles,
-    acceptExtendedResponse,
-    acceptWorksheet,
     worksheetIds,
     gradeWithAI,
     studentIds,
@@ -145,6 +147,25 @@ export async function createAssignmentRecord(
     sourceAssignmentId,
   } = input;
 
+  const behavior = resolveAssignmentBehavior({
+    type,
+    acceptFiles: input.acceptFiles,
+    acceptExtendedResponse: input.acceptExtendedResponse,
+    acceptWorksheet: input.acceptWorksheet,
+    singleAttempt: input.singleAttempt,
+    allowLateSubmissions: input.allowLateSubmissions,
+    timeLimitMinutes: input.timeLimitMinutes,
+    applyTypeDefaults: input.applyTypeDefaults,
+  });
+  const {
+    acceptFiles,
+    acceptExtendedResponse,
+    acceptWorksheet,
+    singleAttempt,
+    allowLateSubmissions,
+    timeLimitMinutes,
+  } = behavior;
+
   if (sourceAssignmentId && (!studentIds || studentIds.length === 0)) {
     throw new TRPCError({
       code: "BAD_REQUEST",
@@ -206,6 +227,9 @@ export async function createAssignmentRecord(
           acceptFiles,
           acceptExtendedResponse,
           acceptWorksheet,
+          singleAttempt,
+          allowLateSubmissions,
+          ...(timeLimitMinutes !== undefined && { timeLimitMinutes }),
           ...(worksheetIds?.length && {
             worksheets: { connect: worksheetIds.map((id) => ({ id })) },
           }),
@@ -402,6 +426,10 @@ export async function updateAssignmentRecord(
     acceptWorksheet?: boolean;
     gradeWithAI?: boolean;
     studentIds?: string[];
+    timeLimitMinutes?: number | null;
+    singleAttempt?: boolean;
+    allowLateSubmissions?: boolean;
+    applyTypeDefaults?: boolean;
   }
 ) {
   const [assignment, classData] = await Promise.all([
@@ -436,6 +464,38 @@ export async function updateAssignmentRecord(
     });
   }
 
+  const nextType = input.type ?? assignment.type;
+  const behaviorTouched =
+    input.type !== undefined ||
+    input.acceptFiles !== undefined ||
+    input.acceptExtendedResponse !== undefined ||
+    input.acceptWorksheet !== undefined ||
+    input.singleAttempt !== undefined ||
+    input.allowLateSubmissions !== undefined ||
+    input.timeLimitMinutes !== undefined ||
+    input.applyTypeDefaults === true;
+
+  const behavior = behaviorTouched
+    ? resolveAssignmentBehavior({
+        type: nextType,
+        acceptFiles: input.acceptFiles ?? assignment.acceptFiles,
+        acceptExtendedResponse:
+          input.acceptExtendedResponse ?? assignment.acceptExtendedResponse,
+        acceptWorksheet: input.acceptWorksheet ?? assignment.acceptWorksheet,
+        singleAttempt: input.singleAttempt ?? assignment.singleAttempt,
+        allowLateSubmissions:
+          input.allowLateSubmissions ?? assignment.allowLateSubmissions,
+        timeLimitMinutes:
+          input.timeLimitMinutes !== undefined
+            ? input.timeLimitMinutes
+            : assignment.timeLimitMinutes,
+        // On update, only re-apply type defaults when type changes or explicitly requested.
+        applyTypeDefaults:
+          input.applyTypeDefaults === true ||
+          (input.type !== undefined && input.type !== assignment.type),
+      })
+    : null;
+
   const submissionData = input.studentIds
     ? (input.studentIds.length > 0
         ? input.studentIds.map((studentId) => ({ student: { connect: { id: studentId } } }))
@@ -479,13 +539,18 @@ export async function updateAssignmentRecord(
     ...(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,
-    }),
+    ...(behavior
+      ? {
+          acceptFiles: behavior.acceptFiles,
+          acceptExtendedResponse: behavior.acceptExtendedResponse,
+          acceptWorksheet: behavior.acceptWorksheet,
+          singleAttempt: behavior.singleAttempt,
+          allowLateSubmissions: behavior.allowLateSubmissions,
+          ...(behavior.timeLimitMinutes !== undefined && {
+            timeLimitMinutes: behavior.timeLimitMinutes,
+          }),
+        }
+      : {}),
     ...(input.gradeWithAI !== undefined && { gradeWithAI: input.gradeWithAI }),
     ...(input.studentIds && {
       assignedTo: {
@@ -691,9 +756,32 @@ export async function updateSubmissionRecord(
   }
 
   if (submit !== undefined) {
+    const assignment = submission.assignment;
+    const isLate = assignment.dueDate < new Date();
+    const becomingSubmitted = !submission.submitted;
+
+    if (becomingSubmitted && isLate && assignment.allowLateSubmissions === false) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Late submissions are not allowed for this assignment",
+      });
+    }
+
+    // Single-attempt: once submitted, students may not unsubmit.
     if (
-      submission.assignment.acceptWorksheet &&
-      submission.assignment.gradeWithAI
+      !becomingSubmitted &&
+      submission.submitted &&
+      assignment.singleAttempt
+    ) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "This assignment only allows a single attempt",
+      });
+    }
+
+    if (
+      assignment.acceptWorksheet &&
+      assignment.gradeWithAI
     ) {
       const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
         where: { submissionId: submission.id },
@@ -735,6 +823,28 @@ export async function updateSubmissionRecord(
     });
   }
 
+  const isLateUpdate = submission.assignment.dueDate < new Date();
+  if (
+    isLateUpdate &&
+    submission.assignment.allowLateSubmissions === false &&
+    (newAttachments?.length || existingFileIds?.length)
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Late file submissions are not allowed for this assignment",
+    });
+  }
+
+  if (
+    submission.assignment.acceptFiles === false &&
+    newAttachments?.length
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "This assignment does not accept file submissions",
+    });
+  }
+
   let uploadedFiles: UploadedFile[] = [];
   if (newAttachments?.length) {
     uploadedFiles = await createDirectUploadFiles(