Staging badges

app/(home)/layout.tsx

@@ -4,8 +4,10 @@ import type { ReactNode } from "react";
 import { Footer } from "@/components/navigation/footer";
 import { baseOptions } from "@/app/layout.config";
 import { SessionProvider, useSession } from "next-auth/react";
-import { useEffect, Suspense } from "react";
+import { useEffect, Suspense, useState } from "react";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import Modal from "@/components/ui/Modal";
+import { Button } from "@/components/ui/button";
 import { LayoutWrapper } from "@/app/layout-wrapper.client";
 import { NavbarDropdownInjector } from "@/components/navigation/navbar-dropdown-injector";
 
@@ -33,6 +35,7 @@ function RedirectIfNewUser() {
   const pathname = usePathname();
   const router = useRouter();
   const searchParams = useSearchParams();
+  const [showModal, setShowModal] = useState(false);
 
   useEffect(() => {
     if (
@@ -45,9 +48,38 @@ function RedirectIfNewUser() {
       if (typeof window !== "undefined") {
         localStorage.setItem("redirectAfterProfile", originalUrl);
       }
+
+      // Show confirmation modal and redirect immediately
+      setShowModal(true);
       router.replace("/profile");
     }
   }, [session, status, pathname, router, searchParams]);
 
-  return null;
+  const handleContinue = () => {
+    setShowModal(false);
+  };
+
+  return (
+    <>
+      {showModal && (
+        <Modal
+          className="border border-red-500"
+          isOpen={showModal}
+          onOpenChange={setShowModal}
+          title="Complete your profile"
+          description="Please fill your profile information to continue. This will help us provide you with a better experience."
+          footer={
+            <div className="flex gap-3 w-full">
+              <Button
+                onClick={handleContinue}
+                className="flex-1"
+              >
+                Continue
+              </Button>
+            </div>
+          }
+        />
+      )}
+    </>
+  );
 }

app/(home)/showcase/[id]/page.tsx

@@ -2,16 +2,19 @@ import React from "react";
 import ProjectOverview from "../../../../components/showcase/ProjectOverview";
 import { getProject } from "@/server/services/projects";
 import { Project } from "@/types/showcase";
+import { getProjectBadges, getUserBadgesByProjectId } from "@/server/services/project-badge";
 export default async function ProjectPage({
   params,
 }: {
   params: Promise<{ id: string }>;
 }) {
   const { id } = await params;
   const project = await getProject(id);
+  const badges = await getUserBadgesByProjectId(id);
+
   return (
     <main className="container relative max-w-[1400px] pb-16">
-      <ProjectOverview project={project as unknown as Project} />
+      <ProjectOverview project={project as unknown as Project} badges={badges} />
     </main>
   );
 }

app/api/badge/assign/route.ts

@@ -0,0 +1,48 @@
+import { withAuth } from "@/lib/protectedRoute";
+import { badgeAssignmentService } from "@/server/services/badgeAssignmentService";
+import { getAuthSession } from "@/lib/auth/authSession";
+
+import { NextRequest, NextResponse } from "next/server";
+
+export const POST = withAuth(async (req: NextRequest) => {
+  try {
+    const body = await req.json();
+    const session = await getAuthSession();
+
+    // Check authorization based on badge type
+    const userRole = session?.user.role || "user";
+    const customAttributes = session?.user.custom_attributes??[];
+    const hasPermission = badgeAssignmentService.hasRequiredRole(body, customAttributes);
+
+    if (!hasPermission) {
+      const requiredRole = badgeAssignmentService.getRequiredRoleForAssignment(body);
+      return NextResponse.json(
+        { 
+          error: { 
+            message: `Insufficient permissions. Required role: ${requiredRole || 'none'}, User role: ${userRole}` 
+          } 
+        },
+        { status: 403 }
+      );
+    }
+
+    // Use the user's name as awardedBy
+    const badge = await badgeAssignmentService.assignBadge(body, session?.user.name || undefined);
+
+    return NextResponse.json({ result: badge }, { status: 200 });
+  } catch (error: any) {
+    console.error('Error POST /api/badge/assign:', error.message);
+    const wrappedError = error as Error;
+    return NextResponse.json(
+      {
+        error: {
+          message: wrappedError.message,
+          stack: wrappedError.stack,
+          cause: wrappedError.cause,
+          name: wrappedError.name,
+        },
+      },
+      { status: wrappedError.cause == "ValidationError" ? 400 : 500 }
+    );
+  }
+});

app/api/badge/get-all/route.ts

@@ -0,0 +1,17 @@
+import { withAuth } from "@/lib/protectedRoute";
+import { getAllBadges, getBadgeByCourseId } from "@/server/services/badge";
+
+import { NextResponse } from "next/server";
+
+export const GET = withAuth(async () => {
+  try {
+    const badges = await getAllBadges();
+    return NextResponse.json(badges, { status: 200 });
+  } catch (error) {
+    console.error("Error getting badge:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+});

app/api/badge/project-badge/route.ts

@@ -0,0 +1,27 @@
+import { withAuth } from "@/lib/protectedRoute";
+
+import { getProjectBadges } from "@/server/services/project-badge";
+
+import { NextResponse } from "next/server";
+
+export const GET = withAuth(async (request) => {
+  const { searchParams } = new URL(request.url);
+  const project_id = searchParams.get("project_id");
+  if (!project_id) {
+    return NextResponse.json(
+      { error: "project_id parameter is required" },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const badge = await getProjectBadges(project_id);
+    return NextResponse.json(badge, { status: 200 });
+  } catch (error) {
+    console.error("Error getting badge:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+});

app/api/badge/route.ts

@@ -1,5 +1,6 @@
 import { withAuth } from "@/lib/protectedRoute";
-import { getBadgeByCourseId } from "@/server/services/rewardBoard";
+import { getBadgeByCourseId } from "@/server/services/badge";
+
 import { NextResponse } from "next/server";
 
 export const GET = withAuth(async (request) => {

app/api/badge/validate/route.ts

@@ -0,0 +1,33 @@
+import { withAuth } from "@/lib/protectedRoute";
+import { getBadgeByCourseId } from "@/server/services/badge";
+
+import { NextResponse } from "next/server";
+
+export const GET = withAuth(async (request) => {
+  const { searchParams } = new URL(request.url);
+  const course_id = searchParams.get("course_id");
+  const user_id = searchParams.get("user_id");
+  if (!course_id) {
+    return NextResponse.json(
+      { error: "course_id parameter is required" },
+      { status: 400 }
+    );
+  }
+  if (!user_id) {
+    return NextResponse.json(
+      { error: "user_id parameter is required" },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const badge = await getBadgeByCourseId(course_id);
+    return NextResponse.json(badge, { status: 200 });
+  } catch (error) {
+    console.error("Error getting badge:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+});

app/api/project/set-winner/route.ts

@@ -0,0 +1,34 @@
+import { getAuthSession } from "@/lib/auth/authSession";
+import { withAuthRole } from "@/lib/protectedRoute";
+import { SetWinner } from "@/server/services/set-project-winner";
+import { NextRequest, NextResponse } from "next/server";
+
+export const PUT = withAuthRole("badge_admin", async (req: NextRequest) => {
+  const body = await req.json();
+  const session = await getAuthSession();
+  const name = session?.user.name || "user";
+
+  try {
+    if (!body.project_id) {
+      return NextResponse.json(
+        { error: "project_id parameter is required" },
+        { status: 400 }
+      );
+    }
+    if (!body.isWinner) {
+      return NextResponse.json(
+        { error: "IsWinner parameter is required" },
+        { status: 400 }
+      );
+    }
+    const badge = await SetWinner(body.project_id, body.isWinner, name);
+
+    return NextResponse.json(badge, { status: 200 });
+  } catch (error) {
+    console.error("Error checking user by email:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+});

app/api/projects/export/route.ts

@@ -0,0 +1,33 @@
+import { withAuthRole } from "@/lib/protectedRoute";
+import { exportShowcase } from "@/server/services/exportShowcase";
+import { NextRequest, NextResponse } from "next/server";
+
+export const POST = withAuthRole('hackathonCreator', async (req: NextRequest) => {
+    try {
+        const body = await req.json();
+        const buffer = await exportShowcase(body);
+        if (!buffer) {
+            return NextResponse.json(
+                { message: 'No projects found' },
+                { status: 404 }
+            );
+        }
+        return new NextResponse(buffer, {
+            headers: { 'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' },
+        });
+    } catch (error: any) {
+        console.error('Error POST /api/projects/export:', error.message);
+        const wrappedError = error as Error;
+        return NextResponse.json(
+            {
+                error: {
+                    message: wrappedError.message,
+                    stack: wrappedError.stack,
+                    cause: wrappedError.cause,
+                    name: wrappedError.name
+                }
+            },
+            { status: wrappedError.cause == 'ValidationError' ? 400 : 500 }
+        );
+    }
+});

components/hackathons/project-submission/SubmissionWrapperSecure.tsx

@@ -1,17 +1,30 @@
-'use client';
+"use client";
 
-import React from 'react';
-import { ProjectSubmissionProvider } from './context/ProjectSubmissionContext';
-import GeneralSecureComponent from './components/GeneralSecure';
+import React, { useState } from "react";
+import { ProjectSubmissionProvider } from "./context/ProjectSubmissionContext";
+import GeneralSecureComponent from "./components/GeneralSecure";
+import { UserNotRegistered } from "./components/UserNotRegistered";
 
 export function SubmissionWrapperSecure({
   searchParams,
 }: {
   searchParams: { [key: string]: string | string[] | undefined };
 }) {
+  const [showComponent, setShowComponent] = useState(false);
+
+  const handleShowComponent = (show: boolean) => {
+    setShowComponent(show);
+  };
+
   return (
     <ProjectSubmissionProvider>
-      <GeneralSecureComponent searchParams={searchParams} />
+      {!showComponent && (
+        <UserNotRegistered
+          hackathonId={searchParams.hackathon as string}
+          onToggle={handleShowComponent}
+        />
+      )}
+      {showComponent && <GeneralSecureComponent searchParams={searchParams} />}
     </ProjectSubmissionProvider>
   );
-} 
+}

components/hackathons/project-submission/components/GeneralSecure.tsx

@@ -21,6 +21,7 @@ import { Alert, AlertDescription } from "@/components/ui/alert";
 import { JoinTeamDialog } from "./JoinTeamDialog";
 import { ProjectMemberWarningDialog } from "./ProjectMemberWarningDialog";
 import InvalidInvitationComponent from "./InvalidInvitationDialog";
+import Modal from "@/components/ui/Modal";
 
 export default function GeneralSecureComponent({
   searchParams,
@@ -335,7 +336,6 @@ export default function GeneralSecureComponent({
           dispatch({ type: "SET_OPEN_INVALID_INVITATION", payload: open })
         }
       />
-
       {error && (
         <div className="mt-4">
           <Alert variant="destructive">

components/hackathons/project-submission/components/Members.tsx

@@ -312,7 +312,7 @@ export default function MembersComponent({
                       spellCheck="false"
                       onChange={(e) => setNewEmail(e.target.value)}
                       onKeyDown={async (e) => {
-                        if (e.key === "Enter" || e.key === " ") {
+                        if (e.key === "Enter" || e.key === " " || e.key === "Tab") {
                           e.preventDefault();
                           await handleAddEmail();
                         }