Merge exams grading into homework

Redirect /teacher/exams/grading* to /teacher/homework/submissions; remove exam grading UI/actions/data-access; add homework student workflow and update design docs.
2025-12-31 11:59:03 +08:00
parent f8e39f518d
commit 13e91e628d
36 changed files with 4491 additions and 452 deletions
--- a/src/modules/homework/actions.ts
+++ b/src/modules/homework/actions.ts
@@ -0,0 +1,366 @@
+"use server"
+
+import { revalidatePath } from "next/cache"
+import { headers } from "next/headers"
+import { createId } from "@paralleldrive/cuid2"
+import { and, count, eq } from "drizzle-orm"
+
+import { db } from "@/shared/db"
+import {
+  exams,
+  homeworkAnswers,
+  homeworkAssignmentQuestions,
+  homeworkAssignmentTargets,
+  homeworkAssignments,
+  homeworkSubmissions,
+  users,
+} from "@/shared/db/schema"
+import type { ActionState } from "@/shared/types/action-state"
+
+import { CreateHomeworkAssignmentSchema, GradeHomeworkSchema } from "./schema"
+
+type CurrentUser = { id: string; role: "admin" | "teacher" | "student" }
+
+async function getCurrentUser() {
+  const ref = (await headers()).get("referer") || ""
+  const roleHint: CurrentUser["role"] = ref.includes("/admin/")
+    ? "admin"
+    : ref.includes("/student/")
+      ? "student"
+      : ref.includes("/teacher/")
+        ? "teacher"
+        : "teacher"
+
+  const byRole = await db.query.users.findFirst({
+    where: eq(users.role, roleHint),
+    orderBy: (u, { asc }) => [asc(u.createdAt)],
+  })
+
+  if (byRole) return { id: byRole.id, role: roleHint }
+
+  const anyUser = await db.query.users.findFirst({
+    orderBy: (u, { asc }) => [asc(u.createdAt)],
+  })
+
+  if (anyUser) return { id: anyUser.id, role: roleHint }
+
+  return { id: "user_teacher_123", role: roleHint }
+}
+
+async function ensureTeacher() {
+  const user = await getCurrentUser()
+  if (!user || (user.role !== "teacher" && user.role !== "admin")) throw new Error("Unauthorized")
+  return user
+}
+
+async function ensureStudent() {
+  const user = await getCurrentUser()
+  if (!user || user.role !== "student") throw new Error("Unauthorized")
+  return user
+}
+
+const parseStudentIds = (raw: string): string[] => {
+  return raw
+    .split(/[,\n\r\t ]+/g)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0)
+}
+
+export async function createHomeworkAssignmentAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  try {
+    const user = await ensureTeacher()
+
+    const targetStudentIdsJson = formData.get("targetStudentIdsJson")
+    const targetStudentIdsText = formData.get("targetStudentIdsText")
+
+    const parsed = CreateHomeworkAssignmentSchema.safeParse({
+      sourceExamId: formData.get("sourceExamId"),
+      title: formData.get("title") || undefined,
+      description: formData.get("description") || undefined,
+      availableAt: formData.get("availableAt") || undefined,
+      dueAt: formData.get("dueAt") || undefined,
+      allowLate: formData.get("allowLate") || undefined,
+      lateDueAt: formData.get("lateDueAt") || undefined,
+      maxAttempts: formData.get("maxAttempts") || undefined,
+      publish: formData.get("publish") || undefined,
+      targetStudentIds:
+        typeof targetStudentIdsJson === "string" && targetStudentIdsJson.length > 0
+          ? (JSON.parse(targetStudentIdsJson) as unknown)
+          : typeof targetStudentIdsText === "string" && targetStudentIdsText.trim().length > 0
+            ? parseStudentIds(targetStudentIdsText)
+            : undefined,
+    })
+
+    if (!parsed.success) {
+      return {
+        success: false,
+        message: "Invalid form data",
+        errors: parsed.error.flatten().fieldErrors,
+      }
+    }
+
+    const input = parsed.data
+    const publish = input.publish ?? true
+
+    const exam = await db.query.exams.findFirst({
+      where: eq(exams.id, input.sourceExamId),
+      with: {
+        questions: {
+          orderBy: (examQuestions, { asc }) => [asc(examQuestions.order)],
+        },
+      },
+    })
+
+    if (!exam) return { success: false, message: "Exam not found" }
+
+    const assignmentId = createId()
+
+    const availableAt = input.availableAt ? new Date(input.availableAt) : null
+    const dueAt = input.dueAt ? new Date(input.dueAt) : null
+    const lateDueAt = input.lateDueAt ? new Date(input.lateDueAt) : null
+
+    const targetStudentIds =
+      input.targetStudentIds && input.targetStudentIds.length > 0
+        ? input.targetStudentIds
+        : (
+            await db
+              .select({ id: users.id })
+              .from(users)
+              .where(eq(users.role, "student"))
+          ).map((r) => r.id)
+
+    await db.transaction(async (tx) => {
+      await tx.insert(homeworkAssignments).values({
+        id: assignmentId,
+        sourceExamId: input.sourceExamId,
+        title: input.title?.trim().length ? input.title.trim() : exam.title,
+        description: input.description ?? null,
+        structure: publish ? (exam.structure as unknown) : null,
+        status: publish ? "published" : "draft",
+        creatorId: user.id,
+        availableAt,
+        dueAt,
+        allowLate: input.allowLate ?? false,
+        lateDueAt,
+        maxAttempts: input.maxAttempts ?? 1,
+      })
+
+      if (publish && exam.questions.length > 0) {
+        await tx.insert(homeworkAssignmentQuestions).values(
+          exam.questions.map((q) => ({
+            assignmentId,
+            questionId: q.questionId,
+            score: q.score ?? 0,
+            order: q.order ?? 0,
+          }))
+        )
+      }
+
+      if (publish && targetStudentIds.length > 0) {
+        await tx.insert(homeworkAssignmentTargets).values(
+          targetStudentIds.map((studentId) => ({
+            assignmentId,
+            studentId,
+          }))
+        )
+      }
+    })
+
+    revalidatePath("/teacher/homework/assignments")
+    revalidatePath("/teacher/homework/submissions")
+
+    return { success: true, message: "Assignment created", data: assignmentId }
+  } catch (error) {
+    if (error instanceof Error) return { success: false, message: error.message }
+    return { success: false, message: "Unexpected error" }
+  }
+}
+
+export async function startHomeworkSubmissionAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  try {
+    const user = await ensureStudent()
+    const assignmentId = formData.get("assignmentId")
+    if (typeof assignmentId !== "string" || assignmentId.length === 0) return { success: false, message: "Missing assignmentId" }
+
+    const assignment = await db.query.homeworkAssignments.findFirst({
+      where: eq(homeworkAssignments.id, assignmentId),
+    })
+    if (!assignment) return { success: false, message: "Assignment not found" }
+    if (assignment.status !== "published") return { success: false, message: "Assignment not available" }
+
+    const target = await db.query.homeworkAssignmentTargets.findFirst({
+      where: and(eq(homeworkAssignmentTargets.assignmentId, assignmentId), eq(homeworkAssignmentTargets.studentId, user.id)),
+    })
+    if (!target) return { success: false, message: "Not assigned" }
+
+    if (assignment.availableAt && assignment.availableAt > new Date()) return { success: false, message: "Not available yet" }
+
+    const [attemptRow] = await db
+      .select({ c: count() })
+      .from(homeworkSubmissions)
+      .where(and(eq(homeworkSubmissions.assignmentId, assignmentId), eq(homeworkSubmissions.studentId, user.id)))
+
+    const attemptNo = (attemptRow?.c ?? 0) + 1
+    if (attemptNo > assignment.maxAttempts) return { success: false, message: "No attempts left" }
+
+    const submissionId = createId()
+    await db.insert(homeworkSubmissions).values({
+      id: submissionId,
+      assignmentId,
+      studentId: user.id,
+      attemptNo,
+      status: "started",
+      startedAt: new Date(),
+    })
+
+    revalidatePath("/student/learning/assignments")
+
+    return { success: true, message: "Started", data: submissionId }
+  } catch (error) {
+    if (error instanceof Error) return { success: false, message: error.message }
+    return { success: false, message: "Unexpected error" }
+  }
+}
+
+export async function saveHomeworkAnswerAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  try {
+    const user = await ensureStudent()
+    const submissionId = formData.get("submissionId")
+    const questionId = formData.get("questionId")
+    const answerJson = formData.get("answerJson")
+    if (typeof submissionId !== "string" || submissionId.length === 0) return { success: false, message: "Missing submissionId" }
+    if (typeof questionId !== "string" || questionId.length === 0) return { success: false, message: "Missing questionId" }
+
+    const submission = await db.query.homeworkSubmissions.findFirst({
+      where: eq(homeworkSubmissions.id, submissionId),
+      with: { assignment: true },
+    })
+    if (!submission) return { success: false, message: "Submission not found" }
+    if (submission.studentId !== user.id) return { success: false, message: "Unauthorized" }
+    if (submission.status !== "started") return { success: false, message: "Submission is locked" }
+
+    const payload = typeof answerJson === "string" && answerJson.length > 0 ? JSON.parse(answerJson) : null
+
+    await db.transaction(async (tx) => {
+      const existing = await tx.query.homeworkAnswers.findFirst({
+        where: and(eq(homeworkAnswers.submissionId, submissionId), eq(homeworkAnswers.questionId, questionId)),
+      })
+
+      if (existing) {
+        await tx
+          .update(homeworkAnswers)
+          .set({ answerContent: payload, updatedAt: new Date() })
+          .where(eq(homeworkAnswers.id, existing.id))
+      } else {
+        await tx.insert(homeworkAnswers).values({
+          id: createId(),
+          submissionId,
+          questionId,
+          answerContent: payload,
+        })
+      }
+    })
+
+    return { success: true, message: "Saved", data: submissionId }
+  } catch (error) {
+    if (error instanceof Error) return { success: false, message: error.message }
+    return { success: false, message: "Unexpected error" }
+  }
+}
+
+export async function submitHomeworkAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  try {
+    const user = await ensureStudent()
+    const submissionId = formData.get("submissionId")
+    if (typeof submissionId !== "string" || submissionId.length === 0) return { success: false, message: "Missing submissionId" }
+
+    const submission = await db.query.homeworkSubmissions.findFirst({
+      where: eq(homeworkSubmissions.id, submissionId),
+      with: { assignment: true },
+    })
+    if (!submission) return { success: false, message: "Submission not found" }
+    if (submission.studentId !== user.id) return { success: false, message: "Unauthorized" }
+    if (submission.status !== "started") return { success: false, message: "Already submitted" }
+
+    const now = new Date()
+    const dueAt = submission.assignment.dueAt
+    const allowLate = submission.assignment.allowLate
+    const lateDueAt = submission.assignment.lateDueAt
+
+    if (dueAt && now > dueAt && !allowLate) return { success: false, message: "Past due" }
+    if (allowLate && lateDueAt && now > lateDueAt) return { success: false, message: "Past late due" }
+
+    const isLate = Boolean(dueAt && now > dueAt)
+
+    await db
+      .update(homeworkSubmissions)
+      .set({ status: "submitted", submittedAt: now, isLate, updatedAt: now })
+      .where(eq(homeworkSubmissions.id, submissionId))
+
+    revalidatePath("/teacher/homework/submissions")
+    revalidatePath("/student/learning/assignments")
+
+    return { success: true, message: "Submitted", data: submissionId }
+  } catch (error) {
+    if (error instanceof Error) return { success: false, message: error.message }
+    return { success: false, message: "Unexpected error" }
+  }
+}
+
+export async function gradeHomeworkSubmissionAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  try {
+    await ensureTeacher()
+
+    const rawAnswers = formData.get("answersJson") as string | null
+    const parsed = GradeHomeworkSchema.safeParse({
+      submissionId: formData.get("submissionId"),
+      answers: rawAnswers ? JSON.parse(rawAnswers) : [],
+    })
+
+    if (!parsed.success) {
+      return {
+        success: false,
+        message: "Invalid grading data",
+        errors: parsed.error.flatten().fieldErrors,
+      }
+    }
+
+    const { submissionId, answers } = parsed.data
+    let totalScore = 0
+
+    for (const ans of answers) {
+      await db
+        .update(homeworkAnswers)
+        .set({ score: ans.score, feedback: ans.feedback ?? null, updatedAt: new Date() })
+        .where(eq(homeworkAnswers.id, ans.id))
+      totalScore += ans.score
+    }
+
+    await db
+      .update(homeworkSubmissions)
+      .set({ score: totalScore, status: "graded", updatedAt: new Date() })
+      .where(eq(homeworkSubmissions.id, submissionId))
+
+    revalidatePath("/teacher/homework/submissions")
+
+    return { success: true, message: "Grading saved" }
+  } catch (error) {
+    if (error instanceof Error) return { success: false, message: error.message }
+    return { success: false, message: "Unexpected error" }
+  }
+}