Add judge portal for hackathon submission review

apps/dashboard/pages/api/judge/bulk-decision.ts

@@ -0,0 +1,98 @@
+import 'reflect-metadata';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { container } from 'tsyringe';
+import { HibiscusSupabaseClient } from '@hibiscus/hibiscus-supabase-client';
+import { getAuthenticatedUser } from '../../../common/auth';
+
+/**
+ * Role IDs from the `roles` table:
+ *   1 = SUPERADMIN
+ *   7 = JUDGE
+ */
+const ALLOWED_ROLES = [1, 7];
+
+const VALID_DECISIONS = ['finalist', 'waitlist', 'not_selected'] as const;
+type FinalDecision = (typeof VALID_DECISIONS)[number];
+
+interface BulkDecisionRequest {
+  teamIds: string[];
+  decision: FinalDecision;
+}
+
+/**
+ * POST /api/judge/bulk-decision
+ * Bulk update final_decision for multiple teams.
+ * Only accessible by admins (role=1) and judges (role=7).
+ *
+ * Body: { teamIds: string[], decision: 'finalist' | 'waitlist' | 'not_selected' }
+ */
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ message: 'Method not allowed' });
+  }
+
+  const user = await getAuthenticatedUser(req);
+  if (!user) {
+    return res.status(401).json({ message: 'Unauthorized' });
+  }
+
+  if (!ALLOWED_ROLES.includes(user.role)) {
+    return res
+      .status(403)
+      .json({ message: 'Forbidden: Admin or Judge role required' });
+  }
+
+  const body = req.body as BulkDecisionRequest;
+
+  // Validate teamIds
+  if (!Array.isArray(body.teamIds) || body.teamIds.length === 0) {
+    return res
+      .status(400)
+      .json({ message: 'teamIds must be a non-empty array' });
+  }
+
+  if (body.teamIds.length > 500) {
+    return res.status(400).json({ message: 'Maximum 500 teams per request' });
+  }
+
+  // Validate decision
+  if (!VALID_DECISIONS.includes(body.decision)) {
+    return res.status(400).json({
+      message: 'decision must be one of: finalist, waitlist, not_selected',
+    });
+  }
+
+  try {
+    const hbc = container.resolve(HibiscusSupabaseClient);
+    hbc.setOptions({ useServiceKey: true });
+    const supabase = hbc.getClient();
+
+    // Build upsert payload for all teams
+    const payload = body.teamIds.map((teamId) => ({
+      team_id: teamId,
+      final_decision: body.decision,
+    }));
+
+    // Bulk upsert
+    const { error: upsertError } = await supabase
+      .from('judging_notes')
+      .upsert(payload, { onConflict: 'team_id' });
+
+    if (upsertError) {
+      console.error('[judge/bulk-decision] Upsert error:', upsertError);
+      return res.status(500).json({ message: 'Failed to update decisions' });
+    }
+
+    return res.status(200).json({
+      message: 'Decisions updated successfully',
+      count: body.teamIds.length,
+      decision: body.decision,
+    });
+  } catch (e) {
+    console.error('[judge/bulk-decision] Error:', e);
+    return res.status(500).json({ message: 'Internal server error' });
+  }
+}

apps/dashboard/pages/api/judge/export.ts

