Merge remote-tracking branch 'origin' into feat/gas-treemap

Author: navillanueva

app/(home)/build-games/page.tsx

@@ -2,7 +2,6 @@ import clsx from "clsx";
 import Link from "next/link";
 import "./styles.css";
 import ReferralLink from "@/components/build-games/ReferralLink";
-import ApplicationStatusTracker from "@/components/build-games/ApplicationStatusTracker";
 import ProgramTimelineWrapper from "@/components/build-games/ProgramTimelineWrapper";
 import BuildGamesResourcesWrapper from "@/components/build-games/BuildGamesResourcesWrapper";
 import HowItWorksWrapper from "@/components/build-games/HowItWorksWrapper";
@@ -1025,7 +1024,6 @@ function MainContent() {
     <div className="absolute content-stretch flex flex-col items-start left-[-0.05px] right-[0.05px] top-0" data-name="Main">
       <HeroSection />
       <HeroTilesSection />
-      <ApplicationStatusTracker />
       <div className="relative shrink-0 w-full" data-name="CTA">
         <div className="flex flex-col justify-center size-full">
           <div className="content-stretch flex flex-col gap-[16px] items-start justify-center px-[186px] py-0 relative w-full">

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

@@ -6,8 +6,8 @@ import {
 } from "@/server/services/hackathons";
 import { getRegisterForm } from "@/server/services/registerForms";
 import { getAuthSession } from "@/lib/auth/authSession";
-import HackathonEventLayout from "@/components/hackathons/event-layouts/HackathonEventLayout";
-import WorkshopBootcampEventLayout from "@/components/hackathons/event-layouts/WorkshopBootcampEventLayout";
+import LegacyEventLayout from "@/components/hackathons/event-layouts/LegacyEventLayout";
+import ModernEventLayout from "@/components/hackathons/event-layouts/ModernEventLayout";
 import { createMetadata } from "@/utils/metadata";
 import type { Metadata } from "next";
 
@@ -83,16 +83,12 @@ export default async function HackathonPage({
 
   if (!hackathon) redirect("/hackathons");
 
-  // Determine event type - default to "hackathon" for backwards compatibility
-  const eventType = hackathon.event || "hackathon";
-  const isHackathon = eventType === "hackathon";
-  const isWorkshopOrBootcamp =
-    eventType === "workshop" || eventType === "bootcamp";
+  // Layout depends only on new_layout; when null/undefined, use legacy
+  const useModernLayout = hackathon.new_layout === true;
 
-  // Render appropriate layout based on event type
-  if (isWorkshopOrBootcamp) {
+  if (useModernLayout) {
     return (
-      <WorkshopBootcampEventLayout
+      <ModernEventLayout
         hackathon={hackathon}
         id={id}
         isRegistered={isRegistered}
@@ -101,9 +97,8 @@ export default async function HackathonPage({
     );
   }
 
-  // Default to hackathon layout (for hackathon type or any other/unknown types)
   return (
-    <HackathonEventLayout
+    <LegacyEventLayout
       hackathon={hackathon}
       id={id}
       isRegistered={isRegistered}

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

@@ -152,7 +152,13 @@ export default async function HackathonPage({
             {hackathon.content.tracks_text && <About hackathon={hackathon} />}
             {hackathon.content.tracks && <Tracks hackathon={hackathon} />}
             <Resources hackathon={hackathon} />
-            {hackathon.content.schedule && <Schedule hackathon={hackathon} />}
+            <Schedule 
+              hackathon={hackathon} 
+              scheduleSource={hackathon.google_calendar_id ? "google-calendar" : "database"}
+              googleCalendarConfig={hackathon.google_calendar_id ? {
+                calendarId: hackathon.google_calendar_id,
+              } : undefined}
+            />
             <Submission hackathon={hackathon} />
             {hackathon.content.speakers && hackathon.content.speakers.length > 0 && (
               <MentorsJudges hackathon={hackathon} />

app/api/build-games/status/route.ts

@@ -15,8 +15,8 @@ export async function GET() {
     // Check all three participation paths in parallel:
     // 1. BuildGames application form
     // 2. RegisterForm for the Build Games hackathon
-    // 3. Confirmed project member of a Build Games project
-    const [application, registration, project] = await Promise.all([
+    // 3. Project member (non-Removed) of a Build Games project
+    const [application, registration, projects] = await Promise.all([
       prisma.buildGamesApplication.findUnique({
         where: { email: session.user.email },
         select: { id: true, first_name: true, project_name: true, created_at: true },
@@ -25,36 +25,78 @@ export async function GET() {
         where: { hackathon_id: BG_HACKATHON_ID, email: session.user.email },
         select: { id: true, name: true, created_at: true },
       }),
-      prisma.project.findFirst({
+      prisma.project.findMany({
         where: {
           hackaton_id: BG_HACKATHON_ID,
-          members: { some: { email: session.user.email } },
+          members: { some: { email: session.user.email, status: { not: "Removed" } } },
+        },
+        select: {
+          id: true,
+          project_name: true,
+          created_at: true,
+          members: {
+            where: { email: session.user.email, status: { not: "Removed" } },
+            select: { status: true },
+          },
         },
-        select: { id: true, project_name: true, created_at: true },
       }),
     ]);
 
-    const isParticipant = !!(application || registration || project);
+    const isParticipant = !!(application || registration || projects.length > 0);
 
     if (!isParticipant) {
       return NextResponse.json({ isParticipant: false });
     }
 
-    // Use the best available project name: application > project > registration name
-    const projectName =
-      application?.project_name ??
-      project?.project_name ??
-      "Build Games 2026";
+    // Fetch FormData for all projects in parallel
+    const projectsWithResults = await Promise.all(
+      projects.map(async (p) => {
+        const formData = await prisma.formData.findFirst({
+          where: { project_id: p.id },
+          select: { form_data: true },
+        });
+        const buildGames = (formData?.form_data as Record<string, any>)?.build_games;
+        const stage1Result: string | null = buildGames?.stage1_result ?? null;
+        const isConfirmed = p.members.some((m) => m.status === "Confirmed");
+        return { projectName: p.project_name, stage1Result, isConfirmed, createdAt: p.created_at };
+      })
+    );
+
+    // Selection logic:
+    // 1. Prefer accepted projects; among those prefer confirmed membership.
+    // 2. If multiple confirmed+accepted exist, show all of them.
+    // 3. If no accepted projects, show the confirmed one.
+    // 4. If only one project total, show it regardless.
+    let selectedProjects = projectsWithResults;
+
+    if (projectsWithResults.length > 1) {
+      const accepted = projectsWithResults.filter((p) => p.stage1Result === "accepted");
+      if (accepted.length > 0) {
+        const confirmedAccepted = accepted.filter((p) => p.isConfirmed);
+        selectedProjects = confirmedAccepted.length > 0 ? confirmedAccepted : accepted;
+      } else {
+        const confirmed = projectsWithResults.filter((p) => p.isConfirmed);
+        selectedProjects = confirmed.length > 0 ? [confirmed[0]] : [projectsWithResults[0]];
+      }
+    }
+
+    const stageResults = selectedProjects
+      .filter((p) => p.stage1Result !== null)
+      .map((p) => ({ projectName: p.projectName, stage1Result: p.stage1Result as string }));
+
+    const firstProject = selectedProjects[0];
+    const projectName = firstProject?.projectName ?? application?.project_name ?? "Build Games 2026";
 
     const createdAt = (
       application?.created_at ??
       registration?.created_at ??
-      project?.created_at
+      firstProject?.createdAt
     )?.toISOString() ?? new Date().toISOString();
 
     return NextResponse.json({
       isParticipant: true,
       participant: { projectName, createdAt },
+      stageResults,
     });
   } catch (error) {
     console.error('Error checking application status:', error);

app/api/calendar/google/route.ts

@@ -0,0 +1,120 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { transformGoogleEventsToSchedule, GoogleCalendarEvent } from '@/lib/hackathons/schedule-strategy';
+
+/**
+ * Google Calendar API route
+ * 
+ * Fetches events from a PUBLIC Google Calendar using an API Key.
+ * Requires GOOGLE_CALENDAR_API_KEY environment variable.
+ * 
+ * Query parameters:
+ * - calendarId: The Google Calendar ID (required)
+ * - maxResults: Maximum number of events to fetch (default: 100)
+ * - timeMin: Only fetch events after this ISO date
+ * - timeMax: Only fetch events before this ISO date
+ */
+
+export async function GET(request: NextRequest) {
+  try {
+    const apiKey = process.env.NEXT_PUBLIC_GOOGLE_CALENDAR_API_KEY;
+
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'NEXT_PUBLIC_GOOGLE_CALENDAR_API_KEY not configured' },
+        { status: 500 }
+      );
+    }
+
+    const { searchParams } = new URL(request.url);
+    
+    const calendarId = searchParams.get('calendarId');
+    const maxResults = searchParams.get('maxResults') || '100';
+    const timeMin = searchParams.get('timeMin');
+    const timeMax = searchParams.get('timeMax');
+
+    if (!calendarId) {
+      return NextResponse.json(
+        { error: 'calendarId is required' },
+        { status: 400 }
+      );
+    }
+
+    // Fetch all events using pagination
+    const allEvents: GoogleCalendarEvent[] = [];
+    let pageToken: string | undefined = undefined;
+
+    do {
+      // Build Google Calendar API URL
+      const apiParams = new URLSearchParams({
+        key: apiKey,
+        maxResults: '250', // Max allowed per request
+        singleEvents: 'true',
+        orderBy: 'startTime',
+        // Include conference data (Google Meet links, etc.)
+        conferenceDataVersion: '1',
+      });
+
+      if (timeMin) {
+        apiParams.set('timeMin', timeMin);
+      }
+      if (timeMax) {
+        apiParams.set('timeMax', timeMax);
+      }
+      if (pageToken) {
+        apiParams.set('pageToken', pageToken);
+      }
+
+      const calendarUrl = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events?${apiParams.toString()}`;
+
+      const response = await fetch(calendarUrl, {
+        next: { revalidate: 60 }, // Cache for 1 minute (reduced for faster updates)
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        console.error('Google Calendar API error:', error);
+        
+        if (response.status === 404) {
+          return NextResponse.json(
+            { error: 'Calendar not found. Make sure the calendar is public and the ID is correct.' },
+            { status: 404 }
+          );
+        }
+        
+        return NextResponse.json(
+          { error: `Google Calendar API error: ${response.status}` },
+          { status: response.status }
+        );
+      }
+
+      const data = await response.json();
+      const events = (data.items || []) as GoogleCalendarEvent[];
+      allEvents.push(...events);
+      
+      // Get next page token for pagination
+      pageToken = data.nextPageToken;
+    } while (pageToken);
+
+    const events = allEvents;
+    
+    // Transform to ScheduleActivity format
+    const schedule = transformGoogleEventsToSchedule(events);
+    
+    // Get calendar timezone from first event or calendar metadata
+    const calendarTimeZone = events[0]?.start?.timeZone || '';
+
+    return NextResponse.json({
+      schedule,
+      totalEvents: events.length,
+      calendarId,
+      timeZone: calendarTimeZone,
+    });
+  } catch (error) {
+    console.error('Google Calendar API error:', error);
+    
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Failed to fetch calendar events' },
+      { status: 500 }
+    );
+  }
+}