Merge pull request #86 from codegasms/feat/submit-on-submit

Submit on submit

Author: virinci

app/[orgId]/contests/[id]/page.tsx

@@ -225,7 +225,9 @@ export default function ContestDetailsPage() {
                 {contestData.problems.map(
                   (problem: { id: string; title: string }) => (
                     <li key={problem.id}>
-                      <Link href={`/${orgId}/problems/${problem.id}`}>
+                      <Link
+                        href={`/${orgId}/contests/${contestId}/problems/${problem.id}`}
+                      >
                         <Button
                           variant="link"
                           className="p-0 h-auto text-primary hover:text-primary/80"

app/[orgId]/contests/[id]/problems/[problemId]/page.tsx

@@ -0,0 +1,55 @@
+import { CodeEditor } from "@/components/code-editor";
+import { notFound } from "next/navigation";
+
+async function getProblem(orgId: string, contestId: string, problemId: string) {
+  console.log(
+    `ENV: ${process.env.NEXT_PUBLIC_APP_URL}`,
+    orgId,
+    contestId,
+    problemId,
+  );
+
+  try {
+    // Fetch the problem with contest context
+    const response = await fetch(
+      `${process.env.NEXT_PUBLIC_APP_URL}/api/orgs/${orgId}/contests/${contestId}/problems/${problemId}`,
+      {
+        cache: "no-store",
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error("Failed to fetch problem");
+    }
+
+    const problem = await response.json();
+
+    // Add the contest ID to the problem data
+    return {
+      ...problem,
+      contestNameId: contestId,
+      orgId,
+    };
+  } catch (error) {
+    console.error("Error fetching problem:", error);
+    return null;
+  }
+}
+
+export default async function Page({
+  params,
+}: {
+  params: { orgId: string; id: string; problemId: string };
+}) {
+  const problem = await getProblem(params.orgId, params.id, params.problemId);
+
+  if (!problem) {
+    notFound();
+  }
+
+  return (
+    <>
+      <CodeEditor problem={problem} />
+    </>
+  );
+}

app/[orgId]/problems/[id]/page.tsx

@@ -19,7 +19,13 @@ async function getProblem(orgId: string, problemId: string) {
       throw new Error("Failed to fetch problem");
     }
 
-    return response.json();
+    // Return the problem without adding contestId
+    const problem = await response.json();
+    return {
+      ...problem,
+      orgId,
+      // No contestId here, as this is a standalone problem
+    };
   } catch (error) {
     console.error("Error fetching problem:", error);
     return null;

app/api/me/service.ts

@@ -10,9 +10,10 @@ interface Org {
 }
 
 interface User {
-  _id: number;
+  id: number;
   email: string;
   name: string;
+  nameId: string;
   orgs: Org[];
   isSuperuser: boolean;
 }
@@ -23,6 +24,7 @@ export async function getUserWithOrgs(userId: number): Promise<User | null> {
       userId: users.id,
       email: users.email,
       name: users.name,
+      nameId: users.nameId,
       isSuperuser: users.isSuperuser,
       orgId: orgs.id,
       orgName: orgs.name,
@@ -42,9 +44,10 @@ export async function getUserWithOrgs(userId: number): Promise<User | null> {
   const userData = result[0];
 
   return {
-    _id: userData.userId,
+    id: userData.userId,
     email: userData.email,
     name: userData.name,
+    nameId: userData.nameId,
     isSuperuser: userData.isSuperuser,
     orgs: result
       .filter((row) => row.orgId !== null) // Filter out null orgs from left join

app/api/orgs/[orgId]/contests/[contestId]/problems/[problemId]/route.ts

@@ -3,41 +3,98 @@ import { z } from "zod";
 import { NameIdSchema } from "@/lib/validations";
 import { getOrgIdFromNameId, getContestIdFromNameId } from "@/app/api/service";
 import * as problemService from "./service";
+import { db } from "@/db/drizzle";
+import { problems, contestProblems, contests, testCases } from "@/db/schema";
+import { eq, and } from "drizzle-orm";
+import { IdSchema } from "@/app/api/types";
 
 export async function GET(
-  _req: NextRequest,
+  request: NextRequest,
   {
     params,
   }: { params: { orgId: string; contestId: string; problemId: string } },
 ) {
   try {
-    const orgId = await getOrgIdFromNameId(NameIdSchema.parse(params.orgId));
-    const contestId = await getContestIdFromNameId(
-      orgId,
-      NameIdSchema.parse(params.contestId),
-    );
-    const problemCode = NameIdSchema.parse(params.problemId);
+    // Parse and validate parameters
+    const orgNameId = NameIdSchema.parse(params.orgId);
+    const contestNameId = NameIdSchema.parse(params.contestId);
+    const problemId = params.problemId;
+
+    // Get numeric orgId
+    const orgId = await getOrgIdFromNameId(orgNameId);
+
+    // Find the contest by nameId
+    const contestResult = await db
+      .select({ id: contests.id })
+      .from(contests)
+      .where(
+        and(
+          eq(contests.nameId, contestNameId),
+          eq(contests.organizerId, orgId),
+          eq(contests.organizerKind, "org"),
+        ),
+      )
+      .limit(1);
+
+    if (contestResult.length === 0) {
+      return NextResponse.json(
+        { message: "Contest not found" },
+        { status: 404 },
+      );
+    }
+
+    const contestId = contestResult[0].id;
+
+    // Find the problem and its associated contest problem
+    const problemResult = await db
+      .select({
+        problem: problems,
+        contestProblem: contestProblems,
+      })
+      .from(problems)
+      .innerJoin(
+        contestProblems,
+        and(
+          eq(contestProblems.problemId, problems.id),
+          eq(contestProblems.contestId, contestId),
+        ),
+      )
+      .where(eq(problems.code, problemId))
+      .limit(1);
+
+    if (problemResult.length === 0) {
+      return NextResponse.json(
+        { message: "Problem not found in this contest" },
+        { status: 404 },
+      );
+    }
 
-    const problem = await problemService.getContestProblem(
+    // Get test cases for the problem
+    const testCasesResult = await db
+      .select()
+      .from(testCases)
+      .where(eq(testCases.problemId, problemResult[0].problem.id));
+
+    // Combine the data
+    const problem = {
+      ...problemResult[0].problem,
+      contestProblemId: problemResult[0].contestProblem.id,
+      testCases: testCasesResult.map((tc) => ({
+        input: tc.input,
+        output: tc.output,
+        kind: tc.kind,
+      })),
+      orgId,
       contestId,
-      problemCode,
-    );
+    };
+
     return NextResponse.json(problem);
   } catch (error) {
     if (error instanceof z.ZodError) {
-      return NextResponse.json({ error: error.errors }, { status: 400 });
-    }
-    if (error instanceof Error) {
-      if (
-        error.message === "Organization not found" ||
-        error.message === "Contest not found" ||
-        error.message === "Problem not found"
-      ) {
-        return NextResponse.json({ error: error.message }, { status: 404 });
-      }
+      return NextResponse.json({ errors: error.errors }, { status: 400 });
     }
     return NextResponse.json(
-      { error: "Failed to fetch contest problem" },
+      { message: "Failed to fetch problem" },
       { status: 500 },
     );
   }

app/api/orgs/[orgId]/submissions/route.ts

@@ -68,9 +68,17 @@ export async function POST(
   { params }: { params: { orgId: string } },
 ) {
   try {
-    const orgId = IdSchema.parse(params.orgId);
-    const data = createSubmissionSchema.parse(await request.json());
+    const orgNameId = NameIdSchema.parse(params.orgId);
+    const orgId = await getOrgIdFromNameId(orgNameId);
+
+    const requestData = await request.json();
+    console.log("requestData", requestData);
+
+    // Parse the submission data including the userId and contestNameId
+    const data = createSubmissionSchema.parse(requestData);
+    console.log("data", data);
 
+    // Pass the data to the service which will handle the contestNameId
     const submission = await submissionService.createSubmission(orgId, data);
     return NextResponse.json(submission, { status: 201 });
   } catch (error) {