@@ -0,0 +1,191 @@
+import 'reflect-metadata';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { container } from 'tsyringe';
+import { HibiscusSupabaseClient } from '@hibiscus/hibiscus-supabase-client';
+import { getAuthenticatedUser } from '../../../common/auth';
+
+/**
+ * Role IDs from the `roles` table:
+ *   1 = SUPERADMIN
+ *   7 = JUDGE
+ */
+const ALLOWED_ROLES = [1, 7];
+
+const VALID_DECISIONS = ['finalist', 'waitlist', 'not_selected'] as const;
+type FinalDecision = (typeof VALID_DECISIONS)[number];
+
+interface TeamMember {
+  firstName: string | null;
+  lastName: string | null;
+  email: string;
+}
+
+interface ExportTeam {
+  teamId: string;
+  teamName: string;
+  projectTitle: string | null;
+  memberCount: number;
+  members: TeamMember[];
+}
+
+/**
+ * GET /api/judge/export?decision=finalist|waitlist|not_selected
+ * Export teams with their members for a given final decision.
+ * Only accessible by admins (role=1) and judges (role=7).
+ *
+ * Returns JSON with team and member details for CSV export.
+ */
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  if (req.method !== 'GET') {
+    return res.status(405).json({ message: 'Method not allowed' });
+  }
+
+  const user = await getAuthenticatedUser(req);
+  if (!user) {
+    return res.status(401).json({ message: 'Unauthorized' });
+  }
+
+  if (!ALLOWED_ROLES.includes(user.role)) {
+    return res
+      .status(403)
+      .json({ message: 'Forbidden: Admin or Judge role required' });
+  }
+
+  const decision = req.query.decision as string;
+
+  if (!decision || !VALID_DECISIONS.includes(decision as FinalDecision)) {
+    return res.status(400).json({
+      message:
+        'decision query param must be one of: finalist, waitlist, not_selected',
+    });
+  }
+
+  try {
+    const hbc = container.resolve(HibiscusSupabaseClient);
+    hbc.setOptions({ useServiceKey: true });
+    const supabase = hbc.getClient();
+
+    let teamIds: string[];
+
+    if (decision === 'not_selected') {
+      // For not_selected (rejected): get all submitted teams NOT marked as finalist/waitlist
+      // 1. Get all submitted teams
+      const { data: submittedTeams, error: submittedError } = await supabase
+        .from('teams')
+        .select('team_id')
+        .eq('submission_status', 2);
+
+      if (submittedError) {
+        console.error('[judge/export] Submitted teams error:', submittedError);
+        return res.status(500).json({ message: 'Failed to fetch teams' });
+      }
+
+      if (!submittedTeams || submittedTeams.length === 0) {
+        return res.status(200).json({ teams: [], count: 0, decision });
+      }
+
+      // 2. Get teams that ARE finalists or waitlist (to exclude)
+      const { data: selectedNotes, error: selectedError } = await supabase
+        .from('judging_notes')
+        .select('team_id')
+        .in('final_decision', ['finalist', 'waitlist']);
+
+      if (selectedError) {
+        console.error('[judge/export] Selected notes error:', selectedError);
+        return res.status(500).json({ message: 'Failed to fetch decisions' });
+      }
+
+      const selectedTeamIds = new Set(
+        (selectedNotes || []).map((n) => n.team_id)
+      );
+
+      // 3. Filter to submitted teams NOT in finalist/waitlist
+      teamIds = submittedTeams
+        .map((t) => t.team_id)
+        .filter((id) => !selectedTeamIds.has(id));
+
+      if (teamIds.length === 0) {
+        return res.status(200).json({ teams: [], count: 0, decision });
+      }
+    } else {
+      // For finalist/waitlist: get teams with that specific final_decision
+      const { data: judgingNotes, error: notesError } = await supabase
+        .from('judging_notes')
+        .select('team_id')
+        .eq('final_decision', decision);
+
+      if (notesError) {
+        console.error('[judge/export] Notes fetch error:', notesError);
+        return res.status(500).json({ message: 'Failed to fetch decisions' });
+      }
+
+      if (!judgingNotes || judgingNotes.length === 0) {
+        return res.status(200).json({ teams: [], count: 0, decision });
+      }
+
+      teamIds = judgingNotes.map((n) => n.team_id);
+    }
+
+    // Get team details
+    const { data: teams, error: teamsError } = await supabase
+      .from('teams')
+      .select('team_id, name, project_title')
+      .in('team_id', teamIds);
+
+    if (teamsError) {
+      console.error('[judge/export] Teams fetch error:', teamsError);
+      return res.status(500).json({ message: 'Failed to fetch teams' });
+    }
+
+    // Get members for these teams
+    const { data: members, error: membersError } = await supabase
+      .from('user_profiles')
+      .select('team_id, first_name, last_name, email')
+      .in('team_id', teamIds);
+
+    if (membersError) {
+      console.error('[judge/export] Members fetch error:', membersError);
+      return res.status(500).json({ message: 'Failed to fetch members' });
+    }
+
+    // Group members by team
+    const membersByTeam = new Map<string, TeamMember[]>();
+    for (const member of members || []) {
+      if (!member.team_id) continue;
+      const list = membersByTeam.get(member.team_id) || [];
+      list.push({
+        firstName: member.first_name,
+        lastName: member.last_name,
+        email: member.email,
+      });
+      membersByTeam.set(member.team_id, list);
+    }
+
+    // Build export data
+    const exportTeams: ExportTeam[] = (teams || []).map((team) => {
+      const teamMembers = membersByTeam.get(team.team_id) || [];
+      return {
+        teamId: team.team_id,
+        teamName: team.name,
+        projectTitle: team.project_title,
+        memberCount: teamMembers.length,
+        members: teamMembers,
+      };
+    });
+
+    // Sort by team name
+    exportTeams.sort((a, b) => a.teamName.localeCompare(b.teamName));
+
+    return res.status(200).json({
+      teams: exportTeams,
+      count: exportTeams.length,
+      decision,
+    });
+  } catch (e) {
+    console.error('[judge/export] Error:', e);
+    return res.status(500).json({ message: 'Internal server error' });
+  }
+}