-
- ) : error ? (
-
-
-
-
- ) : blogData ? (
- {error}
-
Bounties Page
diff --git a/app/(landing)/contact/page.tsx b/app/(landing)/contact/page.tsx
index 0e253034a..d12c5373d 100644
--- a/app/(landing)/contact/page.tsx
+++ b/app/(landing)/contact/page.tsx
@@ -1,10 +1,11 @@
-import React from 'react';
+import { redirect } from 'next/navigation';
import { Metadata } from 'next';
import { generatePageMetadata } from '@/lib/metadata';
export const metadata: Metadata = generatePageMetadata('contact');
const ContactPage = () => {
+ redirect('/coming-soon');
return (
Contact Page
diff --git a/app/(landing)/grants/page.tsx b/app/(landing)/grants/page.tsx
index 08dfe9250..1c3258e95 100644
--- a/app/(landing)/grants/page.tsx
+++ b/app/(landing)/grants/page.tsx
@@ -1,10 +1,11 @@
-import React from 'react';
+import { redirect } from 'next/navigation';
import { Metadata } from 'next';
import { generatePageMetadata } from '@/lib/metadata';
export const metadata: Metadata = generatePageMetadata('grants');
const GrantPage = () => {
+ redirect('/coming-soon');
return (
Grant Page
diff --git a/app/(landing)/hackathons/[slug]/HackathonPageClient.tsx b/app/(landing)/hackathons/[slug]/HackathonPageClient.tsx
new file mode 100644
index 000000000..91518cd5a
--- /dev/null
+++ b/app/(landing)/hackathons/[slug]/HackathonPageClient.tsx
@@ -0,0 +1,521 @@
+'use client';
+
+import { useState, useEffect, useMemo, useCallback } from 'react';
+import { useRouter, useSearchParams, useParams } from 'next/navigation';
+import { useHackathonData } from '@/lib/providers/hackathonProvider';
+import { useRegisterHackathon } from '@/hooks/hackathon/use-register-hackathon';
+import { useLeaveHackathon } from '@/hooks/hackathon/use-leave-hackathon';
+import { RegisterHackathonModal } from '@/components/hackathons/overview/RegisterHackathonModal';
+import { HackathonBanner } from '@/components/hackathons/hackathonBanner';
+import { HackathonNavTabs } from '@/components/hackathons/hackathonNavTabs';
+import { HackathonOverview } from '@/components/hackathons/overview/hackathonOverview';
+import { HackathonResources } from '@/components/hackathons/resources/resources';
+import SubmissionTab from '@/components/hackathons/submissions/submissionTab';
+import { HackathonDiscussions } from '@/components/hackathons/discussion/comment';
+import { TeamFormationTab } from '@/components/hackathons/team-formation/TeamFormationTab';
+import { WinnersTab } from '@/components/hackathons/winners/WinnersTab';
+import LoadingScreen from '@/features/projects/components/CreateProjectModal/LoadingScreen';
+import { useTimelineEvents } from '@/hooks/hackathon/use-timeline-events';
+import { toast } from 'sonner';
+import type { Participant } from '@/lib/api/hackathons';
+import { HackathonStickyCard } from '@/components/hackathons/hackathonStickyCard';
+import { HackathonParticipants } from '@/components/hackathons/participants/hackathonParticipant';
+import { useCommentSystem } from '@/hooks/use-comment-system';
+import { CommentEntityType } from '@/types/comment';
+import { useTeamPosts } from '@/hooks/hackathon/use-team-posts';
+import {
+ listAnnouncements,
+ type HackathonAnnouncement,
+} from '@/lib/api/hackathons/index';
+import { Megaphone } from 'lucide-react';
+import { AnnouncementsTab } from '@/components/hackathons/announcements/AnnouncementsTab';
+
+export default function HackathonPageClient() {
+ const router = useRouter();
+ const searchParams = useSearchParams();
+ const params = useParams();
+
+ const {
+ currentHackathon,
+ submissions,
+ winners,
+ loading,
+ setCurrentHackathon,
+ refreshCurrentHackathon,
+ } = useHackathonData();
+
+ const timeline_Events = useTimelineEvents(currentHackathon, {
+ includeEndDate: false,
+ dateFormat: { month: 'short', day: 'numeric', year: 'numeric' },
+ });
+
+ const hackathonId = params.slug as string;
+ const [activeTab, setActiveTab] = useState('overview');
+ const [showRegisterModal, setShowRegisterModal] = useState(false);
+
+ // Fetch discussion comments for count
+ const { comments: discussionComments } = useCommentSystem({
+ entityType: CommentEntityType.HACKATHON,
+ entityId: hackathonId,
+ page: 1,
+ limit: 100,
+ enabled: !!hackathonId,
+ });
+
+ // Fetch team posts for count
+ const { posts: teamPosts } = useTeamPosts({
+ hackathonSlugOrId: hackathonId,
+ autoFetch: !!hackathonId,
+ });
+
+ // Fetch announcements for public view
+ const [announcements, setAnnouncements] = useState(
+ []
+ );
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ const [announcementsLoading, setAnnouncementsLoading] = useState(false);
+
+ useEffect(() => {
+ async function fetchAnnouncements() {
+ if (!hackathonId) return;
+ try {
+ setAnnouncementsLoading(true);
+ const data = await listAnnouncements(hackathonId);
+ // Only show published announcements for public view
+ setAnnouncements(data.filter(a => !a.isDraft));
+ } catch (error) {
+ // eslint-disable-next-line no-console
+ console.error('Failed to fetch announcements:', error);
+ } finally {
+ setAnnouncementsLoading(false);
+ }
+ }
+ fetchAnnouncements();
+ }, [hackathonId]);
+
+ const hackathonTabs = useMemo(() => {
+ const hasParticipants =
+ Array.isArray(currentHackathon?.participants) &&
+ currentHackathon.participants.length > 0;
+
+ const hasResources = currentHackathon?.resources?.[0];
+ const participantType = currentHackathon?.participantType;
+ const isTeamHackathon =
+ participantType === 'TEAM' || participantType === 'TEAM_OR_INDIVIDUAL';
+
+ const hasWinners = winners && winners.length > 0;
+
+ const tabs = [
+ { id: 'overview', label: 'Overview' },
+ ...(hasParticipants
+ ? [
+ {
+ id: 'participants',
+ label: 'Participants',
+ badge: currentHackathon?.participants.length,
+ },
+ ]
+ : []),
+ ...(hasResources
+ ? [
+ {
+ id: 'resources',
+ label: 'Resources',
+ badge: currentHackathon?.resources?.length,
+ },
+ ]
+ : []),
+ ...(announcements.length > 0
+ ? [
+ {
+ id: 'announcements',
+ label: 'Announcements',
+ badge: announcements.length,
+ icon: Megaphone,
+ },
+ ]
+ : []),
+ {
+ id: 'submission',
+ label: 'Submissions',
+ badge: submissions.filter(p => p.status === 'Approved').length,
+ },
+ {
+ id: 'discussions',
+ label: 'Discussions',
+ badge: discussionComments.comments.length,
+ },
+ ];
+
+ if (isTeamHackathon) {
+ tabs.push({
+ id: 'team-formation',
+ label: 'Find Team',
+ badge: teamPosts.length,
+ });
+ }
+
+ if (hasWinners) {
+ tabs.push({
+ id: 'winners',
+ label: 'Winners',
+ badge: winners.length,
+ });
+ }
+
+ // Filter tabs against enabledTabs so only explicitly enabled tabs are shown.
+ // 'overview' is always kept as it is the default fallback tab.
+ // If enabledTabs is undefined/null (not configured), all tabs are shown as before.
+ //
+ // IMPORTANT: Any new tab id added to the tabs array above must have a corresponding
+ // entry in tabIdToEnabledKey below; otherwise it falls back to tab.id and may be
+ // hidden when enabledTabs is set.
+ const tabIdToEnabledKey: Record = {
+ 'team-formation': 'joinATeamTab',
+ winners: 'winnersTab',
+ resources: 'resourcesTab',
+ participants: 'participantsTab',
+ announcements: 'announcementsTab',
+ submission: 'submissionTab',
+ discussions: 'discussionTab',
+ };
+
+ /** Backend enabledTabs entry type; keys in tabIdToEnabledKey must align with this. */
+ type EnabledTab = NonNullable<
+ typeof currentHackathon
+ >['enabledTabs'][number];
+ const enabledTabs = currentHackathon?.enabledTabs;
+
+ if (Array.isArray(enabledTabs)) {
+ const enabledSet = new Set(enabledTabs);
+ return tabs.filter(tab => {
+ if (tab.id === 'overview') return true;
+ const key = (tabIdToEnabledKey[tab.id] ?? tab.id) as EnabledTab;
+ const isVisible = enabledSet.has(key);
+ if (
+ !isVisible &&
+ process.env.NODE_ENV === 'development' &&
+ currentHackathon?.enabledTabs
+ ) {
+ console.warn(
+ `[HackathonPageClient] Tab "${tab.id}" (enabled key: ${key}) is not in currentHackathon.enabledTabs and will be hidden. Add the tab id to tabIdToEnabledKey and ensure the backend includes the key in enabledTabs when the tab should be visible.`
+ );
+ }
+ return isVisible;
+ });
+ }
+ return tabs;
+ }, [
+ currentHackathon?.participants,
+ currentHackathon?.resources,
+ currentHackathon?.participantType,
+ currentHackathon?.enabledTabs,
+ submissions,
+ discussionComments.comments.length,
+ teamPosts.length,
+ winners,
+ announcements,
+ ]);
+
+ // Refresh hackathon data
+ const refreshHackathonData = useCallback(async () => {
+ if (hackathonId && refreshCurrentHackathon) {
+ await refreshCurrentHackathon();
+ }
+ }, [hackathonId, refreshCurrentHackathon]);
+
+ // Registration status
+ const {
+ isRegistered,
+ hasSubmitted,
+ setParticipant,
+ register: registerForHackathon,
+ } = useRegisterHackathon({
+ hackathon: currentHackathon
+ ? {
+ id: currentHackathon.id,
+ slug: currentHackathon.slug,
+ isParticipant: currentHackathon.isParticipant,
+ }
+ : null,
+ organizationId: undefined,
+ });
+
+ // Leave hackathon functionality
+ const { isLeaving, leave: leaveHackathon } = useLeaveHackathon({
+ hackathonSlugOrId: currentHackathon?.id || '',
+ organizationId: undefined,
+ });
+
+ const handleRegister = async () => {
+ try {
+ const participantData = await registerForHackathon();
+
+ toast.success('Successfully registered for hackathon!');
+ handleRegisterSuccess(participantData);
+ } catch {
+ // Error handled in hook
+ }
+ };
+
+ // Team formation availability
+ const isTeamHackathon =
+ currentHackathon?.participantType === 'TEAM' ||
+ currentHackathon?.participantType === 'TEAM_OR_INDIVIDUAL';
+ const isTeamFormationEnabled =
+ isTeamHackathon &&
+ currentHackathon?.enabledTabs?.includes('joinATeamTab') !== false;
+
+ // Event handlers
+ const handleJoinClick = () => {
+ handleRegister();
+ };
+
+ const handleLeaveClick = async () => {
+ try {
+ setParticipant(null);
+ await leaveHackathon();
+ refreshHackathonData();
+ router.push('?tab=overview');
+ } catch (error) {
+ const errorMessage =
+ error instanceof Error ? error.message : 'Failed to leave hackathon';
+ toast.error(errorMessage);
+ }
+ };
+
+ const handleRegisterSuccess = async (participantData: Participant) => {
+ setParticipant(participantData);
+ await refreshHackathonData();
+ router.push('?tab=submission');
+ };
+
+ const handleSubmitClick = () => {
+ router.push('?tab=submission');
+ };
+
+ const handleViewSubmissionClick = () => {
+ router.push('?tab=submission');
+ };
+
+ const handleFindTeamClick = () => {
+ router.push('?tab=team-formation');
+ };
+
+ // Set current hackathon on mount
+ useEffect(() => {
+ if (hackathonId) {
+ setCurrentHackathon(hackathonId);
+ }
+ }, [hackathonId, setCurrentHackathon]);
+
+ // Handle tab changes from URL
+ // Now also defaults to 'overview' if the URL tab is not in the filtered hackathonTabs list.
+ // This handles direct URL access to a disabled tab โ user is silently redirected to overview.
+ useEffect(() => {
+ if (loading || !currentHackathon) return;
+
+ const tabFromUrl = searchParams.get('tab');
+
+ // No tab in URL โ default to overview
+ if (!tabFromUrl) {
+ setActiveTab('overview');
+ return;
+ }
+
+ if (hackathonTabs.some(tab => tab.id === tabFromUrl)) {
+ // Tab exists in filtered list โ activate it normally
+ setActiveTab(tabFromUrl);
+ return;
+ }
+
+ // Tab is disabled or unrecognised โ fall back to overview
+ setActiveTab('overview');
+ const queryParams = new URLSearchParams(searchParams.toString());
+ queryParams.set('tab', 'overview');
+ router.replace(`?${queryParams.toString()}`, { scroll: false });
+ }, [searchParams, hackathonTabs, router, loading, currentHackathon]);
+
+ const handleTabChange = (tabId: string) => {
+ setActiveTab(tabId);
+ const queryParams = new URLSearchParams(searchParams.toString());
+ queryParams.set('tab', tabId);
+ router.push(`?${queryParams.toString()}`, { scroll: false });
+ };
+
+ // Loading state
+ if (loading) {
+ return (null);
+ const [hackathonName, setHackathonName] = useState('');
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ async function fetchDetails() {
+ if (!announcementId) return;
+ try {
+ setLoading(true);
+ const [announcementData, hackathonData] = await Promise.all([
+ getAnnouncementDetails(announcementId),
+ GetHackathonBySlug(slug),
+ ]);
+ setAnnouncement(announcementData);
+ setHackathonName(hackathonData.data.name);
+ } catch (err) {
+ console.error('Failed to fetch details:', err);
+ setError(
+ 'Failed to load announcement. It may have been deleted or moved.'
+ );
+ } finally {
+ setLoading(false);
+ }
+ }
+ fetchDetails();
+ }, [announcementId, slug]);
+
+ const { styledContent, loading: markdownLoading } = useMarkdown(
+ announcement?.content || '',
+ {
+ breaks: true,
+ gfm: true,
+ }
+ );
+
+ if (loading) {
+ return (
+ {
+ try {
+ const { slug } = await params;
+ const response = await getHackathon(slug);
+
+ if (!response.success || !response.data) {
+ return {
+ title: 'Hackathon Not Found | Boundless',
+ description: 'The requested hackathon could not be found.',
+ };
}
- };
-
- const handleRegisterSuccess = async (participantData: Participant) => {
- setParticipant(participantData);
- await refreshHackathonData(); // This will update hackathon.isParticipant
- router.push('?tab=submission');
- };
-
- const handleSubmitClick = () => {
- router.push('?tab=submission');
- };
-
- const handleViewSubmissionClick = () => {
- router.push('?tab=submission');
- };
- const handleFindTeamClick = () => {
- router.push('?tab=team-formation');
- };
+ return generateHackathonMetadata(response.data);
+ } catch {
+ return {
+ title: 'Hackathon | Boundless',
+ description: 'Join exciting hackathons on Boundless.',
+ };
+ }
+}
- // Set current hackathon on mount
- useEffect(() => {
- if (hackathonId) {
- setCurrentHackathon(hackathonId);
- }
- }, [hackathonId, setCurrentHackathon]);
+export default async function HackathonPage({ params }: HackathonPageProps) {
+ const { slug } = await params;
+ try {
+ const response = await getHackathon(slug);
- // Handle tab changes from URL
- useEffect(() => {
- const tabFromUrl = searchParams.get('tab');
- if (tabFromUrl && hackathonTabs.some(tab => tab.id === tabFromUrl)) {
- setActiveTab(tabFromUrl);
+ if (!response.success || !response.data) {
+ notFound();
}
- }, [searchParams, hackathonTabs]);
-
- const handleTabChange = (tabId: string) => {
- setActiveTab(tabId);
- const params = new URLSearchParams(searchParams.toString());
- params.set('tab', tabId);
- router.push(`?${params.toString()}`, { scroll: false });
- };
-
- // Loading state
- if (loading) {
- return
+
);
+ } catch {
+ notFound();
}
-
- // Shared props for banner and sticky card
- const sharedActionProps = {
- deadline: currentHackathon.submissionDeadline,
- startDate: currentHackathon.startDate,
- totalPrizePool: currentHackathon.prizeTiers
- .reduce((acc, prize) => acc + Number(prize.prizeAmount || 0), 0)
- .toString(),
- isRegistered,
- hasSubmitted,
- isTeamFormationEnabled,
- registrationDeadlinePolicy: currentHackathon.registrationDeadlinePolicy, // Now matches API casing
- registrationDeadline: currentHackathon.registrationDeadline,
- onJoinClick: handleJoinClick,
- onLeaveClick: handleLeaveClick,
- isLeaving,
- onSubmitClick: handleSubmitClick,
- onViewSubmissionClick: handleViewSubmissionClick,
- onFindTeamClick: handleFindTeamClick,
- };
-
- return (
-
+ {/* Banner skeleton */}
+
+ );
+}
diff --git a/app/(landing)/org/[slug]/org-profile-client.tsx b/app/(landing)/org/[slug]/org-profile-client.tsx
new file mode 100644
index 000000000..e57061982
--- /dev/null
+++ b/app/(landing)/org/[slug]/org-profile-client.tsx
@@ -0,0 +1,170 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import Image from 'next/image';
+import {
+ Trophy,
+ HandCoins,
+ FolderKanban,
+ Target,
+ Building2,
+} from 'lucide-react';
+import {
+ getOrganizationProfile,
+ OrganizationProfile,
+} from '@/lib/api/organization';
+import { Skeleton } from '@/components/ui/skeleton';
+
+interface OrgProfileClientProps {
+ slug: string;
+}
+
+export default function OrgProfileClient({ slug }: OrgProfileClientProps) {
+ const [profile, setProfile] = useState(null);
+ const [loading, setLoading] = useState(true);
+
+ useEffect(() => {
+ async function loadProfile() {
+ try {
+ const data = await getOrganizationProfile(slug);
+ setProfile(data);
+ } catch {
+ setProfile(null);
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ loadProfile();
+ }, [slug]);
+
+ if (loading) {
+ return
+
+ );
+ }
+
+ const { stats } = profile;
+ const statCards = [
+ {
+ label: 'Projects',
+ value: stats.projectsCount,
+ icon: FolderKanban,
+ color: 'text-purple-400',
+ bgColor: 'bg-purple-500/10',
+ },
+ {
+ label: 'Hackathons',
+ value: stats.totalHackathons,
+ icon: Trophy,
+ color: 'text-[#a7f950]',
+ bgColor: 'bg-[#a7f950]/10',
+ },
+ {
+ label: 'Bounties',
+ value: stats.totalBounties,
+ icon: Target,
+ color: 'text-amber-400',
+ bgColor: 'bg-amber-500/10',
+ },
+ {
+ label: 'Grants',
+ value: stats.totalGrants,
+ icon: HandCoins,
+ color: 'text-blue-400',
+ bgColor: 'bg-blue-500/10',
+ },
+ ];
+
+ return (
+
+ {/* Banner / Header */}
+
+ );
+}
+
+function OrgProfileSkeleton() {
+ return (
+
+
+ );
+}
diff --git a/app/(landing)/org/[slug]/page.tsx b/app/(landing)/org/[slug]/page.tsx
new file mode 100644
index 000000000..b4dedd803
--- /dev/null
+++ b/app/(landing)/org/[slug]/page.tsx
@@ -0,0 +1,62 @@
+import { Metadata } from 'next';
+import { getOrganizationProfile } from '@/lib/api/organization';
+import OrgProfileClient from './org-profile-client';
+
+const SITE_URL = process.env.NEXT_PUBLIC_APP_URL || 'https://boundlessfi.xyz';
+
+interface OrgProfilePageProps {
+ params: Promise<{ slug: string }>;
+}
+
+export async function generateMetadata({
+ params,
+}: OrgProfilePageProps): Promise {
+ try {
+ const { slug } = await params;
+ const org = await getOrganizationProfile(slug);
+
+ const title = `${org.name} | Boundless`;
+ const description = org.description || `View ${org.name} on Boundless`;
+ const ogImageUrl = `${SITE_URL}/api/og?slug=${encodeURIComponent(slug)}`;
+
+ return {
+ title,
+ description,
+ openGraph: {
+ title,
+ description,
+ url: `${SITE_URL}/org/${slug}`,
+ siteName: 'Boundless',
+ images: [
+ {
+ url: ogImageUrl,
+ width: 1200,
+ height: 630,
+ alt: org.name,
+ type: 'image/png',
+ },
+ ],
+ },
+ twitter: {
+ card: 'summary_large_image',
+ title,
+ description,
+ images: [ogImageUrl],
+ },
+ };
+ } catch {
+ return {
+ title: 'Organization | Boundless',
+ description: 'View organization profile on Boundless.',
+ openGraph: {
+ images: [`${SITE_URL}/api/og`],
+ },
+ };
+ }
+}
+
+export default async function OrgProfilePage({ params }: OrgProfilePageProps) {
+ const { slug } = await params;
+
+ return
+
+ );
+ }
+
+ // Helper: checks if a tab id is present in the filtered hackathonTabs array.
+ // Used below to guard each tab's content from rendering if the tab is disabled.
+ const isTabVisible = (tabId: string): boolean =>
+ hackathonTabs.some(tab => tab.id === tabId);
+
+ // Shared props for banner and sticky card
+ const sharedActionProps = {
+ deadline: currentHackathon.submissionDeadline,
+ startDate: currentHackathon.startDate,
+ totalPrizePool: currentHackathon.prizeTiers
+ .reduce((acc, prize) => acc + Number(prize.prizeAmount || 0), 0)
+ .toString(),
+ isRegistered,
+ hasSubmitted,
+ isTeamFormationEnabled,
+ registrationDeadline: currentHackathon.registrationDeadline,
+ participantType: currentHackathon.participantType,
+ onJoinClick: handleJoinClick,
+ onLeaveClick: handleLeaveClick,
+ isLeaving,
+ onSubmitClick: handleSubmitClick,
+ onViewSubmissionClick: handleViewSubmissionClick,
+ onFindTeamClick: handleFindTeamClick,
+ };
+
+ return (
+
+
+ + Hackathon not found +
++ The hackathon you're looking for doesn't exist. +
+
+
+ );
+}
diff --git a/app/(landing)/hackathons/[slug]/announcements/[announcementId]/page.tsx b/app/(landing)/hackathons/[slug]/announcements/[announcementId]/page.tsx
new file mode 100644
index 000000000..759781a56
--- /dev/null
+++ b/app/(landing)/hackathons/[slug]/announcements/[announcementId]/page.tsx
@@ -0,0 +1,199 @@
+'use client';
+
+import React, { useState, useEffect } from 'react';
+import { useParams, useRouter } from 'next/navigation';
+import { Megaphone, ArrowLeft, Calendar, User, Pin } from 'lucide-react';
+import {
+ getAnnouncementDetails,
+ GetHackathonBySlug,
+ type HackathonAnnouncement,
+} from '@/lib/api/hackathons/index';
+import { useMarkdown } from '@/hooks/use-markdown';
+import { BoundlessButton } from '@/components/buttons';
+import Loading from '@/components/Loading';
+import { Badge } from '@/components/ui/badge';
+
+export default function AnnouncementDetailPage() {
+ const params = useParams();
+ const router = useRouter();
+ const announcementId = params.announcementId as string;
+ const slug = params.slug as string;
+
+ const [announcement, setAnnouncement] =
+ useState
+
+
+ {hackathonId && (
+
+
+
+
+ {activeTab === 'overview' && (
+ ({
+ id: tier.id,
+ place: tier.name,
+ currency: tier.currency,
+ passMark: tier.passMark,
+ description: tier.description,
+ prizeAmount: tier.prizeAmount,
+ }))}
+ totalPrizePool={currentHackathon.prizeTiers
+ .reduce(
+ (acc, prize) => acc + Number(prize.prizeAmount || 0),
+ 0
+ )
+ .toString()}
+ hackathonSlugOrId={hackathonId}
+ venue={{
+ type: currentHackathon.venueType.toLowerCase() as
+ | 'virtual'
+ | 'physical',
+ country: currentHackathon.country,
+ state: currentHackathon.state,
+ city: currentHackathon.city,
+ venueName: currentHackathon.venueName,
+ venueAddress: currentHackathon.venueAddress,
+ }}
+ />
+ )}
+
+ {/* isTabVisible('resources') guard โ HackathonResources will not
+ render at all if 'resources' is not in enabledTabs, even via direct URL */}
+ {activeTab === 'resources' &&
+ isTabVisible('resources') &&
+ currentHackathon.resources?.length > 0 &&
+
+
+
+
+ );
+ }
+
+ if (error || !announcement) {
+ return (
+
+ router.back()} variant='outline'>
+
+
+ );
+ }
+
+ return (
+
+
+ + Announcement Not Found +
++ {error || "We couldn't find the announcement you're looking for."} +
+
+ {/* Top Header */}
+
+ );
+}
diff --git a/app/(landing)/hackathons/[slug]/page.tsx b/app/(landing)/hackathons/[slug]/page.tsx
index 38a0e2d62..6caeb1d7e 100644
--- a/app/(landing)/hackathons/[slug]/page.tsx
+++ b/app/(landing)/hackathons/[slug]/page.tsx
@@ -1,427 +1,52 @@
-'use client';
-
-import { useState, useEffect, useMemo, useCallback } from 'react';
-import { useRouter, useSearchParams, useParams } from 'next/navigation';
-import { useHackathonData } from '@/lib/providers/hackathonProvider';
-import { useRegisterHackathon } from '@/hooks/hackathon/use-register-hackathon';
-import { useLeaveHackathon } from '@/hooks/hackathon/use-leave-hackathon';
-import { RegisterHackathonModal } from '@/components/hackathons/overview/RegisterHackathonModal';
-import { HackathonBanner } from '@/components/hackathons/hackathonBanner';
-import { HackathonNavTabs } from '@/components/hackathons/hackathonNavTabs';
-import { HackathonOverview } from '@/components/hackathons/overview/hackathonOverview';
-import { HackathonResources } from '@/components/hackathons/resources/resources';
-import SubmissionTab from '@/components/hackathons/submissions/submissionTab';
-import { HackathonDiscussions } from '@/components/hackathons/discussion/comment';
-import { TeamFormationTab } from '@/components/hackathons/team-formation/TeamFormationTab';
-import { WinnersTab } from '@/components/hackathons/winners/WinnersTab';
-import LoadingScreen from '@/features/projects/components/CreateProjectModal/LoadingScreen';
-import { useTimelineEvents } from '@/hooks/hackathon/use-timeline-events';
-import { toast } from 'sonner';
-import type { Participant } from '@/lib/api/hackathons';
-import { HackathonStickyCard } from '@/components/hackathons/hackathonStickyCard';
-import { HackathonParticipants } from '@/components/hackathons/participants/hackathonParticipant';
-import { useCommentSystem } from '@/hooks/use-comment-system';
-import { CommentEntityType } from '@/types/comment';
-import { useTeamPosts } from '@/hooks/hackathon/use-team-posts';
-import { HackathonWinner } from '@/lib/api/hackathons';
-
-export default function HackathonPage() {
- const router = useRouter();
- const searchParams = useSearchParams();
- const params = useParams();
-
- const {
- currentHackathon,
- submissions,
- winners,
- loading,
- setCurrentHackathon,
- refreshCurrentHackathon,
- } = useHackathonData();
-
- const timeline_Events = useTimelineEvents(currentHackathon, {
- includeEndDate: false,
- dateFormat: { month: 'short', day: 'numeric', year: 'numeric' },
- });
-
- const hackathonId = params.slug as string;
- const [activeTab, setActiveTab] = useState('overview');
- const [showRegisterModal, setShowRegisterModal] = useState(false);
-
- // Fetch discussion comments for count
- const { comments: discussionComments } = useCommentSystem({
- entityType: CommentEntityType.HACKATHON,
- entityId: hackathonId,
- page: 1,
- limit: 100,
- enabled: !!hackathonId,
- });
-
- // Fetch team posts for count
- const { posts: teamPosts } = useTeamPosts({
- hackathonSlugOrId: hackathonId,
- autoFetch: !!hackathonId,
- });
-
- const hackathonTabs = useMemo(() => {
- const hasParticipants =
- Array.isArray(currentHackathon?.participants) &&
- currentHackathon.participants.length > 0;
-
- const hasResources = currentHackathon?.resources?.[0];
- const participantType = currentHackathon?.participantType;
- const isTeamHackathon =
- participantType === 'TEAM' ||
- participantType === 'TEAM_OR_INDIVIDUAL' ||
- participantType === 'INDIVIDUAL';
- const isTabEnabled =
- currentHackathon?.enabledTabs?.includes('joinATeamTab') !== false;
-
- // For testing: Use mock winners if real winners are empty
- // const displayWinners =
- // winners && winners.length > 0 ? winners : MOCK_WINNERS;
- // const hasWinners = displayWinners.length > 0;
- const hasWinners = winners && winners.length > 0;
-
- // For testing: Force enable winners tab
- // const isWinnersTabEnabled =
- // currentHackathon?.enabledTabs?.includes('winnersTab') !== false;
- // const isWinnersTabEnabled = true;
- const isWinnersTabEnabled =
- currentHackathon?.enabledTabs?.includes('winnersTab') !== false;
-
- const tabs = [
- { id: 'overview', label: 'Overview' },
- ...(hasParticipants
- ? [
- {
- id: 'participants',
- label: 'Participants',
- badge: currentHackathon?.participants.length,
- },
- ]
- : []),
- ...(hasResources
- ? [
- {
- id: 'resources',
- label: 'Resources',
- badge: currentHackathon?.resources?.length,
- },
- ]
- : []),
- {
- id: 'submission',
- label: 'Submissions',
- badge: submissions.filter(p => p.status === 'Approved').length,
- },
- {
- id: 'discussions',
- label: 'Discussions',
- badge: discussionComments.comments.length,
- },
- ];
-
- if (isTeamHackathon && isTabEnabled) {
- tabs.push({
- id: 'team-formation',
- label: 'Find Team',
- badge: teamPosts.length,
- });
- }
-
- if (hasWinners && isWinnersTabEnabled) {
- tabs.push({
- id: 'winners',
- label: 'Winners',
- });
- }
-
- return tabs;
- }, [
- currentHackathon?.participants,
- currentHackathon?.resources,
- currentHackathon?.participantType,
- currentHackathon?.enabledTabs,
- currentHackathon?.organizationId,
- submissions,
- discussionComments.comments.length,
- teamPosts.length,
- hackathonId,
- winners,
- ]);
-
- // Refresh hackathon data
- const refreshHackathonData = useCallback(async () => {
- if (hackathonId && refreshCurrentHackathon) {
- await refreshCurrentHackathon();
- }
- }, [hackathonId, refreshCurrentHackathon]);
-
- // Registration status
- const {
- isRegistered,
- hasSubmitted,
- setParticipant,
- register: registerForHackathon,
- } = useRegisterHackathon({
- hackathon: currentHackathon
- ? {
- id: currentHackathon.id,
- slug: currentHackathon.slug,
- isParticipant: currentHackathon.isParticipant,
- }
- : null,
- organizationId: undefined,
- });
-
- // Leave hackathon functionality
- const { isLeaving, leave: leaveHackathon } = useLeaveHackathon({
- hackathonSlugOrId: currentHackathon?.id || '',
- organizationId: undefined,
- });
- const handleRegister = async () => {
- try {
- const participantData = await registerForHackathon();
-
- toast.success('Successfully registered for hackathon!');
- handleRegisterSuccess(participantData);
- } catch {
- // Error handled in hook
- }
- };
-
- // Check if hackathon has ended
- // const isEnded = useMemo(() => {
- // if (!currentHackathon?.deadline) return false
- // const deadline = new Date(currentHackathon.deadline)
- // const now = new Date()
- // return now > deadline
- // }, [currentHackathon?.deadline])
-
- // Team formation availability
- const isTeamHackathon =
- currentHackathon?.participantType === 'TEAM' ||
- currentHackathon?.participantType === 'TEAM_OR_INDIVIDUAL' ||
- currentHackathon?.participantType === 'INDIVIDUAL';
- const isTeamFormationEnabled =
- isTeamHackathon &&
- currentHackathon?.enabledTabs?.includes('joinATeamTab') !== false;
-
- // Event handlers
- const handleJoinClick = () => {
- handleRegister();
- };
+import { Metadata } from 'next';
+import { notFound } from 'next/navigation';
+import { getHackathon } from '@/lib/api/hackathon';
+import { generateHackathonMetadata } from '@/lib/metadata';
+import { HackathonDataProvider } from '@/lib/providers/hackathonProvider';
+import HackathonPageClient from './HackathonPageClient';
+
+interface HackathonPageProps {
+ params: Promise<{ slug: string }>;
+}
- const handleLeaveClick = async () => {
- try {
- setParticipant(null);
- await leaveHackathon();
- refreshHackathonData();
- router.push('?tab=overview');
- } catch (error) {
- const errorMessage =
- error instanceof Error ? error.message : 'Failed to leave hackathon';
- toast.error(errorMessage);
- // refreshHackathonData() will update the isParticipant status
+export async function generateMetadata({
+ params,
+}: HackathonPageProps): Promise
+
+
+
+
+
+
+
+
+ {/* Title & Metadata */}
+
+
+
+
+ {/* Content */}
+
+ {hackathonName && (
+
+ {hackathonName}
+
+ )}
+ {announcement.isPinned && (
+
+
+ )}
+
+ Published
+
+
+
+ + {announcement.title} +
+ +
+
+
+
+
+
+ {announcement.author?.name?.charAt(0) || (
+
+
+ {announcement.author?.name || 'Organizer'}
+
+
+
+
+ {markdownLoading ? (
+
+
+ {/* Footer */}
+
+
+
+ ) : (
+
+ {styledContent}
+
+ )}
+
+ window.close()}
+ variant='outline'
+ size='sm'
+ >
+ Return to Hackathon
+
+
+ End of Announcement
++ This announcement was published by the hackathon organizers. +
+
-
+
-
- - Hackathon not found -
-- The hackathon you're looking for doesn't exist. -
-
-
- );
}
diff --git a/app/(landing)/hackathons/preview/[orgId]/[draftId]/page.tsx b/app/(landing)/hackathons/preview/[orgId]/[draftId]/page.tsx
index 2cc8283af..558a16372 100644
--- a/app/(landing)/hackathons/preview/[orgId]/[draftId]/page.tsx
+++ b/app/(landing)/hackathons/preview/[orgId]/[draftId]/page.tsx
@@ -4,6 +4,7 @@ import { useState, useEffect, useMemo } from 'react';
import { useRouter, useSearchParams } from 'next/navigation';
import { ArrowLeft } from 'lucide-react';
import { getDraft, PrizeTier, VenueType } from '@/lib/api/hackathons';
+import { getOrganization } from '@/lib/api/organization';
import { HackathonBanner } from '@/components/hackathons/hackathonBanner';
import { HackathonNavTabs } from '@/components/hackathons/hackathonNavTabs';
import { HackathonOverview } from '@/components/hackathons/overview/hackathonOverview';
@@ -93,6 +94,18 @@ export default function DraftPreviewPage({ params }: PreviewPageProps) {
resolvedParams.orgId,
resolvedParams.draftId
);
+ let organizationData = { name: '', logo: '' };
+ try {
+ const orgRes = await getOrganization(resolvedParams.orgId);
+ if (orgRes) {
+ organizationData = {
+ name: orgRes.name,
+ logo: orgRes.logo || '',
+ };
+ }
+ } catch (orgErr) {
+ console.error('Failed to fetch organization for preview:', orgErr);
+ }
if (response.success && response.data) {
const draft = response.data;
@@ -111,8 +124,8 @@ export default function DraftPreviewPage({ params }: PreviewPageProps) {
organizationId: resolvedParams.orgId,
organization: {
id: resolvedParams.orgId,
- name: '', // We don't have organizer name from draft
- logo: '',
+ name: organizationData.name,
+ logo: organizationData.logo,
},
status: 'DRAFT',
@@ -132,22 +145,14 @@ export default function DraftPreviewPage({ params }: PreviewPageProps) {
timezone: draft.data.timeline?.timezone || 'UTC',
startDate: draft.data.timeline?.startDate || '',
- endDate: draft.data.timeline?.winnerAnnouncementDate || '',
submissionDeadline: draft.data.timeline?.submissionDeadline || '',
registrationDeadline:
- draft.data.participation?.registrationDeadline || '',
- customRegistrationDeadline:
- draft.data.participation?.registrationDeadline || null,
+ draft.data.timeline?.registrationDeadline || '',
+ judgingDeadline: draft.data.timeline?.judgingDeadline || '',
registrationOpen: false,
- registrationDeadlinePolicy:
- (draft.data.participation?.registrationDeadlinePolicy as
- | 'BEFORE_START'
- | 'BEFORE_SUBMISSION_DEADLINE'
- | 'CUSTOM') || 'BEFORE_SUBMISSION_DEADLINE',
daysUntilStart: 0,
- daysUntilEnd: 0,
participantType: (draft.data.participation?.participantType ===
'individual'
@@ -500,7 +505,6 @@ export default function DraftPreviewPage({ params }: PreviewPageProps) {
participants={0}
imageUrl={previewHackathon.banner}
startDate={previewHackathon.startDate}
- endDate={previewHackathon.endDate}
/>
{/* Tabs */}
diff --git a/app/(landing)/org/[slug]/loading.tsx b/app/(landing)/org/[slug]/loading.tsx
new file mode 100644
index 000000000..51ad4c26d
--- /dev/null
+++ b/app/(landing)/org/[slug]/loading.tsx
@@ -0,0 +1,42 @@
+import { Skeleton } from '@/components/ui/skeleton';
+
+export default function OrgProfileLoading() {
+ return (
+
- {/* Main Content (2/3 width on desktop) */}
-
-
- {/* Registration Modal */}
- {hackathonId && (
-
- {/* Banner - Shows on all screens */}
-
-
- {/* Sidebar - Sticky Card (1/3 width on desktop, hidden on mobile) */}
-
- {activeTab === 'overview' && (
- ({
- id: tier.id,
- place: tier.place,
- currency: tier.currency,
- passMark: tier.passMark,
- description: tier.description,
- prizeAmount: tier.prizeAmount, // Keep as string to match PrizeTier interface
- }))}
- totalPrizePool={currentHackathon.prizeTiers
- .reduce(
- (acc, prize) => acc + Number(prize.prizeAmount || 0),
- 0
- )
- .toString()}
- hackathonSlugOrId={hackathonId}
- venue={{
- type: currentHackathon.venueType.toLowerCase() as
- | 'virtual'
- | 'physical',
- country: currentHackathon.country,
- state: currentHackathon.state,
- city: currentHackathon.city,
- venueName: currentHackathon.venueName,
- venueAddress: currentHackathon.venueAddress,
- }}
- />
- )}
-
- {activeTab === 'resources' &&
- currentHackathon.resources?.length > 0 &&
-
-
-
+
+
+ {/* Stats grid skeleton */}
+
+
+
+
+
+
+
+ {[1, 2, 3].map(i => (
+
+
+ {[1, 2, 3, 4].map(i => (
+
+
+ {/* About skeleton */}
+
+
+ Organization not found
+
+
+
+
+
+
+ {/* Stats Grid */}
+
+
+
+ {/* Logo */}
+
+
+ {profile.logoUrl ? (
+
+
+ {/* Info */}
+
+
+ + {profile.name} +
+ {profile.description && ( ++ {profile.description} +
+ )} +
+ {statCards.map((stat, index) => {
+ const Icon = stat.icon;
+ return (
+
+
+
+ );
+ })}
+
+
+
+ {stat.value}
+
+ {stat.label}
+
+
+
+
+
+
+
+
+ {[1, 2, 3, 4].map(i => (
+
+
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/announcement/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/announcement/page.tsx
index df479615a..d73e70426 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/announcement/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/announcement/page.tsx
@@ -1,84 +1,376 @@
'use client';
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
import { useParams } from 'next/navigation';
-import { Megaphone } from 'lucide-react';
+import { Megaphone, Trash2, Edit2, Pin, Send } from 'lucide-react';
import { AnnouncementEditor } from '@/components/ui/shadcn-io/announcement-editor';
import { BoundlessButton } from '@/components/buttons';
import { toast } from 'sonner';
-import { api } from '@/lib/api/api';
import { AuthGuard } from '@/components/auth';
import Loading from '@/components/Loading';
+import {
+ createAnnouncement,
+ listAnnouncements,
+ deleteAnnouncement,
+ publishAnnouncement,
+ updateAnnouncement,
+ HackathonAnnouncement,
+} from '@/lib/api/hackathons/index';
+import { Input } from '@/components/ui/input';
+import { Badge } from '@/components/ui/badge';
+import { cn } from '@/lib/utils';
+import {
+ Dialog,
+ DialogContent,
+ DialogHeader,
+ DialogTitle,
+ DialogFooter,
+} from '@/components/ui/dialog';
+import { Switch } from '@/components/ui/switch';
export default function AnnouncementPage() {
const params = useParams();
const organizationId = params.id as string;
const hackathonId = params.hackathonId as string;
+ const [announcements, setAnnouncements] = useState(
+ []
+ );
+ const [isLoading, setIsLoading] = useState(true);
+ const [title, setTitle] = useState('');
const [content, setContent] = useState('');
- const [isPublishing, setIsPublishing] = useState(false);
+ const [isPinned, setIsPinned] = useState(false);
+ const [isDraft, setIsDraft] = useState(true);
+ const [isSubmitting, setIsSubmitting] = useState(false);
+ const [editingId, setEditingId] = useState(null);
+ const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
+ const [announcementToDelete, setAnnouncementToDelete] = useState<
+ string | null
+ >(null);
+
+ useEffect(() => {
+ fetchAnnouncements();
+ }, [hackathonId]);
+
+ const fetchAnnouncements = async () => {
+ try {
+ const data = await listAnnouncements(hackathonId);
+ setAnnouncements(data);
+ } catch (error) {
+ console.error('Failed to fetch announcements:', error);
+ toast.error('Failed to load announcements');
+ } finally {
+ setIsLoading(false);
+ }
+ };
- const handlePublish = async () => {
+ const handleSave = async (draft = true) => {
+ if (!title.trim()) {
+ toast.error('Please enter a title');
+ return;
+ }
if (!content.trim()) {
toast.error('Please enter announcement content');
return;
}
- setIsPublishing(true);
+ setIsSubmitting(true);
try {
- await api.post(
- `/organizations/${organizationId}/hackathons/${hackathonId}/announcements`,
- {
+ if (editingId) {
+ await updateAnnouncement(organizationId, hackathonId, editingId, {
+ title,
+ content,
+ isPinned,
+ isDraft: draft,
+ });
+ toast.success(
+ draft ? 'Announcement saved as draft' : 'Announcement updated'
+ );
+ } else {
+ await createAnnouncement(organizationId, hackathonId, {
+ title,
content,
- }
+ isPinned,
+ isDraft: draft,
+ });
+ toast.success(
+ draft ? 'Announcement saved as draft' : 'Announcement published'
+ );
+ }
+ resetForm();
+ fetchAnnouncements();
+ } catch (error) {
+ console.error('Failed to save announcement:', error);
+ toast.error('Failed to save announcement');
+ } finally {
+ setIsSubmitting(false);
+ }
+ };
+
+ const handleDelete = async () => {
+ if (!announcementToDelete) return;
+
+ try {
+ await deleteAnnouncement(
+ organizationId,
+ hackathonId,
+ announcementToDelete
);
+ toast.success('Announcement deleted');
+ fetchAnnouncements();
+ } catch (error) {
+ console.error('Failed to delete announcement:', error);
+ toast.error('Failed to delete announcement');
+ } finally {
+ setIsDeleteDialogOpen(false);
+ setAnnouncementToDelete(null);
+ }
+ };
- toast.success('Announcement published successfully!');
- setContent('');
- } catch {
+ const handlePublishDraft = async (id: string) => {
+ try {
+ await publishAnnouncement(organizationId, hackathonId, id);
+ toast.success('Announcement published');
+ fetchAnnouncements();
+ } catch (error) {
+ console.error('Failed to publish announcement:', error);
toast.error('Failed to publish announcement');
- } finally {
- setIsPublishing(false);
}
};
+ const handleEdit = (announcement: HackathonAnnouncement) => {
+ setEditingId(announcement.id);
+ setTitle(announcement.title);
+ setContent(announcement.content);
+ setIsPinned(announcement.isPinned);
+ setIsDraft(announcement.isDraft);
+ window.scrollTo({ top: 0, behavior: 'smooth' });
+ };
+
+ const resetForm = () => {
+ setEditingId(null);
+ setTitle('');
+ setContent('');
+ setIsPinned(false);
+ setIsDraft(true);
+ };
+
return (
-
- ([]);
+ const [criteria, setCriteria] = useState([]);
const [isLoading, setIsLoading] = useState(true);
- const [page, setPage] = useState(1);
- const [pagination, setPagination] = useState({
- page: 1,
- totalPages: 1,
- total: 0,
- limit: 10,
- });
-
- const fetchSubmissions = useCallback(
- async (pageNum = 1) => {
- if (!organizationId || !hackathonId) return;
-
- setIsLoading(true);
+ const [activeTab, setActiveTab] = useState('overview');
+ const [isAddingJudge, setIsAddingJudge] = useState(false);
+ const [orgMembers, setOrgMembers] = useState([]);
+ const [currentJudges, setCurrentJudges] = useState([]);
+ const [isRefreshingJudges, setIsRefreshingJudges] = useState(false);
+ const [currentUserRole, setCurrentUserRole] = useState<
+ 'owner' | 'admin' | 'member' | null
+ >(null);
+ const [judgingResults, setJudgingResults] = useState([]);
+ const [judgingSummary, setJudgingSummary] =
+ useState(null);
+ const [isFetchingResults, setIsFetchingResults] = useState(false);
+ const [winners, setWinners] = useState([]);
+ const [isFetchingWinners, setIsFetchingWinners] = useState(false);
+ const [isPublishing, setIsPublishing] = useState(false);
+ const [isCurrentUserJudge, setIsCurrentUserJudge] = useState(false);
+ const [currentUserId, setCurrentUserId] = useState(null);
+
+ const canManageJudges =
+ currentUserRole === 'owner' || currentUserRole === 'admin';
+ const canPublishResults = canManageJudges && isCurrentUserJudge;
+ const resultsPublished = winners.length > 0;
+
+ const fetchJudges = useCallback(async () => {
+ // Priority: activeOrgId from context, then params.id
+ const targetOrgId = activeOrgId || organizationId;
+ if (!targetOrgId || !hackathonId) return;
+
+ setIsRefreshingJudges(true);
+ let finalMembers: any[] = [];
+ let judges: any[] = [];
+
+ // 1. Try to fetch organization members
+ try {
+ // First try legacy API
try {
- const response = await getJudgingSubmissions(
- organizationId,
- hackathonId,
- pageNum,
- 10
+ const membersRes = await getOrganizationMembers(targetOrgId);
+ if (
+ membersRes.success &&
+ Array.isArray(membersRes.data) &&
+ membersRes.data.length > 0
+ ) {
+ finalMembers = membersRes.data;
+ }
+ } catch (err) {
+ console.warn(
+ 'Legacy member fetch failed, trying Better Auth fallback:',
+ err
);
+ }
- if (response.success) {
- setSubmissions(response.data || []);
- setPagination(response.meta.pagination);
- setPage(pageNum);
+ // If still empty, try Better Auth directly
+ if (finalMembers.length === 0) {
+ const { data: baData } = await authClient.organization.listMembers({
+ query: { organizationId: targetOrgId, limit: 100 },
+ });
+
+ if (baData?.members && Array.isArray(baData.members)) {
+ finalMembers = baData.members.map((m: any) => ({
+ id: m.userId,
+ userId: m.userId,
+ name: m.user.name || m.user.email,
+ email: m.user.email,
+ image: m.user.image,
+ role: m.role,
+ }));
}
- } catch {
- toast.error('Failed to load submissions');
- } finally {
- setIsLoading(false);
}
- },
- [organizationId, hackathonId]
- );
+ } catch (err) {
+ console.error('All member fetching attempts failed:', err);
+ }
+
+ // 2. Fetch judges
+ try {
+ const judgesRes = await getHackathonJudges(targetOrgId, hackathonId);
+ if (judgesRes.success) {
+ judges = judgesRes.data || [];
+ }
+ } catch (err) {
+ console.error('Failed to fetch judges:', err);
+ }
+
+ setOrgMembers(finalMembers);
+ setCurrentJudges(judges);
+ setIsRefreshingJudges(false);
+
+ // Determine current user role and judge status
+ const { data: session } = await authClient.getSession();
+ const currentUserId = session?.user?.id;
+ if (currentUserId && finalMembers.length > 0) {
+ const me = finalMembers.find(
+ (m: any) => m.userId === currentUserId || m.id === currentUserId
+ );
+ setCurrentUserRole(me?.role || null);
+
+ // Check if current user is a judge
+ const isJudge = judges.some(
+ (j: any) => j.userId === currentUserId || j.id === currentUserId
+ );
+ setIsCurrentUserJudge(isJudge);
+ }
+
+ // Set current user ID for child components
+ if (currentUserId) {
+ setCurrentUserId(currentUserId);
+ }
+ }, [organizationId, hackathonId, activeOrgId]);
+
+ const fetchResults = useCallback(async () => {
+ if (!organizationId || !hackathonId) return;
+
+ setIsFetchingResults(true);
+ try {
+ const res = await getJudgingResults(organizationId, hackathonId);
+
+ if (res.success && res.data) {
+ setJudgingResults(res.data.results || []);
+ setJudgingSummary(res.data);
+ } else {
+ setJudgingResults([]);
+ setJudgingSummary(null);
+ if (!res.success) {
+ toast.error((res as any).message || 'Failed to load judging results');
+ }
+ }
+ } catch (error: any) {
+ console.error('Error fetching results:', error);
+ setJudgingResults([]);
+ setJudgingSummary(null);
+ toast.error(
+ error.response?.data?.message ||
+ error.message ||
+ 'Failed to load judging results'
+ );
+ } finally {
+ setIsFetchingResults(false);
+ }
+ }, [organizationId, hackathonId]);
+
+ const fetchWinners = useCallback(async () => {
+ if (!organizationId || !hackathonId) return;
+ setIsFetchingWinners(true);
+ try {
+ const res = await getJudgingWinners(organizationId, hackathonId);
+ if (res.success && res.data) {
+ setWinners(Array.isArray(res.data) ? res.data : []);
+ }
+ } catch (error) {
+ console.error('Error fetching winners:', error);
+ } finally {
+ setIsFetchingWinners(false);
+ }
+ }, [organizationId, hackathonId]);
+
+ const fetchData = useCallback(async () => {
+ if (!organizationId || !hackathonId) return;
+
+ setIsLoading(true);
+ try {
+ // Fetch submissions, criteria, and judges/members
+ const [submissionsRes, criteriaRes] = await Promise.all([
+ getJudgingSubmissions(organizationId, hackathonId, 1, 50),
+ getJudgingCriteria(hackathonId),
+ ]);
+
+ // Trigger judges, results, and winners fetch in parallel (winners => results published state)
+ fetchJudges();
+ fetchResults();
+ fetchWinners();
+
+ let enrichedSubmissions: JudgingSubmission[] = [];
+
+ if (submissionsRes.success) {
+ // Standard submissions endpoint returns { data: { submissions: [], pagination: {} } }
+ const submissionData =
+ (submissionsRes.data as any)?.submissions ||
+ submissionsRes.data ||
+ [];
+ const basicSubmissions = Array.isArray(submissionData)
+ ? submissionData
+ : [];
+
+ // 2. Fetch full details for each submission to get user info
+ // We do this by fetching the project details, as submission endpoints lack user data
+ const detailsPromises = basicSubmissions.map(async (sub: any) => {
+ try {
+ // Check if we already have sufficient user data
+ if (
+ sub.participant?.user?.profile?.firstName ||
+ sub.participant?.name
+ )
+ return sub;
+
+ // Try fetch project details if we have projectId
+ if (sub.projectId) {
+ const project = await getCrowdfundingProject(sub.projectId);
+ if (project && project.project && project.project.creator) {
+ const creator = project.project.creator;
+ return {
+ ...sub,
+ participant: {
+ ...sub.participant,
+ // Use creator info for participant
+ name: creator.name,
+ username: creator.username,
+ image: creator.image,
+ email: creator.email,
+ user: {
+ ...sub.participant?.user,
+ name: creator.name,
+ username: creator.username,
+ image: creator.image,
+ email: creator.email,
+ profile: {
+ ...sub.participant?.user?.profile,
+ firstName: creator.name?.split(' ')[0] || '',
+ lastName:
+ creator.name?.split(' ').slice(1).join(' ') || '',
+ username: creator.username,
+ avatar: creator.image,
+ },
+ },
+ },
+ };
+ }
+ }
+
+ // Fallback to submission details check if project fail or no projectId
+ const detailsRes = await getSubmissionDetails(sub.id);
+ if (detailsRes.success && detailsRes.data) {
+ const details = detailsRes.data as any;
+ return {
+ ...sub,
+ participant: {
+ ...sub.participant,
+ ...details.participant,
+ user: details.participant?.user || sub.participant?.user,
+ },
+ };
+ }
+ return sub;
+ } catch (err) {
+ console.error(
+ `Failed to fetch details for submission ${sub.id}`,
+ err
+ );
+ return sub;
+ }
+ });
+
+ enrichedSubmissions = await Promise.all(detailsPromises);
+ setSubmissions(enrichedSubmissions);
+ } else {
+ setSubmissions([]);
+ }
+
+ // Handle criteria response safely
+ setCriteria(Array.isArray(criteriaRes) ? criteriaRes : []);
+ } catch (error) {
+ console.error('Judging data fetch error:', error);
+ toast.error('Failed to load judging data');
+ } finally {
+ setIsLoading(false);
+ }
+ }, [organizationId, hackathonId, fetchJudges, fetchResults, fetchWinners]);
useEffect(() => {
- fetchSubmissions();
- }, [fetchSubmissions]);
+ fetchData();
+ }, [fetchData]);
const handleSuccess = () => {
- fetchSubmissions(page);
+ fetchData();
+ fetchResults(); // Refresh results to update metrics/table
+ };
+
+ const handleAddJudge = async (userId: string, email: string) => {
+ setIsAddingJudge(true);
+ try {
+ const res = await addJudge(organizationId, hackathonId, {
+ userId,
+ email,
+ });
+ if (res.success) {
+ toast.success('Judge assigned successfully');
+ fetchJudges();
+ } else {
+ toast.error(res.message || 'Failed to assign judge');
+ }
+ } catch (error: any) {
+ console.error('Error adding judge:', error);
+ toast.error(
+ error.response?.data?.message ||
+ error.message ||
+ 'Failed to assign judge'
+ );
+ } finally {
+ setIsAddingJudge(false);
+ }
};
- // Calculate statistics
- const totalSubmissions = pagination.total;
- const averageScore =
- submissions.length > 0
- ? submissions.reduce((sum, sub) => {
- return sum + (sub.averageScore || 0);
- }, 0) / submissions.length
+ const handleRemoveJudge = async (userId: string) => {
+ try {
+ const res = await removeJudge(organizationId, hackathonId, userId);
+ if (res.success) {
+ toast.success('Judge removed successfully');
+ fetchJudges();
+ } else {
+ toast.error(res.message || 'Failed to remove judge');
+ }
+ } catch (error: any) {
+ console.error('Error removing judge:', error);
+ toast.error(
+ error.response?.data?.message ||
+ error.message ||
+ 'Failed to remove judge'
+ );
+ }
+ };
+
+ const handlePublishResults = async () => {
+ setIsPublishing(true);
+ try {
+ const res = await publishJudgingResults(organizationId, hackathonId);
+ if (res.success) {
+ toast.success('Results published successfully!');
+ fetchResults();
+ fetchWinners();
+ } else {
+ toast.error(res.message || 'Failed to publish results');
+ }
+ } catch (error: any) {
+ toast.error(error.message || 'Failed to publish results');
+ } finally {
+ setIsPublishing(false);
+ }
+ };
+
+ // Use pre-calculated statistics from the API if available, otherwise fallback to local calculation
+ const gradedCount = judgingSummary
+ ? judgingSummary.submissionsScoredCount
+ : judgingResults.length;
+
+ const totalPossibleSubmissions = judgingSummary
+ ? judgingSummary.totalSubmissions
+ : submissions.length;
+
+ const averageHackathonScore = judgingSummary
+ ? judgingSummary.averageScoreAcrossAll
+ : judgingResults.length > 0
+ ? judgingResults.reduce(
+ (acc, curr) => acc + (curr.averageScore || 0),
+ 0
+ ) / judgingResults.length
: 0;
- const totalJudges = new Set(
- submissions.flatMap(sub => sub.scores.map(score => score.judge.id))
- ).size;
+
+ const assignedJudgesCount = judgingSummary
+ ? judgingSummary.judgesAssigned
+ : currentJudges.length;
return (
-
+
+
+
);
}
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/judging/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/judging/page.tsx
index 5643b1dd6..ceb280bbc 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/judging/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/judging/page.tsx
@@ -3,152 +3,735 @@
import { useEffect, useState, useCallback } from 'react';
import MetricsCard from '@/components/organization/cards/MetricsCard';
import JudgingParticipant from '@/components/organization/cards/JudgingParticipant';
+import EmptyState from '@/components/EmptyState';
import { useParams } from 'next/navigation';
import {
getJudgingSubmissions,
+ getJudgingCriteria,
+ addJudge,
+ removeJudge,
+ getHackathonJudges,
+ getJudgingResults,
+ getJudgingWinners,
+ publishJudgingResults,
+ type JudgingCriterion,
type JudgingSubmission,
-} from '@/lib/api/hackathons';
-import { Loader2 } from 'lucide-react';
+ type JudgingResult,
+ type AggregatedJudgingResults,
+} from '@/lib/api/hackathons/judging';
+import { getSubmissionDetails } from '@/lib/api/hackathons/participants';
+import { getOrganizationMembers } from '@/lib/api/organization';
+import { getCrowdfundingProject } from '@/features/projects/api';
+import { authClient } from '@/lib/auth-client';
+import { useOrganization } from '@/lib/providers/OrganizationProvider';
+import { Loader2, Trophy, CheckCircle2 } from 'lucide-react';
import { toast } from 'sonner';
import { Button } from '@/components/ui/button';
import { AuthGuard } from '@/components/auth/AuthGuard';
import Loading from '@/components/Loading';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import { JudgingCriteriaList } from '@/components/organization/hackathons/judging/JudgingCriteriaList';
+import JudgingResultsTable from '@/components/organization/hackathons/judging/JudgingResultsTable';
export default function JudgingPage() {
const params = useParams();
const organizationId = params.id as string;
const hackathonId = params.hackathonId as string;
+ const { activeOrgId, activeOrg } = useOrganization();
const [submissions, setSubmissions] = useState- Create Announcement -
-- Share important updates, reminders, or announcements with the - community. -
+
+
-
+ {/* Header */}
+
-
+
+ Cancel Edit
+
+ )}
+
+
+ {/* Editor Card */}
+
+
+ {editingId && (
+ + {editingId ? 'Edit Announcement' : 'Create Announcement'} +
++ {editingId + ? 'Update your announcement details.' + : 'Share important updates, reminders, or announcements with the community.'} +
+
+
-
+
+
+
+
+ setTitle(e.target.value)}
+ placeholder='Enter announcement title'
+ className='focus:border-primary/50 border-zinc-800 bg-zinc-950/50 text-white'
+ maxLength={100}
+ />
+
+
+
+
+
+
+
+
+
+
+
+
+
+ handleSave(false)}
+ disabled={isSubmitting}
+ className='bg-primary hover:bg-primary/90'
+ >
+
+ handleSave(true)}
+ disabled={isSubmitting}
+ className='border-zinc-800 text-zinc-300'
+ >
+ {editingId ? 'Save Draft' : 'Save as Draft'}
+
+
-
+
+
+
+
+
+ {isLoading ? (
+ Existing Announcements
+
+
+ ) : announcements.length === 0 ? (
+
+ No announcements yet.
+
+ ) : (
+
+ {announcements.map(item => (
+
+ ))}
+
+ )}
+ {/* Delete Confirmation Dialog */}
+
-
-
- 0 ? averageScore.toFixed(2) : 'N/A'}
- subtitle={
- submissions.length > 0 ? 'Across all submissions' : undefined
- }
- />
-
-
- {isLoading ? (
-
-
+
+
+
- ) : submissions.length === 0 ? (
- Judging Dashboard
++ Manage and grade shortlisted submissions +
- No shortlisted submissions found
+
+
);
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/page.tsx
index cf5323177..884c6275f 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/page.tsx
@@ -9,7 +9,7 @@ import {
Check,
} from 'lucide-react';
import { useHackathons } from '@/hooks/use-hackathons';
-import { useEffect } from 'react';
+import { useEffect, useState } from 'react';
import { useHackathonAnalytics } from '@/hooks/use-hackathon-analytics';
import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert';
import { HackathonStatistics } from '@/components/organization/hackathons/details/HackathonStatistics';
@@ -17,12 +17,21 @@ import { HackathonCharts } from '@/components/organization/hackathons/details/Ha
import { HackathonTimeline } from '@/components/organization/hackathons/details/HackathonTimeline';
import { AuthGuard } from '@/components/auth';
import Loading from '@/components/Loading';
+import HackathonPublishedModal from '@/components/organization/hackathons/new/tabs/components/review/HackathonPublishedModal';
+import type { PublishResponseData } from '@/hooks/use-hackathon-publish';
+
+const STORAGE_KEY = 'boundless_hackathon_published';
export default function HackathonPage() {
const params = useParams();
const organizationId = params.id as string;
const hackathonId = params.hackathonId as string;
+ const [publishedModalData, setPublishedModalData] = useState<{
+ publishResponse: PublishResponseData;
+ organizationId: string;
+ } | null>(null);
+
const { currentHackathon, currentLoading, currentError, fetchHackathon } =
useHackathons({
organizationId,
@@ -41,6 +50,37 @@ export default function HackathonPage() {
}
}, [organizationId, hackathonId, fetchHackathon]);
+ useEffect(() => {
+ try {
+ const raw = sessionStorage.getItem(STORAGE_KEY);
+ if (!raw) return;
+ const payload = JSON.parse(raw) as {
+ organizationId: string;
+ id: string;
+ slug: string;
+ publishedAt: string;
+ message: string;
+ escrowAddress: string;
+ transactionHash: string | null;
+ };
+ if (payload.id !== hackathonId) return;
+ sessionStorage.removeItem(STORAGE_KEY);
+ setPublishedModalData({
+ publishResponse: {
+ id: payload.id,
+ slug: payload.slug,
+ publishedAt: payload.publishedAt,
+ message: payload.message,
+ escrowAddress: payload.escrowAddress,
+ transactionHash: payload.transactionHash,
+ },
+ organizationId: payload.organizationId,
+ });
+ } catch {
+ // ignore
+ }
+ }, [hackathonId]);
+
if (currentLoading) {
return (
+ 0 ? Math.round((gradedCount / totalPossibleSubmissions) * 100) : 0}% Completion`}
+ />
+
- ) : (
- <>
-
- {submissions.map(submission => (
- {
+ setActiveTab(value);
+ if (value === 'results') {
+ fetchResults();
+ fetchWinners();
+ }
+ }}
+ className='w-full'
+ >
+
+
+ Overview
+
+
+ Criteria
+
+
+ Judges
+
+
+ Results
+
+
+
+
+ {isLoading ? (
+
-
- {/* Pagination */}
- {pagination.totalPages > 1 && (
-
+
+ ) : submissions.length > 0 ? (
+
+ {submissions.map(submission => (
+ 0}
+ judges={currentJudges}
+ isJudgesLoading={isRefreshingJudges}
+ currentUserId={currentUserId || undefined}
+ canOverrideScores={canManageJudges}
+ onSuccess={handleSuccess}
+ />
+ ))}
+
+ ) : (
+
-
-
- Page {pagination.page} of {pagination.totalPages}
-
-
+ )}
+
+
+
+
+
+
+
+
+
+
+
+
+ {/* Current Judges List */}
+
- )}
-
- )}
+
+
+ Current Judges
+ {isRefreshingJudges && (
+
+
+
+ {/* Org Members List - Only visible to admin/owner */}
+ {canManageJudges && (
+
+ Current Judges
+ {isRefreshingJudges && (
+
+
+ {currentJudges.length === 0 ? (
+
+
+
+ ))
+ )}
+
+
+ {canManageJudges && (
+
+ )}
+
+ {judge.image ? (
+ 
+ ) : (
+
+
+ {judge.name?.[0] || '?'}
+
+ )}
+
+
+ + {judge.name} +
++ Judge {index + 1} +
+
+
+ )}
+ Add from Organization Members +
++ Select members from your organization to assign them as + judges. +
+
+ {orgMembers.map((member: any) => {
+ const isAlreadyJudge = currentJudges.some(
+ j => j.id === member.id || j.userId === member.id
+ );
+ return (
+
+
+
+ );
+ })}
+ {orgMembers.length === 0 && !isRefreshingJudges && (
+
+
+
+
+ {member.image ? (
+ 
+ ) : (
+
+
+ {member.name?.[0] ||
+ member.username?.[0] ||
+ '?'}
+
+ )}
+
+
+ + {member.name || member.username} +
++ {member.email} +
+
+ {resultsPublished && (
+
+
+
+ )}
+
+ {!resultsPublished &&
+ canPublishResults &&
+ judgingResults.length > 0 && (
+
+
+ + Results published +
++ Winner rankings are live. This hackathon's results + have been finalized. +
+
+
+ )}
+
+ {winners.length > 0 && (
+
+
+
+ + Finalize Competition +
++ Publish the current rankings to name the winners. +
+
+
+
+
+ )}
+
+
+
+
+
+ + Current Standings +
+ {isFetchingResults ? ( +
+
+ ) : judgingResults.length > 0 ? (
+
@@ -95,6 +135,15 @@ export default function HackathonPage() {
return (
+ {
+ if (!open) setPublishedModalData(null);
+ }}
+ publishResponse={publishedModalData?.publishResponse ?? null}
+ organizationId={publishedModalData?.organizationId}
+ />
+
{/* Hero Section with Hackathon Name */}
+ Distribution Status Error
+ {distributionError}
+
+ )}
+
{!isLoading && !error && (
setIsPublishWizardOpen(true)}
onRankChange={handleRankChangeWrapper}
+ distributionStatus={distributionStatus}
+ isLoadingDistributionStatus={isLoadingDistributionStatus}
+ onRefreshDistributionStatus={refetchDistributionStatus}
+ resultsPublished={resultsPublished}
+ escrowAddress={hackathon?.escrowAddress || hackathon?.contractId}
/>
)}
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/settings/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/settings/page.tsx
index 2ba98388a..057d07dff 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/settings/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/settings/page.tsx
@@ -16,6 +16,8 @@ import {
} from 'lucide-react';
import { toast } from 'sonner';
import { api } from '@/lib/api/api';
+import { getHackathon, Hackathon } from '@/lib/api/hackathons';
+import { useEffect } from 'react';
import GeneralSettingsTab from '@/components/organization/hackathons/settings/GeneralSettingsTab';
import TimelineSettingsTab from '@/components/organization/hackathons/settings/TimelineSettingsTab';
import ParticipantSettingsTab from '@/components/organization/hackathons/settings/ParticipantSettingsTab';
@@ -32,101 +34,152 @@ export default function SettingsPage() {
const hackathonId = params.hackathonId as string;
const [isSaving, setIsSaving] = useState(false);
+ const [hackathon, setHackathon] = useState(null);
+ const [isLoading, setIsLoading] = useState(true);
+
+ const fetchHackathon = async () => {
+ try {
+ const res = await getHackathon(hackathonId);
+ setHackathon(res.data);
+ } catch {
+ toast.error('Failed to load hackathon data');
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ useEffect(() => {
+ if (hackathonId) {
+ fetchHackathon();
+ }
+ }, [hackathonId]);
const tabTriggerClassName =
'data-[state=active]:border-b-primary rounded-none border-b-2 border-transparent bg-transparent px-0 pt-4 pb-3 text-sm font-medium text-gray-400 transition-all data-[state=active]:text-white data-[state=active]:shadow-none flex items-center gap-2';
- const mockHackathonData = {
- info: {
- name: 'Web3 Innovation Hackathon',
- banner: 'https://example.com/banner.jpg',
- description: '
@@ -158,31 +207,7 @@ export default function HackathonPage() {
e => e.phase === 'Winner Announcement'
);
- // Manually append Winner Announcement if missing and date exists
const fullTimeline = [...timelineEvents];
- if (!hasWinnerAnnouncement && currentHackathon?.endDate) {
- const winnerDate = new Date(currentHackathon.endDate);
- const now = new Date();
- // Simple status logic for single date event
- // If date is passed, completed. If today (roughly), ongoing?
- // Or just use 'upcoming' if future, 'completed' if past.
- // Ideally we'd match the phase logic, but for a single date event:
- let status: 'completed' | 'ongoing' | 'upcoming' =
- 'upcoming';
- if (now > winnerDate) {
- status = 'completed';
- }
- // For "Winner Announcement", it might be "ongoing" on the day of?
- // keeping simple for now.
-
- fullTimeline.push({
- phase: 'Winner Announcement',
- description:
- 'Final results published and prizes distributed to winners.',
- date: currentHackathon.endDate,
- status: status,
- });
- }
return fullTimeline.map((phase, index) => {
const isLast = index === fullTimeline.length - 1;
@@ -229,7 +254,7 @@ export default function HackathonPage() {
{phase.description}
-
+
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/participants/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/participants/page.tsx
index 712d31c25..77c4ee389 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/participants/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/participants/page.tsx
@@ -137,9 +137,13 @@ const ParticipantsPage: React.FC = () => {
organizationId,
actualHackathonId
);
+ const stats = response.data as {
+ totalSubmissions?: number;
+ activeParticipants?: number;
+ };
setStatistics({
- participantsCount: response.data.participantsCount,
- submissionsCount: response.data.submissionsCount,
+ participantsCount: stats.activeParticipants ?? 0,
+ submissionsCount: stats.totalSubmissions ?? 0,
});
} catch (err) {
console.error('Failed to load statistics', err);
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/rewards/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/rewards/page.tsx
index ca45e6361..e97849a2c 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/rewards/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/rewards/page.tsx
@@ -7,6 +7,7 @@ import PublishWinnersWizard from '@/components/organization/hackathons/rewards/P
import { RewardsPageHeader } from '@/components/organization/hackathons/rewards/RewardsPageHeader';
import { RewardsPageContent } from '@/components/organization/hackathons/rewards/RewardsPageContent';
import { useHackathonRewards } from '@/hooks/use-hackathon-rewards';
+import { useRewardDistributionStatus } from '@/hooks/use-reward-distribution-status';
import { useRankAssignment } from '@/hooks/use-rank-assignment';
import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert';
import { AuthGuard } from '@/components/auth';
@@ -27,11 +28,21 @@ export default function RewardsPage() {
isLoadingSubmissions,
error,
refreshEscrow,
+ refetchHackathon,
+ resultsPublished,
+ hackathon,
} = useHackathonRewards(organizationId, hackathonId);
const { handleRankChange } = useRankAssignment();
const [isPublishWizardOpen, setIsPublishWizardOpen] = useState(false);
+ const {
+ distributionStatus,
+ isLoading: isLoadingDistributionStatus,
+ error: distributionError,
+ refetch: refetchDistributionStatus,
+ } = useRewardDistributionStatus(organizationId, hackathonId);
+
const maxRank = useMemo(() => prizeTiers.length, [prizeTiers.length]);
const winners = useMemo(
() => submissions.filter(s => s.rank && s.rank <= maxRank),
@@ -56,6 +67,8 @@ export default function RewardsPage() {
const handlePublishSuccess = () => {
refreshEscrow();
+ refetchDistributionStatus();
+ refetchHackathon();
};
return (
@@ -85,6 +98,14 @@ export default function RewardsPage() {
)}
+ {!isLoading && distributionError && (
+
{new Date(phase.date).toLocaleDateString()}
Join us for an exciting hackathon...
', - category: ['DeFi' as const], - venueType: 'virtual' as const, - country: '', - state: '', - city: '', - venueName: '', - venueAddress: '', - }, - timeline: { - startDate: new Date('2025-01-15'), - endDate: new Date('2025-01-20'), - registrationDeadline: new Date('2025-01-10'), - submissionDeadline: new Date('2025-01-18'), - timezone: 'UTC', - phases: [], - }, - participant: { - participantType: 'team_or_individual' as const, - teamMin: 2, - teamMax: 5, - about: '', - require_github: true, - require_demo_video: true, - require_other_links: false, - details_tab: true, - schedule_tab: true, - rules_tab: true, - reward_tab: true, - announcements_tab: true, - partners_tab: true, - join_a_team_tab: true, - projects_tab: true, - participants_tab: true, - }, - rewards: { - prizeTiers: [ - { - id: '1', - place: '1st', - prizeAmount: '10000', - currency: 'USDC', - description: '', - passMark: 80, - }, - { - id: '2', - place: '2nd', - prizeAmount: '5000', - currency: 'USDC', - description: '', - passMark: 70, - }, - { - id: '3', - place: '3rd', - prizeAmount: '3000', - currency: 'USDC', - description: '', - passMark: 60, - }, - ], - }, - collaboration: { - contactEmail: 'contact@example.com', - telegram: '', - discord: '', - socialLinks: [], - sponsorsPartners: [], - }, + // Mapping functions to convert Hackathon to tab data types + const getGeneralData = (h: Hackathon | null) => { + if (!h) return undefined; + return { + name: h.name, + tagline: h.tagline, + slug: h.slug, + banner: h.banner, + description: h.description, + categories: h.categories, + venueType: h.venueType.toLowerCase() as any, + country: h.country, + state: h.state, + city: h.city, + venueName: h.venueName, + venueAddress: h.venueAddress, + }; + }; + + const getTimelineData = (h: Hackathon | null) => { + if (!h) return undefined; + return { + startDate: h.startDate ? new Date(h.startDate) : undefined, + submissionDeadline: h.submissionDeadline + ? new Date(h.submissionDeadline) + : undefined, + timezone: h.timezone || 'UTC', + registrationDeadline: h.registrationDeadline + ? new Date(h.registrationDeadline) + : undefined, + judgingDeadline: h.judgingDeadline + ? new Date(h.judgingDeadline) + : undefined, + phases: h.phases?.map(p => ({ + ...p, + startDate: p.startDate ? new Date(p.startDate) : undefined, + endDate: p.endDate ? new Date(p.endDate) : undefined, + })) as any, + }; + }; + + const getParticipantData = (h: Hackathon | null) => { + if (!h) return undefined; + return { + participantType: h.participantType.toLowerCase() as any, + teamMin: h.teamMin, + teamMax: h.teamMax, + require_github: h.requireGithub, + require_demo_video: h.requireDemoVideo, + require_other_links: h.requireOtherLinks, + detailsTab: h.enabledTabs.includes('detailsTab'), + participantsTab: h.enabledTabs.includes('participantsTab'), + resourcesTab: h.enabledTabs.includes('resourcesTab'), + submissionTab: h.enabledTabs.includes('submissionTab'), + announcementsTab: h.enabledTabs.includes('announcementsTab'), + discussionTab: h.enabledTabs.includes('discussionTab'), + winnersTab: h.enabledTabs.includes('winnersTab'), + sponsorsTab: h.enabledTabs.includes('sponsorsTab'), + joinATeamTab: h.enabledTabs.includes('joinATeamTab'), + rulesTab: h.enabledTabs.includes('rulesTab'), + }; + }; + + const getAdvancedData = (h: Hackathon | null) => { + if (!h) return undefined; + const adv = h.metadata?.advancedSettings; + return { + isPublic: adv?.isPublic ?? true, + allowLateRegistration: adv?.allowLateRegistration ?? false, + requireApproval: adv?.requireApproval ?? false, + maxParticipants: adv?.maxParticipants, + customDomain: adv?.customDomain || '', + enableDiscord: adv?.enableDiscord ?? !!h.discord, + discordInviteLink: adv?.discordInviteLink || h.discord || '', + enableTelegram: adv?.enableTelegram ?? !!h.telegram, + telegramInviteLink: adv?.telegramInviteLink || h.telegram || '', + }; }; const handleSave = async (section: string, data: unknown) => { setIsSaving(true); try { - await api.patch( - `/organizations/${organizationId}/hackathons/${hackathonId}/settings/${section.toLowerCase()}`, - data - ); + if (section === 'General') { + await api.patch( + `/organizations/${organizationId}/hackathons/${hackathonId}/content`, + { information: data } + ); + } else if (section === 'Collaboration') { + await api.patch( + `/organizations/${organizationId}/hackathons/${hackathonId}/content`, + { collaboration: data } + ); + } else if (section === 'Participants') { + await api.patch( + `/organizations/${organizationId}/hackathons/${hackathonId}/schedule`, + { participation: data } + ); + } else if (section === 'Rewards') { + await api.patch( + `/organizations/${organizationId}/hackathons/${hackathonId}/financial`, + { rewards: data } + ); + } else { + await api.patch( + `/organizations/${organizationId}/hackathons/${hackathonId}/settings/${section.toLowerCase()}`, + data + ); + } toast.success(`${section} settings saved successfully!`); - } catch { - toast.error(`Failed to save ${section} settings`); + await fetchHackathon(); // Call fetchHackathon after successful save + } catch (error: any) { + const message = + error.response?.data?.message || `Failed to save ${section} settings`; + const errorMessage = Array.isArray(message) ? message[0] : message; + toast.error(errorMessage); + throw error; // Re-throw to let callers know it failed } finally { setIsSaving(false); } }; + if (isLoading) return
@@ -208,9 +261,17 @@ export default function SettingsPage() {
handleSave('General', data)}
+ initialData={getGeneralData(hackathon) as any}
+ onSave={async data => {
+ await handleSave('General', data);
+ }}
isLoading={isSaving}
+ isPublished={[
+ 'UPCOMING',
+ 'ACTIVE',
+ 'JUDGING',
+ 'COMPLETED',
+ ].includes(hackathon?.status ?? '')}
/>
@@ -218,9 +279,8 @@ export default function SettingsPage() {
handleSave('Timeline', data)}
- isLoading={isSaving}
+ initialData={getTimelineData(hackathon)}
+ onSaveSuccess={fetchHackathon}
/>
@@ -228,8 +288,15 @@ export default function SettingsPage() {
handleSave('Participants', data)}
+ initialData={
+ hackathon ? getParticipantData(hackathon) : undefined
+ }
+ isRegistrationClosed={
+ hackathon ? !hackathon.registrationOpen : false
+ }
+ onSave={async data => {
+ await handleSave('Participants', data);
+ }}
isLoading={isSaving}
/>
@@ -238,8 +305,10 @@ export default function SettingsPage() {
handleSave('Rewards', data)}
+ initialData={{ prizeTiers: hackathon?.prizeTiers || [] } as any}
+ onSave={async data => {
+ await handleSave('Rewards', data);
+ }}
isLoading={isSaving}
/>
@@ -248,8 +317,18 @@ export default function SettingsPage() {
handleSave('Collaboration', data)}
+ initialData={
+ {
+ contactEmail: hackathon?.contactEmail || '',
+ telegram: hackathon?.telegram || '',
+ discord: hackathon?.discord || '',
+ socialLinks: hackathon?.socialLinks || [],
+ sponsorsPartners: hackathon?.sponsorsPartners || [],
+ } as any
+ }
+ onSave={async data => {
+ await handleSave('Collaboration', data);
+ }}
isLoading={isSaving}
/>
@@ -258,8 +337,8 @@ export default function SettingsPage() {
handleSave('Advanced', data)}
- isLoading={isSaving}
+ initialData={getAdvancedData(hackathon)}
+ onSaveSuccess={fetchHackathon}
/>
diff --git a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/submissions/page.tsx b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/submissions/page.tsx
index 7e02bb40d..46f22f9d5 100644
--- a/app/(landing)/organizations/[id]/hackathons/[hackathonId]/submissions/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/[hackathonId]/submissions/page.tsx
@@ -1,13 +1,15 @@
'use client';
import { useParams } from 'next/navigation';
-import { useEffect } from 'react';
+import { useEffect, useState } from 'react';
import { Loader2, AlertCircle } from 'lucide-react';
-import { useHackathonSubmissions } from '@/hooks/hackathon/use-hackathon-submissions';
+import { useOrganizerSubmissions } from '@/hooks/hackathon/use-organizer-submissions';
import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert';
import { AuthGuard } from '@/components/auth';
import Loading from '@/components/Loading';
import { SubmissionsManagement } from '@/components/organization/hackathons/submissions/SubmissionsManagement';
+import { authClient } from '@/lib/auth-client';
+import { getHackathon, type Hackathon } from '@/lib/api/hackathons';
export default function SubmissionsPage() {
const params = useParams();
@@ -24,14 +26,42 @@ export default function SubmissionsPage() {
updateFilters,
goToPage,
refresh,
- } = useHackathonSubmissions(hackathonId);
+ } = useOrganizerSubmissions(hackathonId);
+
+ const [currentUserId, setCurrentUserId] = useState(null);
+ const [hackathon, setHackathon] = useState(null);
useEffect(() => {
if (hackathonId) {
fetchSubmissions();
+ const fetchHackathonDetails = async () => {
+ try {
+ const res = await getHackathon(hackathonId);
+ if (res.success && res.data) {
+ setHackathon(res.data);
+ }
+ } catch (err) {
+ console.error('Failed to fetch hackathon details:', err);
+ }
+ };
+ fetchHackathonDetails();
}
}, [hackathonId, fetchSubmissions]);
+ useEffect(() => {
+ const fetchSession = async () => {
+ try {
+ const { data: session } = await authClient.getSession();
+ if (session?.user?.id) {
+ setCurrentUserId(session.user.id);
+ }
+ } catch (err) {
+ console.error('Failed to fetch session:', err);
+ }
+ };
+ fetchSession();
+ }, []);
+
if (error) {
return (
('all');
const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
const [hackathonToDelete, setHackathonToDelete] = useState<{
id: string;
title: string;
+ type: 'draft' | 'hackathon';
} | null>(null);
const { hackathons, hackathonsLoading, drafts, draftsLoading, refetchAll } =
@@ -99,13 +149,12 @@ export default function HackathonsPage() {
// Use the separate delete hook
const { isDeleting, deleteHackathon } = useDeleteHackathon({
organizationId,
- hackathonId: hackathonToDelete?.id || '', // This will be set when we have a hackathon to delete
+ hackathonId: hackathonToDelete?.id || '',
+ type: hackathonToDelete?.type ?? 'hackathon',
+ suppressToast: true,
onSuccess: () => {
// Refresh the hackathons list after successful deletion
refetchAll();
- toast.success('Hackathon deleted successfully', {
- description: `"${hackathonToDelete?.title}" has been permanently deleted.`,
- });
},
onError: error => {
toast.error('Failed to delete hackathon', {
@@ -114,93 +163,101 @@ export default function HackathonsPage() {
},
});
- const allHackathons = useMemo(() => {
- const items: Array<{
- type: 'draft' | 'hackathon';
- data: HackathonDraft | Hackathon;
- }> = [];
-
- drafts.forEach(draft => {
- if (statusFilter === 'all' || statusFilter === 'draft') {
- items.push({ type: 'draft', data: draft });
- }
- });
-
- hackathons.forEach(hackathon => {
- if (hackathon.status === 'DRAFT') return;
- if (
- statusFilter === 'all' ||
- (statusFilter === 'open' && hackathon.status === 'PUBLISHED')
- ) {
- items.push({ type: 'hackathon', data: hackathon });
- }
+ const publishedHackathons = useMemo(() => {
+ let items = hackathons.filter(h => h.status !== 'DRAFT');
+ if (searchQuery) {
+ const query = searchQuery.toLowerCase();
+ items = items.filter(h => h.name?.toLowerCase().includes(query));
+ }
+ if (categoryFilter !== 'all') {
+ items = items.filter(h =>
+ h.categories
+ ?.map(c => c.toLowerCase())
+ .includes(categoryFilter.toLowerCase())
+ );
+ }
+ items = items.sort((a, b) => {
+ const dateA = new Date(a.createdAt || 0).getTime();
+ const dateB = new Date(b.createdAt || 0).getTime();
+ return sortBy === 'newest' ? dateB - dateA : dateA - dateB;
});
+ return items;
+ }, [hackathons, searchQuery, categoryFilter, sortBy]);
- let filtered = items;
+ const draftHackathons = useMemo(() => {
+ let items = drafts;
if (searchQuery) {
const query = searchQuery.toLowerCase();
- filtered = items.filter(item => {
- const title =
- item.type === 'draft'
- ? (
- item.data as HackathonDraft
- ).data.information?.name?.toLowerCase() || ''
- : (item.data as Hackathon).name?.toLowerCase() || '';
- return title.includes(query);
- });
+ items = items.filter(d =>
+ d.data.information?.name?.toLowerCase().includes(query)
+ );
}
-
if (categoryFilter !== 'all') {
- filtered = filtered.filter(item => {
- const category =
- item.type === 'draft'
- ? (item.data as HackathonDraft).data.information?.categories
- ?.join(',')
- ?.toLowerCase() || ''
- : '';
- return category.includes(categoryFilter.toLowerCase());
- });
+ items = items.filter(d =>
+ d.data.information?.categories
+ ?.map(c => c.toLowerCase())
+ .includes(categoryFilter.toLowerCase())
+ );
}
-
- filtered.sort((a, b) => {
- const dateA = new Date(a.data.createdAt || 0).getTime();
- const dateB = new Date(b.data.createdAt || 0).getTime();
+ items = items.sort((a, b) => {
+ const dateA = new Date(a.createdAt || 0).getTime();
+ const dateB = new Date(b.createdAt || 0).getTime();
return sortBy === 'newest' ? dateB - dateA : dateA - dateB;
});
-
- return filtered;
- }, [drafts, hackathons, searchQuery, statusFilter, categoryFilter, sortBy]);
+ return items;
+ }, [drafts, searchQuery, categoryFilter, sortBy]);
const isLoading = hackathonsLoading || draftsLoading;
const stats = useMemo(() => {
- const published = hackathons.filter(h => h.status === 'PUBLISHED').length;
+ const published = hackathons.filter(h =>
+ ['UPCOMING', 'ACTIVE', 'JUDGING', 'COMPLETED'].includes(h.status)
+ ).length;
const total = hackathons.length + drafts.length;
return { published, drafts: drafts.length, total };
}, [hackathons, drafts]);
- const handleDeleteClick = (hackathonId: string) => {
- const hackathon = allHackathons.find(item => item.data.id === hackathonId);
- if (hackathon) {
- const title =
- hackathon.type === 'draft'
- ? (hackathon.data as HackathonDraft).data.information?.name ||
- 'Untitled Hackathon'
- : (hackathon.data as Hackathon).name || 'Untitled Hackathon';
- setHackathonToDelete({ id: hackathonId, title });
- setDeleteDialogOpen(true);
+ const handleDeleteClick = (
+ hackathonId: string,
+ type: 'draft' | 'hackathon'
+ ) => {
+ if (type === 'hackathon') {
+ const published = publishedHackathons.find(h => h.id === hackathonId);
+ if (published) {
+ setHackathonToDelete({
+ id: hackathonId,
+ title: published.name || 'Untitled Hackathon',
+ type: 'hackathon',
+ });
+ setDeleteDialogOpen(true);
+ }
+ } else {
+ const draft = draftHackathons.find(d => d.id === hackathonId);
+ if (draft) {
+ setHackathonToDelete({
+ id: hackathonId,
+ title: draft.data.information?.name || 'Untitled Hackathon',
+ type: 'draft',
+ });
+ setDeleteDialogOpen(true);
+ }
}
};
const handleDeleteConfirm = async () => {
if (!hackathonToDelete) return;
+ const { title } = hackathonToDelete; // โ
snapshot before state clears
+
setDeleteDialogOpen(false);
try {
await deleteHackathon();
+ toast.success('Hackathon deleted successfully', {
+ description: `"${title}" has been permanently deleted.`,
+ });
} catch {
- // Error handled by toast in deleteHackathon hook
+ // error toast handled by onError in hook
} finally {
setHackathonToDelete(null);
}
@@ -210,11 +267,11 @@ export default function HackathonsPage() {
{
- const [blogPosts, hackathons, crowdfundingProjects] = await Promise.all([
- fetchBlogPostsSitemap(),
+ const blogPosts = fetchBlogPostsSitemap();
+ const [hackathons, crowdfundingProjects] = await Promise.all([
fetchHackathonsSitemap(),
fetchCrowdfundingProjectsSitemap(),
]);
@@ -118,39 +117,18 @@ export default async function sitemap(): Promise {
}
/**
- * Fetches published blog posts and formats them for sitemap
- * Returns empty array if fetch fails
+ * Reads blog posts from MDX files and formats them for sitemap
*/
-async function fetchBlogPostsSitemap(): Promise {
+function fetchBlogPostsSitemap(): MetadataRoute.Sitemap {
try {
- const response = await getBlogPosts({
- status: 'PUBLISHED',
- limit: MAX_ITEMS,
- });
-
- // Validate response
- if (!response?.data || !Array.isArray(response.data)) {
- return [];
- }
-
- return response.data
- .filter((post: BlogPost) => {
- // Validate required fields
- if (!post.slug) {
- return false;
- }
- return true;
- })
- .map((post: BlogPost) => ({
- url: `${SITE_URL}/blog/${post.slug}`,
- lastModified: new Date(
- post.updatedAt || post.publishedAt || new Date()
- ),
- changeFrequency: 'monthly' as const,
- priority: 0.7,
- }));
+ const posts = getAllBlogPosts();
+ return posts.map(post => ({
+ url: `${SITE_URL}/blog/${post.slug}`,
+ lastModified: new Date(post.publishedAt || new Date()),
+ changeFrequency: 'monthly' as const,
+ priority: 0.7,
+ }));
} catch {
- // Silently fail if fetch fails, return empty array
return [];
}
}
@@ -173,14 +151,14 @@ async function fetchHackathonsSitemap(): Promise {
}
return response.data.hackathons
- .filter((hackathon: Hackathon) => {
+ .filter((hackathon: HackathonAPI) => {
// Validate required fields
if (!hackathon.slug) {
return false;
}
return true;
})
- .map((hackathon: Hackathon) => ({
+ .map((hackathon: HackathonAPI) => ({
url: `${SITE_URL}/hackathons/${hackathon.slug}`,
lastModified: new Date(
hackathon.updatedAt || hackathon.publishedAt || new Date()
diff --git a/components/ComingSoon.tsx b/components/ComingSoon.tsx
new file mode 100644
index 000000000..1afcc2f14
--- /dev/null
+++ b/components/ComingSoon.tsx
@@ -0,0 +1,115 @@
+'use client';
+
+import {
+ ArrowDownUp,
+ CircleDollarSign,
+ ChartNoAxesColumnIncreasing,
+ ShieldCheck,
+ LucideIcon,
+} from 'lucide-react';
+import { motion } from 'framer-motion';
+
+type Feature = {
+ id: string;
+ title: string;
+ description: string;
+ icon: LucideIcon;
+};
+
+const features: Feature[] = [
+ {
+ id: 'grant-flow',
+ title: 'Full Grant Flow & Architecture',
+ description:
+ 'End-to-end grant lifecycle system covering submission, evaluation, approval, and fund distribution.',
+ icon: ArrowDownUp,
+ },
+ {
+ id: 'bounty-implementation',
+ title: 'Bounty Implementation',
+ description:
+ 'Structured bounty creation with decentralized submission handling and transparent verification.',
+ icon: CircleDollarSign,
+ },
+ {
+ id: 'analytics-dashboard',
+ title: 'Advanced Analytics Dashboard',
+ description:
+ 'Clear financial and participation metrics with intuitive visual breakdowns.',
+ icon: ChartNoAxesColumnIncreasing,
+ },
+ {
+ id: 'verified-badging',
+ title: 'Verified Project Badging',
+ description:
+ 'Recognition layer for trusted and high-quality ecosystem projects.',
+ icon: ShieldCheck,
+ },
+];
+
+const FeatureBlock = ({
+ title,
+ description,
+ icon: Icon,
+ index,
+}: Feature & { index: number }) => {
+ return (
+
+
+ );
+};
+
+const ComingSoon = () => {
+ return (
+
+
+ );
+};
+
+export default ComingSoon;
diff --git a/components/EmptyState.tsx b/components/EmptyState.tsx
index 2796bca45..5869929ef 100644
--- a/components/EmptyState.tsx
+++ b/components/EmptyState.tsx
@@ -66,11 +66,11 @@ const EmptyState: React.FC = ({
switch (type) {
case 'compact':
- return `${baseStyle} px-4 py-2 text-sm bg-[#00D2A4] text-black hover:bg-[#00B894] focus:ring-[#00D2A4] shadow-sm`;
+ return `${baseStyle} px-4 py-2 text-sm bg-primary text-primary-foreground hover:bg-primary/90 focus:ring-primary shadow-sm`;
case 'custom':
return `${baseStyle} px-6 py-3 bg-blue-600 text-white hover:bg-blue-700 focus:ring-blue-500 shadow-md`;
default:
- return `${baseStyle} px-6 py-3 bg-[#00D2A4] text-black hover:bg-[#00B894] focus:ring-[#00D2A4] shadow-[0_2px_8px_rgba(0,210,164,0.2)]`;
+ return `${baseStyle} px-6 py-3 bg-primary text-primary-foreground hover:bg-primary/90 focus:ring-primary shadow-[var(--primary-shadow)]`;
}
};
diff --git a/components/analytics/AnalyticsBentoGrid.tsx b/components/analytics/AnalyticsBentoGrid.tsx
new file mode 100644
index 000000000..066262990
--- /dev/null
+++ b/components/analytics/AnalyticsBentoGrid.tsx
@@ -0,0 +1,230 @@
+'use client';
+
+import { useMemo } from 'react';
+import { motion, Variants } from 'framer-motion';
+import {
+ TrendingUp,
+ TrendingDown,
+ Minus,
+ Users,
+ FolderGit2,
+ Trophy,
+ Star,
+ DollarSign,
+ MessageSquare,
+ ThumbsUp,
+ GitBranch,
+} from 'lucide-react';
+import { Card, CardContent, CardHeader } from '@/components/ui/card';
+import { GetMeResponse } from '@/lib/api/types';
+import { calculateChartTrend, TrendResult } from '@/lib/utils/calculateTrend';
+
+interface Props {
+ stats: GetMeResponse['stats'];
+ chart: GetMeResponse['chart'];
+}
+
+function TrendBadge({ trend }: { trend: TrendResult }) {
+ if (trend.direction === 'up') {
+ return (
+
+
+ {trend.percentage}%
+
+ );
+ }
+ if (trend.direction === 'down') {
+ return (
+
+
+ {trend.percentage}%
+
+ );
+ }
+ return (
+
+
+ 0%
+
+ );
+}
+
+interface TileConfig {
+ label: string;
+ value: number;
+ icon: React.ReactNode;
+ trend: TrendResult;
+ colSpan: string;
+ rowSpan: string;
+ large?: boolean;
+}
+
+const containerVariants: Variants = {
+ hidden: {},
+ show: { transition: { staggerChildren: 0.07 } },
+};
+
+const tileVariants: Variants = {
+ hidden: { opacity: 0, y: 16 },
+ show: {
+ opacity: 1,
+ y: 0,
+ transition: { duration: 0.35, ease: [0.4, 0, 0.2, 1] as const },
+ },
+};
+
+export function AnalyticsBentoGrid({ stats, chart }: Props) {
+ const chartTrend = useMemo(() => calculateChartTrend(chart), [chart]);
+ const flat: TrendResult = { percentage: 0, direction: 'flat' };
+
+ const tiles: TileConfig[] = useMemo(
+ () => [
+ {
+ label: 'Global Reputation',
+ value: stats.reputation,
+ icon:
+
+
+
+
+
+ );
+}
diff --git a/components/analytics/AnalyticsChart.tsx b/components/analytics/AnalyticsChart.tsx
new file mode 100644
index 000000000..6748a85ab
--- /dev/null
+++ b/components/analytics/AnalyticsChart.tsx
@@ -0,0 +1,184 @@
+'use client';
+
+import { useMemo, useState } from 'react';
+import {
+ ResponsiveContainer,
+ LineChart,
+ Line,
+ XAxis,
+ YAxis,
+ CartesianGrid,
+ Tooltip,
+ TooltipProps,
+} from 'recharts';
+import { motion } from 'framer-motion';
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from '@/components/ui/card';
+import { GetMeResponse } from '@/lib/api/types';
+import {
+ transformChartData,
+ filterChartByRange,
+} from '@/lib/utils/calculateTrend';
+
+type Range = '7D' | '30D' | '90D' | 'ALL';
+const RANGE_DAYS: Record = {
+ '7D': 7,
+ '30D': 30,
+ '90D': 90,
+ ALL: 'ALL',
+};
+
+interface Props {
+ chart: GetMeResponse['chart'];
+}
+
+function CustomTooltip({
+ active,
+ payload,
+ label,
+}: TooltipProps) {
+ if (!active || !payload?.length) return null;
+ return (
+ ('30D');
+ const ranges: Range[] = ['7D', '30D', '90D', 'ALL'];
+
+ const allTransformed = useMemo(() => transformChartData(chart), [chart]);
+
+ const filtered = useMemo(
+ () => filterChartByRange(allTransformed, RANGE_DAYS[range]),
+ [allTransformed, range]
+ );
+
+ return (
+
+
+
+
+
+
+ {filtered.length === 0 ? (
+
+
+
+
+
+
+ )}
+
+
+
+ );
+}
diff --git a/components/app-sidebar.tsx b/components/app-sidebar.tsx
index ad72176a8..eea9e5cc6 100644
--- a/components/app-sidebar.tsx
+++ b/components/app-sidebar.tsx
@@ -4,6 +4,7 @@ import * as React from 'react';
import {
IconBell,
IconChartBar,
+ IconCurrencyDollar,
IconDashboard,
IconFileText,
IconFolder,
@@ -26,8 +27,13 @@ import {
} from '@/components/ui/sidebar';
import Image from 'next/image';
import Link from 'next/link';
+import { useNotificationStore } from '@/lib/stores/notification-store';
-const navigationData = {
+const getNavigationData = (counts?: {
+ participating?: number;
+ unreadNotifications?: number;
+ submissions?: number;
+}) => ({
main: [
{
title: 'Overview',
@@ -39,6 +45,11 @@ const navigationData = {
url: '/me/analytics',
icon: IconChartBar,
},
+ {
+ title: 'Earnings',
+ url: '/me/earnings',
+ icon: IconCurrencyDollar,
+ },
],
projects: [
{
@@ -56,14 +67,21 @@ const navigationData = {
hackathons: [
{
title: 'Participating',
- url: '/me/hackathons',
+ url: '/me/participating',
icon: IconShieldCheck,
- badge: '2',
+ badge:
+ (counts?.participating ?? 0) > 0
+ ? String(counts?.participating)
+ : undefined,
},
{
title: 'Submissions',
url: '/me/hackathons/submissions',
icon: IconUsers,
+ badge:
+ (counts?.submissions ?? 0) > 0
+ ? String(counts?.submissions)
+ : undefined,
},
],
crowdfunding: [
@@ -88,19 +106,35 @@ const navigationData = {
title: 'Notifications',
url: '/me/notifications',
icon: IconBell,
- badge: '5',
+ badge:
+ counts?.unreadNotifications && counts.unreadNotifications > 0
+ ? counts.unreadNotifications.toString()
+ : undefined,
},
],
-};
-interface userData {
+});
+
+interface UserData {
name: string;
email: string;
- image: string;
+ image: string | null;
}
+
export function AppSidebar({
user,
+ counts,
...props
-}: { user: userData } & React.ComponentProps) {
+}: {
+ user: UserData;
+ counts?: { participating?: number; submissions?: number };
+} & React.ComponentProps) {
+ const unreadNotifications = useNotificationStore(state => state.unreadCount);
+
+ const navigationData = React.useMemo(
+ () => getNavigationData({ ...counts, unreadNotifications }),
+ [counts, unreadNotifications]
+ );
+
return (
@@ -84,6 +114,8 @@ export default function SubmissionsPage() {
onRefresh={refresh}
organizationId={organizationId}
hackathonId={hackathonId}
+ currentUserId={currentUserId || undefined}
+ hackathon={hackathon || undefined}
/>
)}
diff --git a/app/(landing)/organizations/[id]/hackathons/page.tsx b/app/(landing)/organizations/[id]/hackathons/page.tsx
index 1f0fb3e0f..10529736e 100644
--- a/app/(landing)/organizations/[id]/hackathons/page.tsx
+++ b/app/(landing)/organizations/[id]/hackathons/page.tsx
@@ -41,8 +41,7 @@ const calculateDraftCompletion = (draft: HackathonDraft): number => {
draft.data.information?.categories,
draft.data.timeline?.startDate,
draft.data.timeline?.submissionDeadline,
- draft.data.timeline?.judgingDate,
- draft.data.timeline?.winnerAnnouncementDate,
+ draft.data.timeline?.judgingDeadline,
draft.data.timeline?.timezone,
draft.data.participation?.participantType,
draft.data.rewards?.prizeTiers?.length,
@@ -73,6 +72,58 @@ const getTimeRemaining = (endDate: string): string => {
return `${Math.floor(days / 365)}y`;
};
+type HackathonStatus =
+ | 'DRAFT'
+ | 'UPCOMING'
+ | 'ACTIVE'
+ | 'JUDGING'
+ | 'COMPLETED'
+ | 'ARCHIVED'
+ | 'CANCELLED';
+
+const getStatusDisplay = (
+ status: HackathonStatus | undefined
+): { label: string; className: string } => {
+ switch (status) {
+ case 'UPCOMING':
+ return {
+ label: 'Upcoming',
+ className: 'bg-blue-500/10 text-blue-400 border-blue-500/20',
+ };
+ case 'ACTIVE':
+ return {
+ label: 'Live',
+ className: 'bg-green-500/10 text-green-400 border-green-500/20',
+ };
+ case 'JUDGING':
+ return {
+ label: 'Judging',
+ className: 'bg-amber-500/10 text-amber-400 border-amber-500/20',
+ };
+ case 'COMPLETED':
+ return {
+ label: 'Ended',
+ className: 'bg-zinc-500/10 text-zinc-400 border-zinc-500/20',
+ };
+ case 'ARCHIVED':
+ return {
+ label: 'Archived',
+ className: 'bg-zinc-600/10 text-zinc-500 border-zinc-600/20',
+ };
+ case 'CANCELLED':
+ return {
+ label: 'Cancelled',
+ className: 'bg-red-500/10 text-red-400 border-red-500/20',
+ };
+ case 'DRAFT':
+ default:
+ return {
+ label: status === 'DRAFT' ? 'Draft' : (status ?? 'Draft'),
+ className: 'bg-zinc-500/10 text-zinc-400 border-zinc-500/20',
+ };
+ }
+};
+
export default function HackathonsPage() {
const params = useParams();
const organizationId = params.id as string;
@@ -80,14 +131,13 @@ export default function HackathonsPage() {
const [searchQuery, setSearchQuery] = useState('');
const [sortBy, setSortBy] = useState<'newest' | 'oldest'>('newest');
- const [statusFilter, setStatusFilter] = useState<'all' | 'open' | 'draft'>(
- 'all'
- );
+ const [tab, setTab] = useState<'published' | 'drafts'>('published');
const [categoryFilter, setCategoryFilter] = useState
{/* Header */}
-
= ({
+ title,
+ value,
+ icon,
+ description,
+}) => (
+
+
+ {title}
+ {icon}
+
+
+
+
+);
+
+/**
+ * Interface for BreakdownItem props.
+ */
+interface BreakdownItemProps {
+ label: string;
+ value: number;
+ icon: React.ReactNode;
+}
+
+/**
+ * BreakdownItem component for showing source-specific earnings.
+ */
+const BreakdownItem: React.FC = ({
+ label,
+ value,
+ icon,
+}) => (
+ = ({ activity }) => (
+ (null);
+
+ useEffect(() => {
+ const fetchData = async () => {
+ try {
+ const res = await getUserEarnings();
+ if (res.success) {
+ setData(res.data);
+ } else {
+ toast.error(res.error || 'Failed to load earnings data');
+ }
+ } catch (error) {
+ console.error('Failed to fetch earnings:', error);
+ toast.error('Failed to load earnings data');
+ } finally {
+ setLoading(false);
+ }
+ };
+ fetchData();
+ }, []);
+
+ if (loading) {
+ return ('submittedAt');
+ const [sortDir, setSortDir] = useState('desc');
+ const [selectedSubmission, setSelectedSubmission] =
+ useState(null);
+ const [sheetOpen, setSheetOpen] = useState(false);
+
+ // Pull submissions data from auth state โ no extra API calls
+ const rawSubmissions: SubmissionRow[] = useMemo(() => {
+ const profile = (user?.profile ?? undefined) as UserProfile | undefined;
+ if (!profile) return [];
+
+ const fromUser: RawSubmission[] =
+ profile.user?.hackathonSubmissionsAsParticipant ?? [];
+ const fromProfile: RawSubmission[] =
+ profile.hackathonSubmissionsAsParticipant ?? [];
+
+ const merged: RawSubmission[] = [...fromUser, ...fromProfile];
+ const seen = new Set();
+ const deduped = merged.filter((s: RawSubmission) => {
+ const id = s.id ?? s._id;
+ if (!id || seen.has(id)) return false;
+ seen.add(id);
+ return true;
+ });
+
+ return deduped.map(
+ (s: RawSubmission): SubmissionRow => ({
+ id: s.id ?? s._id ?? '',
+ projectName:
+ s.projectName ?? s.title ?? s.name ?? 'Untitled Submission',
+ description: s.description,
+ introduction: s.introduction,
+ logo: s.logo,
+ videoUrl: s.videoUrl,
+ category: s.category,
+ links: s.links,
+ status: s.status ?? 'draft',
+ rank: s.rank ?? null,
+ submittedAt: s.submittedAt ?? s.submissionDate ?? s.createdAt ?? '',
+ votes: s.votes,
+ comments: s.comments,
+ hackathon: s.hackathon,
+ disqualificationReason: s.disqualificationReason,
+ })
+ );
+ }, [user]);
+
+ const sorted = useMemo(() => {
+ return [...rawSubmissions].sort((a, b) => {
+ let aVal: any;
+ let bVal: any;
+
+ switch (sortField) {
+ case 'projectName':
+ aVal = (a.projectName || '').toLowerCase();
+ bVal = (b.projectName || '').toLowerCase();
+ break;
+ case 'hackathon':
+ aVal = (a.hackathon?.title || a.hackathon?.name || '').toLowerCase();
+ bVal = (b.hackathon?.title || b.hackathon?.name || '').toLowerCase();
+ break;
+ case 'status':
+ aVal = (a.status || '').toLowerCase();
+ bVal = (b.status || '').toLowerCase();
+ break;
+ case 'submittedAt':
+ aVal = a.submittedAt ? new Date(a.submittedAt).getTime() : 0;
+ bVal = b.submittedAt ? new Date(b.submittedAt).getTime() : 0;
+ break;
+ case 'rank':
+ aVal = a.rank ?? Infinity;
+ bVal = b.rank ?? Infinity;
+ break;
+ default:
+ return 0;
+ }
+
+ if (aVal < bVal) return sortDir === 'asc' ? -1 : 1;
+ if (aVal > bVal) return sortDir === 'asc' ? 1 : -1;
+ return 0;
+ });
+ }, [rawSubmissions, sortField, sortDir]);
+
+ const summaryStats = useMemo(() => {
+ const ranked = rawSubmissions.filter(s => {
+ const st = (s.status || '').toLowerCase();
+ return st === 'ranked' || st === 'shortlisted' || st === 'winner';
+ }).length;
+ const underReview = rawSubmissions.filter(s => {
+ const st = (s.status || '').toLowerCase().replace(/[\s\-_]+/g, '_');
+ return st === 'under_review' || st === 'submitted';
+ }).length;
+ const draft = rawSubmissions.filter(
+ s => (s.status || '').toLowerCase() === 'draft'
+ ).length;
+ return [
+ {
+ label: 'Total',
+ value: rawSubmissions.length,
+ color: 'text-white',
+ },
+ { label: 'Ranked', value: ranked, color: 'text-primary' },
+ { label: 'Under Review', value: underReview, color: 'text-amber-400' },
+ { label: 'Draft', value: draft, color: 'text-zinc-400' },
+ ] as const;
+ }, [rawSubmissions]);
+
+ const handleSort = (field: SortField) => {
+ if (sortField === field) {
+ setSortDir(d => (d === 'asc' ? 'desc' : 'asc'));
+ } else {
+ setSortField(field);
+ setSortDir('asc');
+ }
+ };
+
+ const handleRowClick = (submission: SubmissionRow) => {
+ setSelectedSubmission(submission);
+ setSheetOpen(true);
+ };
+
+ const getAriaSort = (field: SortField) => {
+ if (sortField !== field) return 'none';
+ return sortDir === 'asc' ? 'ascending' : 'descending';
+ };
+
+ const thClass =
+ 'h-12 px-2 text-left align-middle font-medium text-zinc-400 [&:has([role=checkbox])]:pr-0';
+
+ if (isLoading) {
+ return (
+ setIsHoverOrFocus(true)}
+ onMouseLeave={() => setIsHoverOrFocus(false)}
+ role='button'
+ tabIndex={0}
+ onKeyDown={handleKeyDown}
+ aria-label={`View details for ${submission.projectName}`}
+ >
+ {/* Project */}
+
+
+
+ {/* Hackathon */}
+
+
+ {hackathonName}
+
+
+
+ {/* Status */}
+
+
+
+ {/* Date */}
+
+
+ {formatDate(submission.submittedAt)}
+
+
+
+ {/* Rank */}
+
+ {submission.rank != null ? (
+
+
+
+ {/* Chevron */}
+
+
+
+ );
+}
diff --git a/app/me/layout.tsx b/app/me/layout.tsx
index 865b62341..a2ad6e87f 100644
--- a/app/me/layout.tsx
+++ b/app/me/layout.tsx
@@ -4,12 +4,64 @@ import { AppSidebar } from '@/components/app-sidebar';
import { SiteHeader } from '@/components/site-header';
import { SidebarInset, SidebarProvider } from '@/components/ui/sidebar';
import { useAuthStatus } from '@/hooks/use-auth';
-import React from 'react';
+import React, { useMemo } from 'react';
import LoadingSpinner from '@/components/LoadingSpinner';
-export default function MeLayout({ children }: { children: React.ReactNode }) {
+interface MeLayoutProps {
+ children: React.ReactNode;
+}
+
+/** Item with optional id or _id for join/submission arrays from profile API. */
+interface ProfileItemWithId {
+ id?: string;
+ _id?: string;
+}
+
+/** Profile shape used by layout: user + optional root-level submission list. */
+interface MeLayoutProfile {
+ user?: {
+ image?: string;
+ joinedHackathons?: ProfileItemWithId[];
+ hackathonSubmissionsAsParticipant?: ProfileItemWithId[];
+ };
+ image?: string;
+ hackathonSubmissionsAsParticipant?: ProfileItemWithId[];
+}
+
+const getId = (item: ProfileItemWithId): string | undefined =>
+ item.id ?? item._id;
+
+const MeLayout = ({ children }: MeLayoutProps): React.ReactElement => {
const { user, isLoading } = useAuthStatus();
+ const { name = '', email = '', profile, image: userImage = '' } = user || {};
+ const typedProfile = profile as MeLayoutProfile | null | undefined;
+
+ const userData = {
+ name: name || '',
+ email,
+ image: typedProfile?.user?.image ?? typedProfile?.image ?? userImage ?? '',
+ };
+
+ const hackathonsCount = useMemo(() => {
+ if (!typedProfile?.user?.joinedHackathons) return 0;
+ return typedProfile.user.joinedHackathons.length;
+ }, [typedProfile]);
+
+ const submissionsCount = useMemo(() => {
+ if (!typedProfile) return 0;
+ const fromUser = typedProfile.user?.hackathonSubmissionsAsParticipant ?? [];
+ const fromProfile = typedProfile.hackathonSubmissionsAsParticipant ?? [];
+ const merged: ProfileItemWithId[] = [...fromUser, ...fromProfile];
+ const seen = new Set();
+ return merged.filter(s => {
+ const id = getId(s);
+ if (!id || seen.has(id)) return false;
+ seen.add(id);
+ return true;
+ }).length;
+ }, [typedProfile]);
+
if (isLoading) {
return (
+
{
>
2FA
+
+ Identity
+
+
+
diff --git a/app/sitemap.ts b/app/sitemap.ts
index 7189496d5..9c65ded44 100644
--- a/app/sitemap.ts
+++ b/app/sitemap.ts
@@ -1,9 +1,8 @@
import { MetadataRoute } from 'next';
-import { getBlogPosts } from '@/lib/api/blog';
+import { getAllBlogPosts } from '@/lib/mdx';
import { getHackathons } from '@/lib/api/hackathons';
import { getCrowdfundingProjects } from '@/features/projects/api';
-import type { BlogPost } from '@/types/blog';
-import type { Hackathon } from '@/types/hackathon/core';
+import type { Hackathon as HackathonAPI } from '@/lib/api/hackathons';
import type { Crowdfunding } from '@/features/projects/types';
// Constants
@@ -15,8 +14,8 @@ const MAX_ITEMS = 100;
* Includes static pages and dynamically fetched content
*/
export default async function sitemap(): Promise
+
+
+ {/* Tabs */}
+
);
}
- console.log(milestone.orderIndex);
return (
-
+
-
+
Hackathons
@@ -226,23 +283,39 @@ export default function HackathonsPage() {
+
+
+
+
{/* Filters */}
-
-
+
+
+
+ );
+};
+
+export default page;
diff --git a/app/globals.css b/app/globals.css
index 7bddde3b2..f26eec3e0 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -1,8 +1,31 @@
@import url('https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap');
@import 'tailwindcss';
@import 'tw-animate-css';
+@plugin "@tailwindcss/typography";
@custom-variant dark (&:is(.dark *));
+/* Prose (Tailwind Typography) dark theme overrides for blog content */
+@layer base {
+ .prose {
+ --tw-prose-body: #d1d5db;
+ --tw-prose-headings: #ffffff;
+ --tw-prose-lead: #d1d5db;
+ --tw-prose-links: #a7f950;
+ --tw-prose-bold: #ffffff;
+ --tw-prose-counters: #b5b5b5;
+ --tw-prose-bullets: #b5b5b5;
+ --tw-prose-hr: #374151;
+ --tw-prose-quotes: #d1d5db;
+ --tw-prose-quote-borders: #a7f950;
+ --tw-prose-captions: #9ca3af;
+ --tw-prose-code: #a7f950;
+ --tw-prose-pre-code: #e5e7eb;
+ --tw-prose-pre-bg: var(--color-background-card);
+ --tw-prose-th-borders: #374151;
+ --tw-prose-td-borders: #1f2937;
+ }
+}
+
@theme {
--font-inter: 'Inter', sans-serif;
--color-gray-50: #f7f7f7;
@@ -214,6 +237,7 @@ body {
--popover-foreground: oklch(0.145 0 0);
--primary: #a7f950;
--primary-foreground: oklch(0.205 0 0);
+ --primary-shadow: 0 2px 8px rgba(167, 249, 80, 0.2);
--secondary: oklch(0.269 0 0);
--secondary-foreground: oklch(0.985 0 0);
--muted: oklch(0.269 0 0);
@@ -267,6 +291,7 @@ body {
--popover-foreground: oklch(0.985 0 0);
--primary: oklch(0.922 0 0);
--primary-foreground: oklch(0.205 0 0);
+ --primary-shadow: 0 2px 8px rgba(0, 0, 0, 0.25);
--secondary: oklch(0.269 0 0);
--secondary-foreground: oklch(0.985 0 0);
--muted: oklch(0.269 0 0);
diff --git a/app/me/analytics/page.tsx b/app/me/analytics/page.tsx
new file mode 100644
index 000000000..e6a082c9d
--- /dev/null
+++ b/app/me/analytics/page.tsx
@@ -0,0 +1,137 @@
+'use client';
+
+import { useMemo, useState } from 'react';
+import { motion } from 'framer-motion';
+import { useAuthStatus } from '@/hooks/use-auth';
+import { GetMeResponse } from '@/lib/api/types';
+import { Activity } from '@/types/user';
+import { AnalyticsBentoGrid } from '@/components/analytics/AnalyticsBentoGrid';
+import { AnalyticsChart } from '@/components/analytics/AnalyticsChart';
+import { AuthGuard } from '@/components/auth';
+import LoadingSpinner from '@/components/LoadingSpinner';
+import ActivityHeatmap from '@/components/profile/ActivityHeatMap';
+import ActivityFeed from '@/components/profile/ActivityFeed';
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from '@/components/ui/card';
+
+const FILTER_OPTIONS = [
+ 'All Time',
+ 'This Year',
+ 'This Month',
+ 'This Week',
+ 'Today',
+];
+
+function AnalyticsContent() {
+ const { user, isLoading } = useAuthStatus();
+ const [activityFilter, setActivityFilter] = useState('All Time');
+
+ const meData = useMemo(
+ () => (user?.profile as GetMeResponse | undefined) ?? null,
+ [user?.profile]
+ );
+
+ if (isLoading) {
+ return (
+ Authenticating...
}
+ >
+
+
diff --git a/app/api/blog/search/route.ts b/app/api/blog/search/route.ts
index 3b7fb9501..0ebb8459b 100644
--- a/app/api/blog/search/route.ts
+++ b/app/api/blog/search/route.ts
@@ -1,5 +1,5 @@
import { NextRequest, NextResponse } from 'next/server';
-import { getBlogPosts } from '@/lib/api/blog';
+import { getAllBlogPosts } from '@/lib/mdx';
export async function GET(request: NextRequest) {
try {
@@ -8,11 +8,13 @@ export async function GET(request: NextRequest) {
const page = parseInt(searchParams.get('page') || '1');
const limit = parseInt(searchParams.get('limit') || '12');
const category = searchParams.get('category');
- const tags = searchParams.get('tags')?.split(',').filter(Boolean);
-
- const response = await getBlogPosts({ limit: 100 });
- const allPosts = response.data;
+ const tags = searchParams
+ .get('tags')
+ ?.split(',')
+ .map(t => t.trim().toLowerCase())
+ .filter(Boolean);
+ const allPosts = getAllBlogPosts();
let filteredPosts = allPosts;
if (q.trim()) {
@@ -21,21 +23,20 @@ export async function GET(request: NextRequest) {
post =>
post.title.toLowerCase().includes(query) ||
post.excerpt.toLowerCase().includes(query) ||
- (post.tags &&
- post.tags.some(tag => tag.tag.name.toLowerCase().includes(query)))
+ post.tags.some(tag => tag.toLowerCase().includes(query))
);
}
if (category) {
- filteredPosts = filteredPosts.filter(
- post => post.categories && post.categories.includes(category)
+ const normalizedCategory = category.trim().toLowerCase();
+ filteredPosts = filteredPosts.filter(post =>
+ post.categories.some(c => c.toLowerCase() === normalizedCategory)
);
}
if (tags && tags.length > 0) {
- filteredPosts = filteredPosts.filter(
- post =>
- post.tags && tags.some(tag => post.tags.some(t => t.tag.name === tag))
+ filteredPosts = filteredPosts.filter(post =>
+ tags.some(tag => post.tags.some(t => t.toLowerCase() === tag))
);
}
diff --git a/app/api/didit/callback/route.ts b/app/api/didit/callback/route.ts
new file mode 100644
index 000000000..ce0c46753
--- /dev/null
+++ b/app/api/didit/callback/route.ts
@@ -0,0 +1,17 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * Didit redirect callback: user is sent here after completing verification on Didit.
+ * We redirect them to Settings โ Identity so they see their updated status.
+ * The backend receives the final result via webhook; this route only handles the browser redirect.
+ */
+export async function GET(request: NextRequest) {
+ const searchParams = request.nextUrl.searchParams;
+ const verification = searchParams.get('verification') ?? 'complete';
+
+ const baseUrl = request.nextUrl.origin;
+ const redirectUrl = new URL('/me/settings', baseUrl);
+ redirectUrl.searchParams.set('verification', verification);
+
+ return NextResponse.redirect(redirectUrl, 302);
+}
diff --git a/app/api/og/route.tsx b/app/api/og/route.tsx
new file mode 100644
index 000000000..e954942fc
--- /dev/null
+++ b/app/api/og/route.tsx
@@ -0,0 +1,188 @@
+import { ImageResponse } from 'next/og';
+
+export const runtime = 'edge';
+
+const API_BASE =
+ process.env.NEXT_PUBLIC_API_URL || 'https://staging-api.boundlessfi.xyz';
+const API_URL = API_BASE.replace(/\/$/, '').replace(/\/api$/i, '') + '/api';
+
+interface OrganizationProfile {
+ id: string;
+ name: string;
+ logoUrl: string;
+ description: string;
+ stats: {
+ projectsCount: number;
+ totalHackathons: number;
+ totalBounties: number;
+ totalGrants: number;
+ };
+}
+
+function truncate(text: string, maxLen: number): string {
+ if (!text || text.length <= maxLen) return text || '';
+ return text.slice(0, maxLen - 3).trim() + '...';
+}
+
+export async function GET(request: Request) {
+ const { searchParams } = new URL(request.url);
+ const slug = searchParams.get('slug');
+
+ if (!slug) {
+ return new ImageResponse(
+
+
+
@@ -269,39 +342,8 @@ export default function HackathonsPage() {
-
-
- ) : allHackathons.length === 0 ? (
-
-
-
-
-
) : (
-
-
- - No hackathons yet -
-- Get started by hosting your first hackathon -
- -
- {allHackathons.map(item => {
- const isDraft = item.type === 'draft';
- const hackathon = item.data;
- const title = isDraft
- ? (hackathon as HackathonDraft).data.information?.name ||
- 'Untitled Hackathon'
- : (hackathon as Hackathon).name || 'Untitled Hackathon';
- const completion = isDraft
- ? calculateDraftCompletion(hackathon as HackathonDraft)
- : 0;
- const endDate = isDraft
- ? (hackathon as HackathonDraft).data.timeline
- ?.submissionDeadline ||
- (hackathon as HackathonDraft).data.timeline
- ?.winnerAnnouncementDate
- : (hackathon as Hackathon).submissionDeadline ||
- (hackathon as Hackathon).endDate;
- const totalPrize = isDraft
- ? (
- hackathon as HackathonDraft
- ).data.rewards?.prizeTiers?.reduce(
- (sum: number, tier: any) => sum + (tier.amount || 0),
- 0
- ) || 0
- : (hackathon as Hackathon).prizeTiers?.reduce(
- (sum: number, tier: any) => sum + (tier.amount || 0),
- 0
- ) || 0;
-
- if (isDraft) {
- return (
- {children}
diff --git a/app/(landing)/profile/[username]/profile-data.tsx b/app/(landing)/profile/[username]/profile-data.tsx
index 8bb25af72..30c6281b9 100644
--- a/app/(landing)/profile/[username]/profile-data.tsx
+++ b/app/(landing)/profile/[username]/profile-data.tsx
@@ -1,10 +1,11 @@
'use client';
import { useEffect, useState } from 'react';
+import { Filter } from 'lucide-react';
import { getUserProfileByUsername } from '@/lib/api/auth';
+import { authClient } from '@/lib/auth-client';
import { PublicUserProfile } from '@/features/projects/types';
import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
-import ActivityTab from '@/components/profile/ActivityTab';
import {
DropdownMenu,
DropdownMenuContent,
@@ -12,11 +13,12 @@ import {
DropdownMenuTrigger,
} from '@/components/ui/dropdown-menu';
import { Button } from '@/components/ui/button';
+import { clsx } from 'clsx';
+import ActivityTab from '@/components/profile/ActivityTab';
import OrganizationsTab from '@/components/profile/OrganizationsTab';
-import { Filter } from 'lucide-react';
-import { authClient } from '@/lib/auth-client';
import ProfileOverviewPublic from '@/components/profile/ProfileOverviewPublic';
import ProjectsTabPublic from '@/components/profile/ProjectsTabPublic';
+import PublicEarningsTab from '@/components/profile/PublicEarningsTab';
interface PublicProfileDataProps {
username: string;
@@ -32,20 +34,26 @@ const FILTER_OPTIONS = [
'All Time',
];
-export function ProfileData({ username }: PublicProfileDataProps) {
+const TAB_CLASS =
+ 'data-[state=active]:border-b-primary/45 rounded-none border-b-2 border-transparent bg-transparent px-0 py-3 text-sm font-medium text-zinc-500 data-[state=active]:text-white';
+
+export const ProfileData = ({
+ username,
+}: PublicProfileDataProps): React.ReactElement => {
const [userData, setUserData] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
const [selectedFilter, setSelectedFilter] = useState('All');
- const [authUser, setAuthUser] = useState(null);
+ const [authUsername, setAuthUsername] = useState(null);
const [isAuthenticated, setIsAuthenticated] = useState(false);
+
useEffect(() => {
- async function loadProfile() {
+ const loadProfile = async (): Promise => {
try {
+ setLoading(true);
const { data: session } = await authClient.getSession();
- setAuthUser(session?.user?.profile?.username || null);
+ setAuthUsername(session?.user?.profile?.username || null);
setIsAuthenticated(!!session?.user);
- setLoading(true);
const data = await getUserProfileByUsername(username);
setUserData(data);
} catch (err) {
@@ -53,11 +61,15 @@ export function ProfileData({ username }: PublicProfileDataProps) {
} finally {
setLoading(false);
}
- }
+ };
loadProfile();
}, [username]);
+ const handleFilterSelect = (filter: string) => {
+ setSelectedFilter(filter);
+ };
+
if (loading) {
return (
@@ -87,8 +99,7 @@ export function ProfileData({ username }: PublicProfileDataProps) {
name: org.name,
avatarUrl: org.logo || '/blog1.jpg',
})) || [];
- // Determine if it's the user's own profile
- const isOwnProfile = isAuthenticated && authUser === userData.username;
+ const isOwnProfile = isAuthenticated && authUsername === userData.username;
return (
@@ -103,24 +114,23 @@ export function ProfileData({ username }: PublicProfileDataProps) {
-
+
Activity
-
+
Projects
-
- Organizations
+
+ Earnings
+ {isAuthenticated && isOwnProfile && (
+
+ Organizations
+
+ )}
@@ -145,12 +155,12 @@ export function ProfileData({ username }: PublicProfileDataProps) {
{FILTER_OPTIONS.map(filter => (
setSelectedFilter(filter)}
- className={
- selectedFilter === filter
- ? 'bg-zinc-800'
- : 'hover:!bg-zinc-600/50 hover:!text-white'
- }
+ onClick={() => handleFilterSelect(filter)}
+ className={clsx({
+ 'bg-zinc-800': selectedFilter === filter,
+ 'hover:bg-zinc-600/50! hover:text-white!':
+ selectedFilter !== filter,
+ })}
>
{filter}
@@ -163,6 +173,10 @@ export function ProfileData({ username }: PublicProfileDataProps) {
+
+
{isAuthenticated && isOwnProfile && (
);
-}
+};
diff --git a/app/(landing)/profile/[username]/projects/page.tsx b/app/(landing)/profile/[username]/projects/page.tsx
index 8d3a1d1d0..888ac850f 100644
--- a/app/(landing)/profile/[username]/projects/page.tsx
+++ b/app/(landing)/profile/[username]/projects/page.tsx
@@ -1,7 +1,6 @@
-import React from 'react';
-
+import { redirect } from 'next/navigation';
const Page = () => {
- return
- router.push(
- `/organizations/${organizationId}/hackathons/drafts/${hackathon.id}`
- )
- }
- className='group cursor-pointer rounded-xl border border-zinc-800 bg-zinc-900/30 p-6 transition-all hover:border-zinc-700 hover:bg-zinc-900/50'
+ <>
+ {tab === 'published' ? (
+ publishedHackathons.length === 0 ? (
+ {children}
+
+ {children}
+
) : (
+
diff --git a/app/(landing)/organizations/layout.tsx b/app/(landing)/organizations/layout.tsx
index f187e7e52..4cf71c888 100644
--- a/app/(landing)/organizations/layout.tsx
+++ b/app/(landing)/organizations/layout.tsx
@@ -10,9 +10,11 @@ import {
NavigationLoadingProvider,
useNavigationLoading,
} from '@/lib/providers';
+import { cn } from '@/lib/utils';
import NewHackathonSidebar from '@/components/organization/hackathons/new/NewHackathonSidebar';
import HackathonSidebar from '@/components/organization/hackathons/details/HackathonSidebar';
import HackathonNavigationLoader from '@/components/organization/hackathons/details/HackathonNavigationLoader';
+
export default function OrganizationsLayout({
children,
}: {
@@ -92,7 +94,14 @@ function OrganizationsLayoutContent({
)}
{/* {showNewGrantSidebar &&
+
+ + No published hackathons yet +
++ Get started by hosting your first hackathon +
+ -
-
+ )}
+
)}
-
- Draft
-
-
- {completion}% complete
-
+
+
+
+
+ ) : (
+
+ {publishedHackathons.map(hackathon => {
+ const endDate = hackathon.submissionDeadline;
+ const totalPrize =
+ hackathon.prizeTiers?.reduce(
+ (sum: number, tier: any) => sum + (tier.amount || 0),
+ 0
+ ) || 0;
+ return (
+
+ );
+ })}
+
+ router.push(
+ `/organizations/${organizationId}/hackathons/${hackathon.id}`
+ )
+ }
+ tabIndex={0}
+ role='button'
+ aria-label={`View hackathon ${hackathon.name}`}
+ >
+ {hackathon.banner && (
+
-
+
+ )}
+
+
+
+ {(() => {
+ const { label, className } = getStatusDisplay(
+ hackathon.status as HackathonStatus
+ );
+ return (
+
+ {label}
+
+ );
+ })()}
+ {endDate && (
+
+
+ + {hackathon.name} +
+
+
+
+
+
+
+
+ );
+ })}
+
+ )
+ ) : draftHackathons.length === 0 ? (
+
+
+
+
+
+ ) : (
+
+
+ + No drafts yet +
++ Start a new draft to host your first hackathon +
+ +
+ {draftHackathons.map(draft => {
+ const title =
+ draft.data.information?.name || 'Untitled Hackathon';
+ const completion = calculateDraftCompletion(draft);
+ const endDate = draft.data.timeline?.submissionDeadline;
+ const totalPrize =
+ draft.data.rewards?.prizeTiers?.reduce(
+ (sum: number, tier: any) => sum + (tier.amount || 0),
+ 0
+ ) || 0;
+ return (
+
- );
- }
-
- const publishedHackathon = hackathon as Hackathon;
-
- return (
-
+ router.push(
+ `/organizations/${organizationId}/hackathons/drafts/${draft.id}`
+ )
+ }
+ tabIndex={0}
+ role='button'
+ aria-label={`Edit draft ${title}`}
+ >
+
-
-
+
+
+
+ Draft
+
+
+ {completion}% complete
+
+ {endDate && (
+
+
+ + {title} +
+
+ {totalPrize > 0 && (
+
+
+
+
+
+ - {title} -
- -
-
-
-
-
- );
- })}
-
-
-
-
-
-
-
-
-
- {publishedHackathon.status === 'PUBLISHED'
- ? 'Live'
- : publishedHackathon.status}
-
- {endDate && (
-
-
-
-
- )}
- - {title} -
- -
-
-
-
-
-
- {totalPrize > 0 && (
- <>
-
-
-
-
- )}
-
-
-
-
-
- Projects
;
+ redirect('/coming-soon');
};
export default Page;
diff --git a/app/(landing)/projects/[slug]/page.tsx b/app/(landing)/projects/[slug]/page.tsx
index 2ba0f1d24..aa7271a42 100644
--- a/app/(landing)/projects/[slug]/page.tsx
+++ b/app/(landing)/projects/[slug]/page.tsx
@@ -79,13 +79,11 @@ function ProjectContent({
setLoading(true);
setError(null);
- // If query param specifies submission, try that first/only
if (isSubmission) {
await fetchSubmission(id);
return;
}
- // Try fetching as crowdfunding project first
try {
const projectData = await getCrowdfundingProject(id);
if (projectData) {
@@ -93,9 +91,6 @@ function ProjectContent({
return;
}
} catch (e) {
- // Ignore error and try fetching as submission
- console.log('Not a crowdfunding project, checking submission...', e);
- // Fallback to submission check
await fetchSubmission(id);
}
} catch {
@@ -126,7 +121,7 @@ function ProjectContent({
+ Organization | Boundless
+
,
+ { width: 1200, height: 630 }
+ );
+ }
+
+ let name = 'Organization';
+ let description = 'View on Boundless';
+ let logoUrl: string | null = null;
+
+ try {
+ const res = await fetch(
+ `${API_URL}/organizations/profile/${encodeURIComponent(slug)}`
+ );
+ if (res.ok) {
+ const json = await res.json();
+ const data = json?.data as OrganizationProfile | undefined;
+ if (data) {
+ name = data.name || name;
+ description = truncate(data.description || description, 140);
+ logoUrl = data.logoUrl || null;
+ }
+ }
+ } catch {
+ // use defaults
+ }
+
+ return new ImageResponse(
+
+
+
,
+ {
+ width: 1200,
+ height: 630,
+ }
+ );
+}
diff --git a/app/coming-soon/page.tsx b/app/coming-soon/page.tsx
new file mode 100644
index 000000000..74bd811fe
--- /dev/null
+++ b/app/coming-soon/page.tsx
@@ -0,0 +1,17 @@
+import ComingSoon from '@/components/ComingSoon';
+import { Footer, Navbar } from '@/components/landing-page';
+import React from 'react';
+
+const page = () => {
+ return (
+ <>
+
+ {logoUrl ? (
+ 
+ ) : (
+
+
+ {name.charAt(0).toUpperCase()}
+
+ )}
+
+
+ + {name} +
++ {description} +
+
+
+ Boundless
+
+
+
+
+ );
+ }
+
+ if (!meData?.stats || !meData?.chart) {
+ return (
+
+ Analytics data unavailable.
+
+ );
+ }
+
+ const activities = (meData.user?.activities ?? []) as Activity[];
+
+ return (
+
+ {/* Page header โ matches earnings page pattern */}
+
+
+
+ {/* Bento stats grid */}
+
+
+ Contribution Graph
+ Your activity over the last year
+
+
+
+
+
+ {/* Recent activity feed */}
+
+
+
+
+
+
+
+ );
+}
+
+export default function AnalyticsPage() {
+ return (
+ Analytics
++ Your personal growth dashboard across the platform. +
+
+ Recent Activity
+
+ What you have been up to on the platform
+
+
+
+ {/* Filter toggle โ matches the pattern ActivityFeed expects */}
+
+ {FILTER_OPTIONS.map(f => (
+
+ ))}
+
+ Your Project contact information will be used for Project - verification and for Boundless staff to contact you. The contact - information can only be accessed by Boundless staff. + verification and for Boundless team to contact you. The contact + information can only be accessed by Boundless team.
{value}
+ {description}
+
+
+);
+
+/**
+ * Interface for ActivityItem props.
+ */
+interface ActivityItemProps {
+ activity: EarningActivity;
+}
+
+/**
+ * ActivityItem component for displaying a single reward entry.
+ */
+const ActivityItem: React.FC
+
+ ${(value ?? 0).toLocaleString()}
+
+ {icon}
+
+ {label}
+
+
+);
+
+/**
+ * EarningsSkeleton component for loading states.
+ */
+const EarningsSkeleton: React.FC = () => (
+
+
+ {activity.title}
+
+ {activity.source}
+ โข
+ {new Date(activity.occurredAt).toLocaleDateString()}
+
+
+
+ + ${(activity.amount ?? 0).toLocaleString()} +
+ {activity.currency && ( +{activity.currency}
+ )} +
+
+);
+
+/**
+ * EarningsPage component for managing and tracking user rewards.
+ */
+const EarningsPage: React.FC = () => {
+ const [loading, setLoading] = useState(true);
+ const [data, setData] = useState
+
+
+
+
+
+
+
+ );
+ }
+
+ return (
+ + No earnings data found. +
+
+
+
+
+ {/* Summary Cards */}
+
+ );
+};
+
+export default EarningsPage;
diff --git a/app/me/hackathons/page.tsx b/app/me/hackathons/page.tsx
new file mode 100644
index 000000000..c1ff1b6d9
--- /dev/null
+++ b/app/me/hackathons/page.tsx
@@ -0,0 +1,7 @@
+import { redirect } from 'next/navigation';
+
+const page = () => {
+ redirect('/coming-soon');
+};
+
+export default page;
diff --git a/app/me/hackathons/submissions/page.tsx b/app/me/hackathons/submissions/page.tsx
new file mode 100644
index 000000000..767c32af2
--- /dev/null
+++ b/app/me/hackathons/submissions/page.tsx
@@ -0,0 +1,394 @@
+'use client';
+
+import { useState, useMemo, type FC } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { useAuthStatus } from '@/hooks/use-auth';
+import BoundlessSheet from '@/components/sheet/boundless-sheet';
+import EmptyState from '@/components/EmptyState';
+import { useRouter } from 'next/navigation';
+import { Trophy } from 'lucide-react';
+import {
+ Table,
+ TableBody,
+ TableHead,
+ TableHeader,
+ TableRow as ShadcnTableRow,
+} from '@/components/ui/table';
+import {
+ SortField,
+ SortDir,
+ SubmissionRow,
+ SortIcon,
+ SubmissionsSheetContent,
+ TableRow,
+} from './submission-components';
+
+/** API shape for a submission as returned from profile / user endpoints. */
+interface RawSubmission {
+ id?: string;
+ _id?: string;
+ projectName?: string;
+ title?: string;
+ name?: string;
+ description?: string;
+ introduction?: string;
+ logo?: string;
+ videoUrl?: string;
+ category?: string;
+ links?: Array<{ type: string; url: string }>;
+ status?: string;
+ rank?: number | null;
+ submittedAt?: string;
+ submissionDate?: string;
+ createdAt?: string;
+ votes?: number | unknown[];
+ comments?: number | unknown[];
+ hackathon?: SubmissionRow['hackathon'];
+ disqualificationReason?: string;
+}
+
+/** Profile shape that may expose submissions under user or at profile level. */
+interface UserProfile {
+ user?: {
+ hackathonSubmissionsAsParticipant?: RawSubmission[];
+ };
+ hackathonSubmissionsAsParticipant?: RawSubmission[];
+}
+
+const SubmissionsPage: FC = () => {
+ const router = useRouter();
+ const { user, isLoading } = useAuthStatus();
+
+ const [sortField, setSortField] = useState+ Earnings Dashboard +
++ Manage and track your rewards across the platform. +
+
+
+
+
+ {/* Breakdown */}
+
+
+ Source Breakdown
+
+ Earnings categorized by activity type
+
+
+
+
+
+
+ {/* Activity Feed */}
+
+
+ Recent Activity
+ Your latest wins and rewards
+
+
+
+
+
+
+ {data.activities.length === 0 ? (
+
+ + No recent activity found. +
+ ) : ( + data.activities.map(activity => ( +
+
+
+ );
+ }
+
+ return (
+
+ {/* Page header */}
+
+
+
+ {/* Summary strip */}
+ {rawSubmissions.length > 0 && (
+
+ {summaryStats.map(stat => (
+
+ )}
+
+ {/* Table */}
+
+ {sorted.length > 0 ? (
+
+
+ ) : (
+
+ router.push('/hackathons')}
+ />
+
+ )}
+
+
+ {/* Detail sheet */}
+
+ {selectedSubmission && (
+
+
+ );
+};
+
+export default SubmissionsPage;
diff --git a/app/me/hackathons/submissions/submission-components.tsx b/app/me/hackathons/submissions/submission-components.tsx
new file mode 100644
index 000000000..3e636b4c9
--- /dev/null
+++ b/app/me/hackathons/submissions/submission-components.tsx
@@ -0,0 +1,521 @@
+'use client';
+
+import { motion } from 'framer-motion';
+import {
+ ChevronUp,
+ ChevronDown,
+ ChevronsUpDown,
+ CalendarDays,
+ Trophy,
+ ExternalLink,
+ MessageCircle,
+ ThumbsUp,
+ FileText,
+ Layers,
+} from 'lucide-react';
+import { Separator } from '@/components/ui/separator';
+import { TableCell, TableRow as ShadcnTableRow } from '@/components/ui/table';
+import Image from 'next/image';
+import { format } from 'date-fns';
+import React, { useState } from 'react';
+
+// โโโโโโโโโโโโโโโโโโโโโโโโโโโ Url Sanitization โโโโโโโโโโโโโโโโโโโโโโโโโโโ
+
+export const getSafeUrl: (
+ urlString?: string
+) => string | undefined = urlString => {
+ if (!urlString) return undefined;
+ try {
+ const parsed = new URL(urlString);
+ if (['http:', 'https:', 'mailto:'].includes(parsed.protocol)) {
+ return parsed.href;
+ }
+ return undefined;
+ } catch {
+ return undefined;
+ }
+};
+
+const formatDate = (dateString?: string): string => {
+ if (!dateString) return 'โ';
+ try {
+ return format(new Date(dateString), 'MMM d, yyyy');
+ } catch {
+ return dateString;
+ }
+};
+
+export type SortField =
+ | 'projectName'
+ | 'hackathon'
+ | 'status'
+ | 'submittedAt'
+ | 'rank';
+export type SortDir = 'asc' | 'desc';
+
+export type SubmissionRow = {
+ id: string;
+ projectName: string;
+ description?: string;
+ introduction?: string;
+ logo?: string;
+ videoUrl?: string;
+ category?: string;
+ links?: Array<{ type: string; url: string }>;
+ status: string;
+ rank?: number | null;
+ submittedAt: string;
+ votes?: number | unknown[];
+ comments?: number | unknown[];
+ hackathon?: {
+ id?: string;
+ title?: string;
+ name?: string;
+ startDate?: string;
+ submissionDeadline?: string;
+ banner?: string;
+ };
+ disqualificationReason?: string;
+};
+
+// โโโโโโโโโโโโโโโโโโโโโโโโโโโ Status badge โโโโโโโโโโโโโโโโโโโโโโโโโโโ
+
+export const getStatusConfig: (status: string) => {
+ label: string;
+ className: string;
+} = status => {
+ const s = (status || '').toLowerCase();
+
+ if (
+ s === 'ranked' ||
+ s === 'shortlisted' ||
+ s === 'winner' ||
+ s === 'completed'
+ ) {
+ return {
+ label:
+ s === 'shortlisted' ? 'Ranked' : s.charAt(0).toUpperCase() + s.slice(1),
+ className: 'text-primary bg-primary/10',
+ };
+ }
+ if (s === 'under_review' || s === 'under review') {
+ return {
+ label: 'Under Review',
+ className: 'text-amber-400 bg-amber-400/10',
+ };
+ }
+ if (s === 'submitted') {
+ return {
+ label: 'Submitted',
+ className: 'text-blue-400 bg-blue-400/10',
+ };
+ }
+ if (s === 'disqualified') {
+ return {
+ label: 'Disqualified',
+ className: 'text-red-400 bg-red-400/10',
+ };
+ }
+ // draft / default
+ return {
+ label:
+ s === 'draft'
+ ? 'Draft'
+ : s.charAt(0).toUpperCase() + s.slice(1) || 'Draft',
+ className: 'text-gray-400 bg-gray-800/20',
+ };
+};
+
+export const StatusBadge: React.FC<{ status: string }> = ({ status }) => {
+ const cfg = getStatusConfig(status);
+ return (
+
+ {cfg.label}
+
+ );
+};
+
+// โโโโโโโโโโโโโโโโโโโโโโโโโโโ Sort icon โโโโโโโโโโโโโโโโโโโโโโโโโโโ
+
+export function SortIcon({
+ field,
+ sortField,
+ sortDir,
+}: {
+ field: SortField;
+ sortField: SortField;
+ sortDir: SortDir;
+}) {
+ if (sortField !== field)
+ return + My Submissions +
++ Track the full lifecycle of every hackathon submission you've + made. +
+
+
+ {stat.value}
+
+ {stat.label}
+
+ ))}
+
+
+
+
+
+ {/* Header */}
+
+ );
+}
+
+export function TableRow({
+ submission,
+ index,
+ onClick,
+}: {
+ submission: SubmissionRow;
+ index: number;
+ onClick: () => void;
+}) {
+ const hackathonName =
+ submission.hackathon?.title || submission.hackathon?.name || 'โ';
+
+ const viewUrl = `/projects/${submission.id}?type=submission`;
+ const [isHoverOrFocus, setIsHoverOrFocus] = useState(false);
+
+ const handleLeftClick = (e: React.MouseEvent) => {
+ // Left click only
+ if (e.button !== 0) return;
+ onClick();
+ };
+
+ const handleAuxClick = (e: React.MouseEvent) => {
+ // Middle click only -> open in new tab
+ if (e.button === 1) {
+ e.stopPropagation();
+ window.open(viewUrl, '_blank', 'noopener,noreferrer');
+ }
+ };
+
+ const handleKeyDown = (e: React.KeyboardEvent) => {
+ if (e.key === 'Enter') {
+ onClick();
+ } else if (e.key === ' ') {
+ e.preventDefault(); // prevent page scrolling
+ onClick();
+ }
+ };
+
+ return (
+
+
+
+ {/* Banner / Logo */}
+ {(submission.hackathon?.banner || submission.logo) && (
+
+
+ + {submission.projectName} +
+
+
+
+
+
+ )}
+
+ {/* Metadata strip */}
+
+
+ )}
+
+
+
+ {submission.rank != null && (
+
+
+
+ {/* Hackathon dates */}
+ {(submission.hackathon?.startDate ||
+ submission.hackathon?.submissionDeadline) && (
+
+ {submission.hackathon.startDate && (
+
+ )}
+
+
+
+ )}
+ {submission.hackathon.submissionDeadline && (
+ Hackathon Start
++ {formatDate(submission.hackathon.startDate)} +
+
+
+ )}
+ Submission Deadline
++ {formatDate(submission.hackathon.submissionDeadline)} +
+
+
+ )}
+
+ {/* Introduction */}
+ {submission.introduction && (
+ + Description +
++ {submission.description} +
+
+
+ )}
+
+ {/* Video link */}
+ {safeVideoUrl && (
+ + Introduction +
++ {submission.introduction} +
+
+
+ )}
+
+ {/* Project links */}
+ {submission.links && submission.links.length > 0 && (
+ + Demo Video +
+ +
+
+ )}
+
+ {/* Disqualification reason */}
+ {(submission.status || '').toLowerCase() === 'disqualified' &&
+ submission.disqualificationReason && (
+ + Project Links +
+
+ {submission.links.map((link, i) => {
+ const safeUrl = getSafeUrl(link.url);
+ if (!safeUrl) return null;
+ return (
+
+
+
+
+ )}
+ + Disqualification Reason +
++ {submission.disqualificationReason} +
+
+ {submission.logo ? (
+
+
+
+ ) : (
+
+
+ )}
+
+
+ {submission.projectName}
+
+ {/* Always in DOM โ fade via opacity so no layout shift */}
+ e.stopPropagation()}
+ onFocus={() => setIsHoverOrFocus(true)}
+ onBlur={() => setIsHoverOrFocus(false)}
+ tabIndex={isHoverOrFocus ? 0 : -1}
+ aria-hidden={!isHoverOrFocus}
+ title='Open submission in new tab'
+ className='rounded-sm text-zinc-500 opacity-0 transition-opacity duration-150 group-hover:opacity-100 hover:text-zinc-200 focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-[#a7f950] focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-900 focus-visible:outline-none'
+ aria-label={`Open ${submission.projectName} in new tab`}
+ >
+
+
@@ -18,14 +70,6 @@ export default function MeLayout({ children }: { children: React.ReactNode }) {
);
}
- const { name = '', email = '', profile, image: userImage = '' } = user || {};
-
- const userData = {
- name: name || '',
- email,
- image: profile?.image || userImage,
- };
-
return (
-
);
-}
+};
+
+export default MeLayout;
diff --git a/app/me/notifications/components/NotificationDetailSheet.tsx b/app/me/notifications/components/NotificationDetailSheet.tsx
new file mode 100644
index 000000000..d99340285
--- /dev/null
+++ b/app/me/notifications/components/NotificationDetailSheet.tsx
@@ -0,0 +1,148 @@
+'use client';
+
+import { Notification } from '@/types/notifications';
+import BoundlessSheet from '@/components/sheet/boundless-sheet';
+import { getNotificationIcon } from '@/components/notifications/NotificationIcon';
+import { format, formatDistanceToNow } from 'date-fns';
+import { cn } from '@/lib/utils';
+import { Badge } from '@/components/ui/badge';
+
+interface NotificationDetailSheetProps {
+ notification: Notification | null;
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+}
+
+const metadataLabels: Record = {
+ organizationName: 'Organization',
+ hackathonName: 'Hackathon',
+ projectName: 'Project',
+ memberEmail: 'Member',
+ role: 'Role',
+ oldRole: 'Previous Role',
+ newRole: 'New Role',
+ oldStatus: 'Previous Status',
+ newStatus: 'New Status',
+ submissionStatus: 'Submission Status',
+ deadlineType: 'Deadline',
+ amount: 'Amount',
+ transactionHash: 'Transaction',
+};
+
+export const NotificationDetailSheet = ({
+ notification,
+ open,
+ onOpenChange,
+}: NotificationDetailSheetProps) => {
+ if (!notification) return null;
+
+ const Icon = getNotificationIcon(notification.type);
+ const createdAt = new Date(notification.createdAt);
+
+ const metadata = Object.entries(notification.data).filter(
+ ([key, value]) =>
+ value !== undefined &&
+ value !== null &&
+ key in metadataLabels &&
+ key !== 'organizationId' &&
+ key !== 'hackathonId' &&
+ key !== 'projectId' &&
+ key !== 'commentId' &&
+ key !== 'milestoneId' &&
+ key !== 'teamInvitationId' &&
+ key !== 'hackathonSlug'
+ );
+
+ return (
+
+
+ );
+};
diff --git a/app/me/notifications/components/NotificationFeedItem.tsx b/app/me/notifications/components/NotificationFeedItem.tsx
new file mode 100644
index 000000000..42620eba8
--- /dev/null
+++ b/app/me/notifications/components/NotificationFeedItem.tsx
@@ -0,0 +1,95 @@
+'use client';
+
+import { formatDistanceToNow } from 'date-fns';
+import { Notification } from '@/types/notifications';
+import { getNotificationIcon } from '@/components/notifications/NotificationIcon';
+import { cn } from '@/lib/utils';
+import { motion, AnimatePresence } from 'motion/react';
+
+interface NotificationFeedItemProps {
+ notification: Notification;
+ onClick: () => void;
+ isMarkingAll: boolean;
+}
+
+export const NotificationFeedItem = ({
+ notification,
+ onClick,
+ isMarkingAll,
+}: NotificationFeedItemProps) => {
+ const Icon = getNotificationIcon(notification.type);
+ const isUnread = !notification.read;
+
+ return (
+
+ );
+};
diff --git a/app/me/notifications/components/NotificationSection.tsx b/app/me/notifications/components/NotificationSection.tsx
new file mode 100644
index 000000000..d1d575ba2
--- /dev/null
+++ b/app/me/notifications/components/NotificationSection.tsx
@@ -0,0 +1,79 @@
+'use client';
+
+import { Notification } from '@/types/notifications';
+import { NotificationFeedItem } from './NotificationFeedItem';
+import { motion, AnimatePresence } from 'motion/react';
+import { Archive, Bell, Inbox } from 'lucide-react';
+
+interface NotificationSectionProps {
+ title: string;
+ notifications: Notification[];
+ onNotificationClick: (notification: Notification) => void;
+ isMarkingAll: boolean;
+ emptyMessage: string;
+ emptySubMessage: string;
+}
+
+const sectionIcons: Record = {
+ New: Bell,
+ Earlier: Inbox,
+ Archived: Archive,
+};
+
+export const NotificationSection = ({
+ title,
+ notifications,
+ onNotificationClick,
+ isMarkingAll,
+ emptyMessage,
+ emptySubMessage,
+}: NotificationSectionProps) => {
+ const Icon = sectionIcons[title] ?? Bell;
+
+ return (
+
+
+ );
+};
diff --git a/app/me/notifications/page.tsx b/app/me/notifications/page.tsx
new file mode 100644
index 000000000..cb82075af
--- /dev/null
+++ b/app/me/notifications/page.tsx
@@ -0,0 +1,302 @@
+'use client';
+
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { useNotifications } from '@/hooks/useNotifications';
+import { useNotificationPolling } from '@/hooks/use-notification-polling';
+import { useNotificationStore } from '@/lib/stores/notification-store';
+import { Notification } from '@/types/notifications';
+import { NotificationDetailSheet } from './components/NotificationDetailSheet';
+import { NotificationSection } from './components/NotificationSection';
+import { Button } from '@/components/ui/button';
+import { Skeleton } from '@/components/ui/skeleton';
+import { AuthGuard } from '@/components/auth';
+import Loading from '@/components/Loading';
+import { toast } from 'sonner';
+import { motion, AnimatePresence } from 'motion/react';
+import { Bell, CheckCheck } from 'lucide-react';
+
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+
+function NotificationsPageSkeleton() {
+ return (
+ (null);
+ const [sheetOpen, setSheetOpen] = useState(false);
+ const [isMarkingAll, setIsMarkingAll] = useState(false);
+
+ const limit = 20;
+
+ const notificationsHook = useNotifications({ page, limit, autoFetch: true });
+ const {
+ notifications,
+ loading,
+ error,
+ total,
+ unreadCount,
+ markAllAsRead,
+ markNotificationAsRead,
+ setCurrentPage,
+ } = notificationsHook;
+
+ const { setUnreadCount, clearUnreadCount } = useNotificationStore();
+
+ useEffect(() => {
+ setUnreadCount(unreadCount);
+ }, [unreadCount, setUnreadCount]);
+
+ useNotificationPolling(notificationsHook, {
+ interval: 30000,
+ enabled: true,
+ });
+
+ const groups = useMemo(
+ () => groupNotifications(notifications),
+ [notifications]
+ );
+
+ const totalPages = Math.ceil(total / limit);
+
+ const handleNotificationClick = useCallback(
+ (notification: Notification) => {
+ setSelectedNotification(notification);
+ setSheetOpen(true);
+
+ if (!notification.read) {
+ markNotificationAsRead([notification.id]).catch(() => {});
+ }
+ },
+ [markNotificationAsRead]
+ );
+
+ const handleMarkAllAsRead = useCallback(async () => {
+ setIsMarkingAll(true);
+ try {
+ await markAllAsRead();
+ clearUnreadCount();
+ toast.success('All notifications marked as read');
+ } catch {
+ toast.error('Failed to mark all as read');
+ } finally {
+ setTimeout(() => setIsMarkingAll(false), 600);
+ }
+ }, [markAllAsRead, clearUnreadCount]);
+
+ const handlePageChange = useCallback(
+ (newPage: number) => {
+ setCurrentPage(newPage);
+ setPage(newPage);
+ window.scrollTo({ top: 0, behavior: 'smooth' });
+ },
+ [setCurrentPage]
+ );
+
+ if (error) {
+ return (
+ ('all');
+
+ const handleTabChange = (value: string) => {
+ setActiveTab(value as TabType);
+ };
+
+ const unifiedList = useMemo(() => {
+ const profile = user?.profile;
+ if (!profile) {
+ return [];
+ }
+
+ const joinedHackathons = (profile.user?.joinedHackathons ||
+ []) as JoinedHackathonRow[];
+ const hackathonsAsParticipant = (profile.hackathonsAsParticipant ||
+ []) as HackathonParticipantRow[];
+ const submissions = (profile.user?.hackathonSubmissionsAsParticipant ||
+ []) as HackathonSubmissionRow[];
+
+ const typedJoinedHackathons: UnifiedItem[] = joinedHackathons
+ .filter((h: JoinedHackathonRow) => {
+ const data =
+ (h as { hackathon?: Hackathon }).hackathon ?? (h as Hackathon);
+ return data?.id != null;
+ })
+ .map((h: JoinedHackathonRow) => {
+ const hackathonData =
+ (h as { hackathon?: Hackathon }).hackathon ?? (h as Hackathon);
+ return {
+ ...hackathonData,
+ type: 'hackathon' as const,
+ };
+ });
+
+ const typedParticipatingHackathons: UnifiedItem[] = hackathonsAsParticipant
+ .filter((p: HackathonParticipantRow) => p?.hackathon?.id != null)
+ .map((p: HackathonParticipantRow) => ({
+ ...p.hackathon,
+ type: 'hackathon' as const,
+ }));
+
+ const typedSubmissionHackathons: UnifiedItem[] = submissions
+ .filter((s: HackathonSubmissionRow) => s?.hackathon != null)
+ .map((s: HackathonSubmissionRow) => ({
+ ...s.hackathon,
+ type: 'hackathon' as const,
+ }));
+
+ // Merge and deduplicate by ID
+ const merged = [
+ ...typedParticipatingHackathons,
+ ...typedJoinedHackathons,
+ ...typedSubmissionHackathons,
+ ];
+
+ const seen = new Set();
+ const deduplicated = merged.filter(item => {
+ if (!item.id || seen.has(item.id)) return false;
+ seen.add(item.id);
+ return true;
+ });
+
+ const now = Date.now();
+ const sorted = deduplicated.sort((a, b) => {
+ const getPriority = (h: UnifiedItem) => {
+ if (!h.startDate || !h.submissionDeadline) return 1;
+
+ const start = new Date(h.startDate).getTime();
+ const deadline = new Date(h.submissionDeadline).getTime();
+
+ if (now >= start && now <= deadline) return 0;
+ if (now < start) return 1;
+ return 2;
+ };
+
+ return getPriority(a) - getPriority(b);
+ });
+
+ return sorted;
+ }, [user]);
+
+ const filteredList = useMemo(() => {
+ if (activeTab === 'projects') return [];
+
+ let result = unifiedList;
+ // Intentional: filter by type so that when UnifiedItem gains 'project' entries, this tab shows only hackathons.
+ if (activeTab === 'hackathons') {
+ result = unifiedList.filter(item => item.type === 'hackathon');
+ }
+ return result;
+ }, [unifiedList, activeTab]);
+
+ const getSubmissionStage = (hackathonId: string): SubmissionStage => {
+ const submission =
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ user?.profile?.user?.hackathonSubmissionsAsParticipant?.find(
+ (s: any) => s.hackathonId === hackathonId
+ );
+
+ if (!submission) return 'Not Started';
+
+ const statusRaw = submission.status;
+ if (!statusRaw || typeof statusRaw !== 'string') return 'In Progress';
+
+ const status = statusRaw.toUpperCase();
+ if (status === 'DRAFT') return 'In Progress';
+ if (status === 'SUBMITTED') return 'Submitted';
+ if (status === 'UNDER_REVIEW') return 'Under Review';
+ if (status === 'WINNER' || status === 'COMPLETED') return 'Results Pending';
+
+ return 'In Progress';
+ };
+
+ const handleEmptyStateClick = () => {
+ router.push(activeTab === 'projects' ? '/projects' : '/hackathons');
+ };
+
+ if (isLoading) {
+ return (
+ (null);
const [isLoading, setIsLoading] = useState(true);
+
+ const fetchUserData = useCallback(async () => {
+ try {
+ const user = await getMe();
+ setUserData(user);
+ } catch {
+ setUserData(null);
+ } finally {
+ setIsLoading(false);
+ }
+ }, []);
+
useEffect(() => {
- const fetchUserData = async () => {
- try {
- const user = await getMe();
- setUserData(user);
- } catch {
- setUserData(null);
- } finally {
- setIsLoading(false);
- }
- };
+ setIsLoading(true);
fetchUserData();
- }, []);
+ }, [fetchUserData]);
+
+ const handleVerificationComplete = useCallback(async () => {
+ await fetchUserData();
+ invalidateAuthProfileCache();
+ }, [fetchUserData]);
if (isLoading) {
return (
@@ -43,7 +57,10 @@ const SettingsContent = () => {
Manage your personal information and public profile
- {children}
+ {/* Notification header */}
+
+
+
+ {notification.read ? 'Read' : 'Unread'}
+
+
+
+ {/* Divider */}
+
+
+ {/* Message body */}
+
+
+
+
+ + {notification.title} +
+
+
+ ยท
+ {formatDistanceToNow(createdAt, { addSuffix: true })}
+
+
+
+
+ {/* Metadata */}
+ {metadata.length > 0 && (
+ + {notification.message} +
+
+
+ )}
+
+ {/* Type tag */}
+ + Details +
+
+ {metadata.map(([key, value]) => (
+
+
+
+ {metadataLabels[key] || key}
+
+
+ {key === 'amount'
+ ? `$${(value as number).toLocaleString()}`
+ : key === 'transactionHash'
+ ? `${String(value).slice(0, 8)}...${String(value).slice(-6)}`
+ : String(value)}
+
+
+ ))}
+
+
+ {notification.type.replace(/_/g, ' ')}
+
+
+
+
+
+ + {title} +
+ {notifications.length > 0 && ( + + {notifications.length} + + )} +
+ {notifications.length === 0 ? (
+
+
+ )}
+
+
+
+ ) : (
+ {emptyMessage}
+{emptySubMessage}
+
+ {notifications.map((notification, index) => (
+
+ onNotificationClick(notification)}
+ isMarkingAll={isMarkingAll}
+ />
+
+ ))}
+
+
+ {['New', 'Earlier', 'Archived'].map(sectionTitle => (
+
+
+ ))}
+
+ );
+}
+
+type NotificationGroups = {
+ new: Notification[];
+ earlier: Notification[];
+ archived: Notification[];
+};
+
+const groupNotifications = (
+ notifications: Notification[]
+): NotificationGroups => {
+ const now = Date.now();
+ const sevenDaysAgo = now - SEVEN_DAYS_MS;
+
+ const groups: NotificationGroups = { new: [], earlier: [], archived: [] };
+
+ for (const notification of notifications) {
+ const createdAt = new Date(notification.createdAt).getTime();
+
+ if (!notification.read) {
+ groups.new.push(notification);
+ } else if (createdAt >= sevenDaysAgo) {
+ groups.earlier.push(notification);
+ } else {
+ groups.archived.push(notification);
+ }
+ }
+
+ return groups;
+};
+
+export default function NotificationsPage() {
+ const [page, setPage] = useState(1);
+ const [selectedNotification, setSelectedNotification] =
+ useState
+
+
+ {[1, 2, 3].map(i => (
+
+
+
+ ))}
+
+
+
+
+
+
+ );
+ }
+
+ return (
+
+
+ + Error loading notifications +
+{error.message}
+ +
+ {/* Header โ matches me layout (Settings, etc.) */}
+
+
+ );
+}
diff --git a/app/me/participating/page.tsx b/app/me/participating/page.tsx
new file mode 100644
index 000000000..2f09b83cc
--- /dev/null
+++ b/app/me/participating/page.tsx
@@ -0,0 +1,268 @@
+'use client';
+
+import React, { useMemo, useState } from 'react';
+import { useRouter } from 'next/navigation';
+import { useAuthStatus } from '@/hooks/use-auth';
+import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import { motion, AnimatePresence } from 'framer-motion';
+import HackathonCard from '@/components/landing-page/hackathon/HackathonCard';
+import {
+ ProgressIndicator,
+ SubmissionStage,
+} from '@/components/hackathons/ProgressIndicator';
+import { cn } from '@/lib/utils';
+import { Hackathon } from '@/lib/api/hackathons';
+import EmptyState from '@/components/EmptyState';
+
+type TabType = 'all' | 'hackathons' | 'projects';
+
+/** API shape: joined hackathon can be wrapper or raw hackathon. */
+type JoinedHackathonRow = { hackathon?: Hackathon } | Hackathon;
+
+/** API shape: participant record with nested hackathon. */
+interface HackathonParticipantRow {
+ hackathon: Hackathon;
+}
+
+/** API shape: submission record with nested hackathon. */
+interface HackathonSubmissionRow {
+ hackathon: Hackathon;
+}
+
+interface UnifiedItem extends Hackathon {
+ type: 'hackathon';
+}
+
+const ParticipatingPage: React.FC = () => {
+ const router = useRouter();
+ const { user, isLoading } = useAuthStatus();
+ const [activeTab, setActiveTab] = useState
+
+ {unreadCount > 0 && !loading && (
+
+
+
+ )}
+
+
+
+ {/* Feed */}
+ {loading ? (
+
+
+
+ + Notifications +
++ {loading ? ( + + ) : ( + <> + {unreadCount > 0 + ? `${unreadCount} unread of ${total} total` + : `${total} notifications`} + + )} +
+
+
+ ) : (
+
+
+ + No notifications yet +
++ When you receive notifications about your projects, hackathons, or + account activity, they will appear here. +
+
+
+ )}
+
+ {/* Pagination */}
+ {totalPages > 1 && !loading && (
+
+
+
+ Page {page} of {totalPages}
+
+
+
+ )}
+
+ {/* Detail Sheet */}
+
+
+
+ );
+ }
+
+ return (
+
+
+ {filteredList.length > 0 ? (
+
+ {filteredList.map(hackathon => (
+
+
+ ))}
+
+ ) : (
+
+
+ );
+};
+
+export default ParticipatingPage;
diff --git a/app/me/profile/page.tsx b/app/me/profile/page.tsx
new file mode 100644
index 000000000..c1ff1b6d9
--- /dev/null
+++ b/app/me/profile/page.tsx
@@ -0,0 +1,7 @@
+import { redirect } from 'next/navigation';
+
+const page = () => {
+ redirect('/coming-soon');
+};
+
+export default page;
diff --git a/app/me/projects/create/page.tsx b/app/me/projects/create/page.tsx
new file mode 100644
index 000000000..c1ff1b6d9
--- /dev/null
+++ b/app/me/projects/create/page.tsx
@@ -0,0 +1,7 @@
+import { redirect } from 'next/navigation';
+
+const page = () => {
+ redirect('/coming-soon');
+};
+
+export default page;
diff --git a/app/me/settings/SettingsContent.tsx b/app/me/settings/SettingsContent.tsx
index 63bcb429a..2f0ad7017 100644
--- a/app/me/settings/SettingsContent.tsx
+++ b/app/me/settings/SettingsContent.tsx
@@ -1,28 +1,42 @@
'use client';
import Profile from '@/components/profile/update/Profile';
import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
-import { useEffect, useState } from 'react';
+import { useEffect, useState, useCallback } from 'react';
+import { useSearchParams } from 'next/navigation';
import { User } from '@/types/user';
import { getMe } from '@/lib/api/auth';
import { GetMeResponse } from '@/lib/api/types';
import { Skeleton } from '@/components/ui/skeleton';
import Settings from '@/components/profile/update/Settings';
+import { IdentityVerificationSection } from '@/components/didit/IdentityVerificationSection';
+import { invalidateAuthProfileCache } from '@/hooks/use-auth';
+
const SettingsContent = () => {
+ const searchParams = useSearchParams();
+ const fromVerification = searchParams.get('verification') === 'complete';
const [userData, setUserData] = useState
+
+
+ {['all', 'hackathons', 'projects'].map(tab => (
+
+ {tab}
+ {activeTab === tab && (
+
+ ))}
+
+
+
+
+
+
+
+ + Participating +
++ Track your active hackathons, projects, and pending submissions. +
+
+
+
+
+
+
+
+
+
+ In Progress
+
+
+ + {title} +
+ ++ {description} +
+
+
+
+
+
+ + Coming Soon +
++ Weโre building foundational systems to power a more transparent, + efficient grant and bounty ecosystem. +
+
+ {features.map((feature, index) => (
+
+ | Metric | +Value | +Trend | +
|---|---|---|
| {t.label} | +{t.value.toLocaleString()} | ++ {t.trend.direction === 'flat' + ? 'No change' + : `${t.trend.direction === 'up' ? 'Up' : 'Down'} ${t.trend.percentage}%`} + | +
+
+ );
+}
+
+export function AnalyticsChart({ chart }: Props) {
+ const [range, setRange] = useState{label}
++ {payload[0].value}{' '} + activities +
+
+ Activity Over Time
+ Your platform activity trend
+
+
+
+ {ranges.map(r => (
+
+ ))}
+
+
+ No activity data available for this period.
+
+ ) : (
+ <>
+ {/* Screen reader fallback */}
+ | Date | +Activity Count | +
|---|---|
| {d.label} | +{d.count} | +
diff --git a/components/auth/login-form.tsx b/components/auth/login-form.tsx
index 14e1d24ba..2a27932ec 100644
--- a/components/auth/login-form.tsx
+++ b/components/auth/login-form.tsx
@@ -36,7 +36,6 @@ export function LoginForm({ onSuccess, onError }: LoginFormProps) {
const onSubmit = async (data: LoginFormData) => {
try {
setIsLoading(true);
- // console.log('Attempting login for:', data.email);
const { error } = await authClient.signIn.email(
{
@@ -46,7 +45,6 @@ export function LoginForm({ onSuccess, onError }: LoginFormProps) {
},
{
onSuccess: () => {
- // console.log('Login successful');
toast.success('Login successful!');
onSuccess?.();
},
diff --git a/components/connect-wallet/index copy.tsx b/components/connect-wallet/index copy.tsx
deleted file mode 100644
index fc20dc232..000000000
--- a/components/connect-wallet/index copy.tsx
+++ /dev/null
@@ -1,388 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import {
- Dialog,
- DialogContent,
- DialogDescription,
- DialogTitle,
-} from '../ui/dialog';
-import WalletCard from './wallet-card';
-import { CircleQuestionMark, X, Loader2, AlertCircle } from 'lucide-react';
-import Link from 'next/link';
-import { Checkbox } from '../ui/checkbox';
-import { ScrollArea } from '../ui/scroll-area';
-import { Button } from '../ui/button';
-import { useWalletStore } from '@/hooks/use-wallet';
-import { toast } from 'sonner';
-import { TooltipContent, TooltipProvider } from '@radix-ui/react-tooltip';
-import { Tooltip, TooltipTrigger } from '../ui/tooltip';
-
-const ConnectWallet = ({
- open,
- onOpenChange,
- onConnect,
-}: {
- open: boolean;
- onOpenChange: (open: boolean) => void;
- onConnect?: () => void;
-}) => {
- const [selectedNetwork, setSelectedNetwork] = useState('testnet');
- const [acceptedTerms, setAcceptedTerms] = useState(true);
- const [isConnecting, setIsConnecting] = useState(false);
- const [connectingWallet, setConnectingWallet] = useState(null);
-
- const {
- network,
- availableWallets,
- isConnected,
- isLoading,
- error,
- initializeWalletKit,
- connectWallet,
- clearError,
- } = useWalletStore();
-
- // Initialize wallet kit when modal opens
- useEffect(() => {
- if (open && !isConnected) {
- initializeWalletKit(selectedNetwork as 'testnet' | 'public').catch(() => {
- // Silently handle initialization errors
- // These are expected when wallet is not available
- });
- }
- }, [open, isConnected, initializeWalletKit, selectedNetwork]);
-
- // Handle network selection
- useEffect(() => {
- setSelectedNetwork(network);
- }, [network]);
-
- const networks = [
- {
- id: 'testnet',
- name: 'Testnet',
- icon: '/globe.svg',
- active: true,
- },
- {
- id: 'public',
- name: 'Public',
- icon: '/globe.svg',
- active: true,
- },
- ];
-
- const handleWalletSelect = async (walletId: string) => {
- if (!acceptedTerms) {
- toast.error('Please accept the terms and conditions first');
- return;
- }
-
- setIsConnecting(true);
- setConnectingWallet(walletId);
- clearError();
-
- try {
- // Show specific instructions for different wallets
- const walletInstructions = {
- freighter: 'Please unlock Freighter and approve the connection',
- albedo:
- 'Albedo will open in a new window. Please approve the connection',
- rabet: 'Please unlock Rabet and approve the connection',
- xbull: 'Please unlock xBull and approve the connection',
- lobstr: 'Please unlock Lobstr and approve the connection',
- hana: 'Please unlock Hana and approve the connection',
- 'hot-wallet':
- 'Please unlock your hardware wallet and approve the connection',
- };
-
- const instruction =
- walletInstructions[walletId as keyof typeof walletInstructions] ||
- 'Please approve the connection';
-
- toast.info(instruction, {
- duration: 5000,
- });
-
- await connectWallet(walletId);
-
- toast.success('Wallet connected successfully!', {
- description: `Connected to ${network === 'testnet' ? 'Testnet' : 'Public'} network`,
- });
- onOpenChange(false);
- onConnect?.();
- } catch (error) {
- const errorMessage =
- error instanceof Error ? error.message : 'Failed to connect wallet';
-
- // Provide specific error messages for different wallets
- let specificError = errorMessage;
- if (errorMessage.includes('not available')) {
- specificError = `${walletId} is not installed or not available. Please install it first.`;
- } else if (errorMessage.includes('permission')) {
- specificError = `Permission denied. Please unlock ${walletId} and try again.`;
- } else if (errorMessage.includes('network')) {
- specificError = `Network mismatch. Please switch ${walletId} to ${selectedNetwork} network.`;
- }
-
- toast.error('Connection failed', {
- description: specificError,
- duration: 8000,
- });
- } finally {
- setIsConnecting(false);
- setConnectingWallet(null);
- }
- };
-
- const handleNetworkChange = async (networkId: string) => {
- if (networkId === selectedNetwork) return;
-
- setSelectedNetwork(networkId);
-
- // Reinitialize wallet kit with new network
- try {
- await initializeWalletKit(networkId as 'testnet' | 'public');
- toast.success(
- `Switched to ${networkId === 'testnet' ? 'Testnet' : 'Public'} network`
- );
- } catch {
- toast.error('Failed to switch network');
- // Log error for debugging but don't expose to user
- }
- };
-
- // Filter available wallets and map them to our UI format
- const walletOptions = availableWallets
- .filter((wallet: { isAvailable: boolean }) => wallet.isAvailable)
- .map((wallet: { id: string; name: string; icon: string }) => ({
- id: wallet.id,
- name: wallet.name,
- icon: wallet.icon,
- disabled: false,
- }));
-
- // Fallback wallets if none are available
- const fallbackWallets = [
- {
- id: 'freighter',
- name: 'Freighter',
- icon: '/wallets/freighter.svg',
- disabled: false,
- },
- {
- id: 'albedo',
- name: 'Albedo',
- icon: '/wallets/albedo.svg',
- disabled: false,
- },
- {
- id: 'rabet',
- name: 'Rabet',
- icon: '/wallets/rabet.svg',
- disabled: false,
- },
- {
- id: 'xbull',
- name: 'xBull',
- icon: '/wallets/xbull.svg',
- disabled: false,
- },
- {
- id: 'lobstr',
- name: 'Lobstr',
- icon: '/wallets/lobstr.svg',
- disabled: false,
- },
- {
- id: 'hana',
- name: 'Hana',
- icon: '/wallets/hana.svg',
- disabled: false,
- },
- {
- id: 'hot-wallet',
- name: 'HOT Wallet',
- icon: '/wallets/hot-wallet.svg',
- disabled: false,
- },
- ];
-
- const wallets = walletOptions.length > 0 ? walletOptions : fallbackWallets;
-
- return (
-
- );
-};
-
-export default ConnectWallet;
diff --git a/components/connect-wallet/index.tsx b/components/connect-wallet/index.tsx
index a8b18c459..f14b298b0 100644
--- a/components/connect-wallet/index.tsx
+++ b/components/connect-wallet/index.tsx
@@ -13,6 +13,8 @@ import { useWalletStore } from '@/hooks/use-wallet';
import { toast } from 'sonner';
import { AlertCircle, Loader2, X } from 'lucide-react';
+import { getCurrentNetwork } from '@/lib/wallet-utils';
+
const ConnectWallet = ({
open,
onOpenChange,
@@ -22,7 +24,7 @@ const ConnectWallet = ({
onOpenChange: (open: boolean) => void;
onConnect?: () => void;
}) => {
- const [selectedNetwork, setSelectedNetwork] = useState('testnet');
+ const [selectedNetwork, setSelectedNetwork] = useState(getCurrentNetwork());
const [isConnecting, setIsConnecting] = useState(false);
const [connectingWallet, setConnectingWallet] = useState(null);
diff --git a/components/didit/DiditVerifyButton.tsx b/components/didit/DiditVerifyButton.tsx
new file mode 100644
index 000000000..2411b3d4b
--- /dev/null
+++ b/components/didit/DiditVerifyButton.tsx
@@ -0,0 +1,90 @@
+'use client';
+
+import { useState } from 'react';
+import { Button } from '@/components/ui/button';
+import clsx from 'clsx';
+import { createDiditSession } from '@/lib/api/didit';
+
+export interface DiditVerifyButtonProps {
+ onSuccess?: (session: { sessionId?: string; status?: string }) => void;
+ onError?: (error: Error | { code?: string; message?: string }) => void;
+ onCancel?: () => void;
+ className?: string;
+ disabled?: boolean;
+ /** Optional user id for vendor_data (backend uses authenticated user if omitted). */
+ userId?: string;
+}
+
+export function DiditVerifyButton({
+ onSuccess,
+ onError,
+ onCancel,
+ className,
+ disabled = false,
+ userId,
+}: DiditVerifyButtonProps) {
+ const [loading, setLoading] = useState(false);
+ const [error, setError] = useState(null);
+
+ const handleVerify = async () => {
+ setLoading(true);
+ setError(null);
+ try {
+ const { session_token, verification_url } = await createDiditSession(
+ userId != null ? { user_id: userId } : undefined
+ );
+
+ if (!session_token || !verification_url) {
+ throw new Error('Invalid session response');
+ }
+
+ const DiditSdkModule = await import('@didit-protocol/sdk-web');
+ const DiditSdk = DiditSdkModule.default;
+ const sdk = DiditSdk.shared;
+
+ sdk.onComplete = (result: {
+ type: string;
+ session?: { sessionId?: string; status?: string };
+ error?: { message?: string };
+ }) => {
+ setLoading(false);
+ if (result.type === 'completed' && result.session) {
+ setError(null);
+ onSuccess?.(result.session);
+ } else if (result.type === 'failed' && result.error) {
+ setError(result.error.message ?? 'Verification failed');
+ onError?.({ message: result.error.message });
+ } else if (result.type === 'cancelled') {
+ onCancel?.();
+ }
+ };
+
+ await sdk.startVerification({ url: verification_url });
+ } catch (e) {
+ const message =
+ e instanceof Error ? e.message : 'Failed to start verification';
+ const error = e instanceof Error ? e : new Error(message);
+ setError(message);
+ setLoading(false);
+ onError?.(error);
+ }
+ };
+
+ return (
+
+
+ Identity verification
+
+ Verify your identity with Didit for KYC and compliance. Your data is
+ processed securely.
+
+
+
+ {status && config ? (
+ {
+ onVerificationComplete?.();
+ }}
+ />
+ {isLocalhost() && (
+
+
+ );
+}
diff --git a/components/hackathons/HackathonsPage.tsx b/components/hackathons/HackathonsPage.tsx
index 9259882fc..34f6dbffd 100644
--- a/components/hackathons/HackathonsPage.tsx
+++ b/components/hackathons/HackathonsPage.tsx
@@ -1,14 +1,15 @@
'use client';
-import React from 'react';
+import React, { useState } from 'react';
import HackathonCard from '@/components/landing-page/hackathon/HackathonCard';
import HackathonsFiltersHeader from '@/components/hackathons/HackathonsFiltersHeader';
import LoadingSpinner from '@/components/LoadingSpinner';
import { useHackathonFilters } from '@/hooks/hackathon/use-hackathon-filters';
import { useHackathonsList } from '@/hooks/hackathon/use-hackathons-list';
import { useHackathonTransform } from '@/hooks/hackathon/use-hackathon-transform';
+import { useInfiniteScroll } from '@/hooks/use-infinite-scroll';
import { BoundlessButton } from '../buttons';
-import { ArrowDownIcon, XIcon } from 'lucide-react';
+import { XIcon } from 'lucide-react';
import LoadingScreen from '@/features/projects/components/CreateProjectModal/LoadingScreen';
import EmptyState from '@/components/EmptyState';
@@ -16,9 +17,7 @@ interface HackathonsPageProps {
className?: string;
}
-export default function HackathonsPage({
- className,
-}: HackathonsPageProps = {}) {
+const HackathonsPage: React.FC = ({ className } = {}) => {
const {
filters,
handleSearch,
@@ -39,8 +38,6 @@ export default function HackathonsPage({
totalCount,
loadMore,
} = useHackathonsList({ initialFilters: filters });
-
- const { transformHackathonForCard } = useHackathonTransform();
const hackathonCards = React.useMemo(() => {
return hackathons.map(hackathon => {
return (
@@ -51,7 +48,16 @@ export default function HackathonsPage({
/>
);
});
- }, [hackathons, transformHackathonForCard]);
+ }, [hackathons]);
+
+ const [loadMoreSentinelEl, setLoadMoreSentinelRef] =
+ useState(null);
+ useInfiniteScroll(loadMoreSentinelEl, {
+ onLoadMore: loadMore,
+ hasMore,
+ loading: loadingMore,
+ rootMargin: '0px 0px 2000px 0px',
+ });
return (
+
+ {error && (
+
+ );
+}
diff --git a/components/didit/IdentityVerificationSection.tsx b/components/didit/IdentityVerificationSection.tsx
new file mode 100644
index 000000000..69bc6b7ba
--- /dev/null
+++ b/components/didit/IdentityVerificationSection.tsx
@@ -0,0 +1,121 @@
+'use client';
+
+import { DiditVerifyButton } from './DiditVerifyButton';
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { CheckCircle2, XCircle, Clock, AlertCircle } from 'lucide-react';
+import clsx from 'clsx';
+import type { GetMeResponse } from '@/lib/api/types';
+
+export type IdentityVerificationStatus =
+ | 'Approved'
+ | 'Declined'
+ | 'In Review'
+ | null
+ | undefined;
+
+export interface IdentityVerificationSectionProps {
+ user: GetMeResponse | null;
+ onVerificationComplete?: () => void;
+}
+
+const statusConfig: Record<
+ string,
+ { label: string; icon: React.ElementType; className: string }
+> = {
+ Approved: {
+ label: 'Verified',
+ icon: CheckCircle2,
+ className: 'text-emerald-500 bg-emerald-500/10 border-emerald-500/20',
+ },
+ Declined: {
+ label: 'Declined',
+ icon: XCircle,
+ className: 'text-red-500 bg-red-500/10 border-red-500/20',
+ },
+ 'In Review': {
+ label: 'In review',
+ icon: Clock,
+ className: 'text-amber-500 bg-amber-500/10 border-amber-500/20',
+ },
+};
+
+const isLocalhost = (): boolean =>
+ typeof window !== 'undefined' &&
+ (window.location.hostname === 'localhost' ||
+ window.location.hostname === '127.0.0.1');
+
+export function IdentityVerificationSection({
+ user,
+ onVerificationComplete,
+}: IdentityVerificationSectionProps) {
+ const status = user?.user
+ ?.identityVerificationStatus as IdentityVerificationStatus;
+ const verifiedAt = user?.user?.identityVerificationAt;
+ const config = status ? statusConfig[status] : null;
+ const StatusIcon = config?.icon ?? AlertCircle;
+
+ return (
+ + {error} +
+ )} +
+
+
+ {verifiedAt && status === 'Approved' && (
+
+ Verified on{' '}
+ {new Date(verifiedAt).toLocaleDateString(undefined, {
+ dateStyle: 'medium',
+ })}
+
+ )}
+
+ ) : (
+ + You have not completed identity verification yet. +
+ )} + + {(status !== 'Approved' || !status) && ( + <> ++ Using localhost? If verification is blocked by the browser, use + a tunnel (e.g. ngrok) and set your backend FRONTEND_URL or + DIDIT_CALLBACK_URL to the tunnel URL. See DIDIT_INTEGRATION.md โ + Troubleshooting. +
+ )} + + )} +
@@ -125,7 +131,7 @@ export default function HackathonsPage({
- {hasMore && (
- =
+ {
+ 'Not Started': {
+ color: 'bg-zinc-500/20 text-zinc-400',
+ label: 'Not Started',
+ },
+ 'In Progress': {
+ color: 'bg-blue-500/20 text-blue-400',
+ label: 'In Progress',
+ },
+ Submitted: { color: 'bg-green-500/20 text-green-400', label: 'Submitted' },
+ 'Under Review': {
+ color: 'bg-purple-500/20 text-purple-400',
+ label: 'Under Review',
+ },
+ 'Results Pending': {
+ color: 'bg-yellow-500/20 text-yellow-400',
+ label: 'Results Pending',
+ },
+ };
+
+export const ProgressIndicator: React.FC = ({
+ stage,
+ className,
+}) => {
+ const config = STAGE_CONFIG[stage];
+
+ return (
+
{/* Title & Tagline */}
@@ -290,17 +246,20 @@ export function HackathonBanner({
{/* Stats Row */}
-
);
-}
+};
+
+export default HackathonsPage;
diff --git a/components/hackathons/ProgressIndicator.tsx b/components/hackathons/ProgressIndicator.tsx
new file mode 100644
index 000000000..fc4fc0eec
--- /dev/null
+++ b/components/hackathons/ProgressIndicator.tsx
@@ -0,0 +1,57 @@
+'use client';
+
+import React from 'react';
+import { cn } from '@/lib/utils';
+
+export type SubmissionStage =
+ | 'Not Started'
+ | 'In Progress'
+ | 'Submitted'
+ | 'Under Review'
+ | 'Results Pending';
+
+interface ProgressIndicatorProps {
+ stage: SubmissionStage;
+ className?: string;
+}
+
+const STAGE_CONFIG: Record
+
)}
@@ -189,4 +184,6 @@ export default function HackathonsPage({
+
+ {config.label}
+
+ );
+};
diff --git a/components/hackathons/announcements/AnnouncementsTab.tsx b/components/hackathons/announcements/AnnouncementsTab.tsx
new file mode 100644
index 000000000..621b2304e
--- /dev/null
+++ b/components/hackathons/announcements/AnnouncementsTab.tsx
@@ -0,0 +1,121 @@
+'use client';
+
+import React, { useState, useMemo } from 'react';
+import { Megaphone, Pin, ArrowUpDown, ExternalLink } from 'lucide-react';
+import { cn } from '@/lib/utils';
+import type { HackathonAnnouncement } from '@/lib/api/hackathons/index';
+import Link from 'next/link';
+
+interface AnnouncementsTabProps {
+ announcements: HackathonAnnouncement[];
+ hackathonSlug: string;
+}
+
+export function AnnouncementsTab({
+ announcements,
+ hackathonSlug,
+}: AnnouncementsTabProps) {
+ const [sortBy, setSortBy] = useState<'newest' | 'oldest'>('newest');
+
+ const sortedAnnouncements = useMemo(() => {
+ return [...announcements].sort((a, b) => {
+ // Always put pinned at top
+ if (a.isPinned && !b.isPinned) return -1;
+ if (!a.isPinned && b.isPinned) return 1;
+
+ // Then sort by date
+ const dateA = new Date(a.publishedAt || a.createdAt).getTime();
+ const dateB = new Date(b.publishedAt || b.createdAt).getTime();
+
+ return sortBy === 'newest' ? dateB - dateA : dateA - dateB;
+ });
+ }, [announcements, sortBy]);
+
+ const isRecent = (date: string) => {
+ const announcementDate = new Date(date).getTime();
+ const now = new Date().getTime();
+ const diff = now - announcementDate;
+ return diff < 1000 * 60 * 60 * 24; // 24 hours
+ };
+
+ return (
+
+
+ );
+}
diff --git a/components/hackathons/hackathonBanner.tsx b/components/hackathons/hackathonBanner.tsx
index 5554031db..dcb8ccd55 100644
--- a/components/hackathons/hackathonBanner.tsx
+++ b/components/hackathons/hackathonBanner.tsx
@@ -1,14 +1,8 @@
'use client';
import { Button } from '@/components/ui/button';
import { useMemo } from 'react';
-import {
- FileText,
- Users,
- ArrowRight,
- Calendar,
- Clock,
- Trophy,
-} from 'lucide-react';
+import { FileText, Users, ArrowRight, Calendar, Trophy } from 'lucide-react';
+import { CountdownTimer } from '@/components/ui/timer';
import { useAuthStatus } from '@/hooks/use-auth';
import { useRouter, usePathname } from 'next/navigation';
import Image from 'next/image';
@@ -20,7 +14,6 @@ interface HackathonBannerProps {
tagline?: string;
deadline?: string;
startDate?: string;
- endDate?: string;
categories?: string[];
status?: string;
participants?: number;
@@ -29,10 +22,6 @@ interface HackathonBannerProps {
hasSubmitted?: boolean;
isEnded?: boolean;
isTeamFormationEnabled?: boolean;
- registrationDeadlinePolicy?:
- | 'BEFORE_START'
- | 'BEFORE_SUBMISSION_DEADLINE'
- | 'CUSTOM';
registrationDeadline?: string;
onJoinClick?: () => void;
onSubmitClick?: () => void;
@@ -40,6 +29,7 @@ interface HackathonBannerProps {
onFindTeamClick?: () => void;
onLeaveClick?: () => void;
isLeaving?: boolean;
+ participantType?: 'INDIVIDUAL' | 'TEAM' | 'TEAM_OR_INDIVIDUAL';
}
export function HackathonBanner({
@@ -53,9 +43,9 @@ export function HackathonBanner({
isRegistered = false,
hasSubmitted = false,
isTeamFormationEnabled = false,
- registrationDeadlinePolicy,
registrationDeadline,
isLeaving,
+ participantType,
onJoinClick,
onSubmitClick,
onViewSubmissionClick,
@@ -73,61 +63,17 @@ export function HackathonBanner({
// Determine if registration is allowed
const canRegister = useMemo(() => {
const now = new Date();
- const policy = registrationDeadlinePolicy || 'BEFORE_SUBMISSION_DEADLINE';
-
- switch (policy) {
- case 'BEFORE_START':
- if (startDate) {
- return now < new Date(startDate);
- }
- return false;
- case 'BEFORE_SUBMISSION_DEADLINE':
- if (deadline) {
- return now < new Date(deadline);
- }
- return false;
- case 'CUSTOM':
- if (registrationDeadline) {
- return now < new Date(registrationDeadline);
- }
- return false;
- default:
- return false;
- }
- }, [registrationDeadlinePolicy, startDate, deadline, registrationDeadline]);
+ const effectiveDeadline = registrationDeadline || deadline;
+ return effectiveDeadline ? now < new Date(effectiveDeadline) : false;
+ }, [registrationDeadline, deadline]);
// Get appropriate register button text
const getRegisterButtonText = useMemo(() => {
if (!canRegister) return null;
-
const now = new Date();
const isBeforeStart = startDate && now < new Date(startDate);
-
- switch (registrationDeadlinePolicy || 'BEFORE_SUBMISSION_DEADLINE') {
- case 'BEFORE_START':
- return 'Register Before Start';
- case 'BEFORE_SUBMISSION_DEADLINE':
- return isBeforeStart ? 'Early Register' : 'Join Hackathon';
- case 'CUSTOM':
- if (registrationDeadline) {
- const customDeadline = new Date(registrationDeadline);
- const isBeforeCustomDeadline = now < customDeadline;
- if (isBeforeStart && isBeforeCustomDeadline) {
- return 'Register Interest';
- } else if (!isBeforeStart && isBeforeCustomDeadline) {
- return 'Late Register';
- }
- }
- return 'Register Now';
- default:
- return 'Join Hackathon';
- }
- }, [
- registrationDeadlinePolicy,
- canRegister,
- startDate,
- registrationDeadline,
- ]);
+ return isBeforeStart ? 'Early Register' : 'Join Hackathon';
+ }, [canRegister, startDate]);
// Redirect to auth screen
const handleRedirectToAuthScreen = () => {
@@ -259,6 +205,16 @@ export function HackathonBanner({
{getStatusText()}
+ {participantType && (
+ <>
+
+
+ {participantType === 'TEAM_OR_INDIVIDUAL'
+ ? 'Hybrid'
+ : participantType.toLowerCase()}
+
+
+ )}
+
+
+
+
+
+
+ Announcements
+ + {announcements.length} + +
+ {sortedAnnouncements.map(announcement => (
+
+ {isRecent(announcement.publishedAt || announcement.createdAt) && (
+
+
+ New
+
+ )}
+
+
+
+
+ ))}
+
+
+
+
+ {announcement.isPinned && (
+
+
+ + {announcement.title} +
++ {announcement.content.replace(/<[^>]*>/g, '')} +
+ +
+
+ {new Date(
+ announcement.publishedAt || announcement.createdAt
+ ).toLocaleDateString(undefined, {
+ month: 'short',
+ day: 'numeric',
+ year: 'numeric',
+ })}
+
+ โข
+ By {announcement.author?.name || 'Organizer'}
+
+
+
+
{/* Countdown Timer */}
- {timeRemaining.total > 0 && (
+ {(status === 'ongoing' || status === 'upcoming') && (
-
-
- {formatCountdown(timeRemaining)}
-
+
-
- {tabs.map(tab => {
- const isActive = activeTab === tab.id;
- return (
-
+ );
+ })}
+
+
-
- {/* Image Section - UNCHANGED */}
+
{imageUrl && (
)}
- {/* Countdown Timer */}
- {/* {timeRemaining.total > 0 && (
-
-
- )} */}
+ {/* Participation Type Section */}
+ {participantType && (
+
- {status === "ongoing" ? "Ends In" : "Starts In"}
-
-
- {formatCountdown(timeRemaining)}
-
-
+
+ )}
+
+ {/* TODO: Add countdown UI โ implement timeRemaining calculation and formatCountdown helper, then render "Ends In" / "Starts In" with formatted time */}
{/* Date Info Section */}
+
+
+ {participantType === 'TEAM_OR_INDIVIDUAL'
+ ? 'Hybrid'
+ : participantType.toLowerCase()}
+
+
@@ -218,10 +188,20 @@ export function HackathonStickyCard(props: HackathonStickyCardProps) {
{/* Action Buttons */}
{/* Register / Leave Button */}
- {!isRegistered ? (
+ {status === 'ended' ? (
+
+ ) : !isRegistered ? (
canRegister ? (