sync-docs-and-fixes

src/modules/questions/actions.ts

@@ -1,29 +1,51 @@
 "use server";
 
 import { db } from "@/shared/db";
-import { questions, questionsToKnowledgePoints } from "@/shared/db/schema";
+import { chapters, knowledgePoints, questions, questionsToKnowledgePoints, textbooks, roles, users, usersToRoles } from "@/shared/db/schema";
 import { CreateQuestionSchema } from "./schema";
 import type { CreateQuestionInput } from "./schema";
 import { ActionState } from "@/shared/types/action-state";
 import { revalidatePath } from "next/cache";
 import { createId } from "@paralleldrive/cuid2";
-import { and, eq } from "drizzle-orm";
+import { and, asc, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 import { getQuestions, type GetQuestionsParams } from "./data-access";
+import type { KnowledgePointOption } from "./types";
+import { auth } from "@/auth";
 
-async function getCurrentUser() {
-  return {
-    id: "user_teacher_math",
-    role: "teacher",
-  };
-}
+const getSessionUserId = async (): Promise<string | null> => {
+  const session = await auth();
+  const userId = String(session?.user?.id ?? "").trim();
+  return userId.length > 0 ? userId : null;
+};
 
 async function ensureTeacher() {
-  const user = await getCurrentUser();
-  if (!user || (user.role !== "teacher" && user.role !== "admin")) {
+  const userId = await getSessionUserId();
+  if (!userId) {
+    const [fallback] = await db
+      .select({ id: users.id, role: roles.name })
+      .from(users)
+      .innerJoin(usersToRoles, eq(usersToRoles.userId, users.id))
+      .innerJoin(roles, eq(usersToRoles.roleId, roles.id))
+      .where(inArray(roles.name, ["teacher", "admin"]))
+      .orderBy(asc(users.createdAt))
+      .limit(1);
+    if (!fallback) {
+      throw new Error("Unauthorized: Only teachers can perform this action.");
+    }
+    return { id: fallback.id, role: fallback.role as "teacher" | "admin" };
+  }
+  const [row] = await db
+    .select({ id: users.id, role: roles.name })
+    .from(users)
+    .innerJoin(usersToRoles, eq(usersToRoles.userId, users.id))
+    .innerJoin(roles, eq(usersToRoles.roleId, roles.id))
+    .where(and(eq(users.id, userId), inArray(roles.name, ["teacher", "admin"])))
+    .limit(1);
+  if (!row) {
     throw new Error("Unauthorized: Only teachers can perform this action.");
   }
-  return user;
+  return { id: row.id, role: row.role as "teacher" | "admin" };
 }
 
 type Tx = Parameters<Parameters<typeof db.transaction>[0]>[0]
@@ -244,3 +266,40 @@ export async function getQuestionsAction(params: GetQuestionsParams) {
   await ensureTeacher();
   return await getQuestions(params);
 }
+
+export async function getKnowledgePointOptionsAction(): Promise<KnowledgePointOption[]> {
+  await ensureTeacher();
+
+  const rows = await db
+    .select({
+      id: knowledgePoints.id,
+      name: knowledgePoints.name,
+      chapterId: chapters.id,
+      chapterTitle: chapters.title,
+      textbookId: textbooks.id,
+      textbookTitle: textbooks.title,
+      subject: textbooks.subject,
+      grade: textbooks.grade,
+    })
+    .from(knowledgePoints)
+    .leftJoin(chapters, eq(chapters.id, knowledgePoints.chapterId))
+    .leftJoin(textbooks, eq(textbooks.id, chapters.textbookId))
+    .orderBy(
+      asc(textbooks.title),
+      asc(chapters.order),
+      asc(chapters.title),
+      asc(knowledgePoints.order),
+      asc(knowledgePoints.name)
+    );
+
+  return rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    chapterId: row.chapterId ?? null,
+    chapterTitle: row.chapterTitle ?? null,
+    textbookId: row.textbookId ?? null,
+    textbookTitle: row.textbookTitle ?? null,
+    subject: row.subject ?? null,
+    grade: row.grade ?? null,
+  }));
+}