Module Update

src/modules/exams/actions.ts

@@ -0,0 +1,244 @@
+"use server"
+
+import { revalidatePath } from "next/cache"
+import { ActionState } from "@/shared/types/action-state"
+import { z } from "zod"
+import { createId } from "@paralleldrive/cuid2"
+import { db } from "@/shared/db"
+import { exams, examQuestions, submissionAnswers, examSubmissions } from "@/shared/db/schema"
+import { eq } from "drizzle-orm"
+
+const ExamCreateSchema = z.object({
+  title: z.string().min(1),
+  subject: z.string().min(1),
+  grade: z.string().min(1),
+  difficulty: z.coerce.number().int().min(1).max(5),
+  totalScore: z.coerce.number().int().min(1),
+  durationMin: z.coerce.number().int().min(1),
+  scheduledAt: z.string().optional().nullable(),
+  questions: z
+    .array(
+      z.object({
+        id: z.string(),
+        score: z.coerce.number().int().min(0),
+      })
+    )
+    .optional(),
+})
+
+export async function createExamAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  const rawQuestions = formData.get("questionsJson") as string | null
+
+  const parsed = ExamCreateSchema.safeParse({
+    title: formData.get("title"),
+    subject: formData.get("subject"),
+    grade: formData.get("grade"),
+    difficulty: formData.get("difficulty"),
+    totalScore: formData.get("totalScore"),
+    durationMin: formData.get("durationMin"),
+    scheduledAt: formData.get("scheduledAt"),
+    questions: rawQuestions ? JSON.parse(rawQuestions) : [],
+  })
+
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: "Invalid form data",
+      errors: parsed.error.flatten().fieldErrors,
+    }
+  }
+
+  const input = parsed.data
+
+  const examId = createId()
+  const scheduled = input.scheduledAt || undefined
+
+  const meta = {
+    subject: input.subject,
+    grade: input.grade,
+    difficulty: input.difficulty,
+    totalScore: input.totalScore,
+    durationMin: input.durationMin,
+    scheduledAt: scheduled ?? undefined,
+  }
+
+  try {
+    const user = await getCurrentUser()
+    await db.insert(exams).values({
+      id: examId,
+      title: input.title,
+      description: JSON.stringify(meta),
+      creatorId: user?.id ?? "user_teacher_123",
+      startTime: scheduled ? new Date(scheduled) : null,
+      status: "draft",
+    })
+  } catch (error) {
+    console.error("Failed to create exam:", error)
+    return {
+      success: false,
+      message: "Database error: Failed to create exam",
+    }
+  }
+
+  revalidatePath("/teacher/exams/all")
+
+  return {
+    success: true,
+    message: "Exam created successfully.",
+    data: examId,
+  }
+}
+
+const ExamUpdateSchema = z.object({
+  examId: z.string().min(1),
+  questions: z
+    .array(
+      z.object({
+        id: z.string(),
+        score: z.coerce.number().int().min(0),
+      })
+    )
+    .default([]),
+  structure: z.any().optional(), // Accept structure JSON
+  status: z.enum(["draft", "published", "archived"]).optional(),
+})
+
+export async function updateExamAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  const rawQuestions = formData.get("questionsJson") as string | null
+  const rawStructure = formData.get("structureJson") as string | null
+  
+  const parsed = ExamUpdateSchema.safeParse({
+    examId: formData.get("examId"),
+    questions: rawQuestions ? JSON.parse(rawQuestions) : [],
+    structure: rawStructure ? JSON.parse(rawStructure) : undefined,
+    status: formData.get("status") ?? undefined,
+  })
+
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: "Invalid update data",
+      errors: parsed.error.flatten().fieldErrors,
+    }
+  }
+
+  const { examId, questions, structure, status } = parsed.data
+
+  try {
+    await db.delete(examQuestions).where(eq(examQuestions.examId, examId))
+    if (questions.length > 0) {
+      await db.insert(examQuestions).values(
+        questions.map((q, idx) => ({
+          examId,
+          questionId: q.id,
+          score: q.score ?? 0,
+          order: idx,
+        }))
+      )
+    }
+    
+    // Prepare update object
+    const updateData: any = {}
+    if (status) updateData.status = status
+    if (structure) updateData.structure = structure
+    
+    if (Object.keys(updateData).length > 0) {
+      await db.update(exams).set(updateData).where(eq(exams.id, examId))
+    }
+    
+  } catch (error) {
+    console.error("Failed to update exam:", error)
+    return {
+      success: false,
+      message: "Database error: Failed to update exam",
+    }
+  }
+
+  revalidatePath("/teacher/exams/all")
+
+  return {
+    success: true,
+    message: "Exam updated",
+    data: examId,
+  }
+}
+
+const GradingSchema = z.object({
+  submissionId: z.string().min(1),
+  answers: z.array(z.object({
+    id: z.string(), // answer id
+    score: z.coerce.number().min(0),
+    feedback: z.string().optional()
+  }))
+})
+
+export async function gradeSubmissionAction(
+  prevState: ActionState<string> | null,
+  formData: FormData
+): Promise<ActionState<string>> {
+  const rawAnswers = formData.get("answersJson") as string | null
+  const parsed = GradingSchema.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
+
+  try {
+    let totalScore = 0
+
+    // Update each answer
+    for (const ans of answers) {
+      await db.update(submissionAnswers)
+        .set({ 
+          score: ans.score,
+          feedback: ans.feedback,
+          updatedAt: new Date()
+        })
+        .where(eq(submissionAnswers.id, ans.id))
+      
+      totalScore += ans.score
+    }
+
+    // Update submission total score and status
+    await db.update(examSubmissions)
+      .set({ 
+        score: totalScore,
+        status: "graded",
+        updatedAt: new Date()
+      })
+      .where(eq(examSubmissions.id, submissionId))
+
+  } catch (error) {
+    console.error("Grading failed:", error)
+    return {
+      success: false,
+      message: "Database error during grading"
+    }
+  }
+
+  revalidatePath(`/teacher/exams/grading`)
+  
+  return {
+    success: true,
+    message: "Grading saved successfully"
+  }
+}
+
+async function getCurrentUser() {
+  return { id: "user_teacher_123", role: "teacher" }
+}