be-components 7.4.8 → 7.5.1

package/src/BetRouter/index.tsx

@@ -0,0 +1,453 @@
+import React, { useEffect, useState } from 'react';
+import { View } from "../Components/Themed";
+import { BetRouterApi } from './api';
+import type {
+    RouterMarketProps,
+    RouterMarketSideProps,
+    RouterMarketVariableProps,
+    RouterContestProps,
+    RouterLeagueProps,
+    RouterPartnerProps,
+    PartnerMarketProps,
+    BuyOpportunity
+} from './types';
+import type { MyPlayerProps, GetContestResponse } from '../types';
+import { Modal } from 'react-native';
+import AdminPortal from './components/AdminPortal';
+import DesktopLayout from './layouts/DesktopLayout';
+import MobileLayout from './layouts/MobileLayout';
+
+type BetRouterProps = {
+    me: MyPlayerProps;
+    insets: { top: number; bottom: number; left: number; right: number };
+};
+
+// ========== Consolidated State Types ==========
+type UIState = {
+    size: { width: number; height: number };
+    showAdminPortal: boolean;
+    adminPortalInitialContestId?: string;
+    adminPortalInitialLeagueId?: string;
+};
+
+type LeagueState = {
+    leagues: RouterLeagueProps[];
+    selectedLeague: RouterLeagueProps | null;
+    loading: boolean;
+};
+
+type ContestState = {
+    contests: RouterContestProps[];
+    filteredContests: RouterContestProps[];
+    selectedContest: RouterContestProps | null;
+    contestDetails: GetContestResponse | undefined;
+    searchValue: string;
+    selectedDate: string | null;
+    offset: number;
+    loading: boolean;
+};
+
+type OpportunityState = {
+    router_contests: RouterContestProps[];
+    contests_processed: number;
+    total_liquidity_count: number;
+    total_opportunities: number;
+    partner_markets: PartnerMarketProps[];
+    router_market_variables: RouterMarketVariableProps[];
+    router_markets: RouterMarketProps[];
+    router_market_sides: RouterMarketSideProps[];
+    partners: RouterPartnerProps[];
+    opportunities: BuyOpportunity[];
+    loading: boolean;
+};
+
+type PartnerState = {
+    partners: RouterPartnerProps[];
+    loading: boolean;
+};
+
+type MarketState = {
+    router_markets: RouterMarketProps[];
+    router_market_sides: RouterMarketSideProps[];
+    router_market_variables: RouterMarketVariableProps[];
+    loading: boolean;
+};
+
+const BetRouter = ({ me, insets }: BetRouterProps) => {
+    // ========== Consolidated State ==========
+    const [uiState, setUIState] = useState<UIState>({
+        size: { width: 0, height: 0 },
+        showAdminPortal: false
+    });
+
+    const [leagueState, setLeagueState] = useState<LeagueState>({
+        leagues: [],
+        selectedLeague: null,
+        loading: false
+    });
+
+    const [contestState, setContestState] = useState<ContestState>({
+        contests: [],
+        filteredContests: [],
+        selectedContest: null,
+        contestDetails: undefined,
+        searchValue: '',
+        selectedDate: null,
+        offset: 0,
+        loading: false
+    });
+
+    const [opportunityState, setOpportunityState] = useState<OpportunityState>({
+        router_contests: [],
+        contests_processed: 0,
+        total_liquidity_count: 0,
+        total_opportunities: 0,
+        partner_markets: [],
+        router_market_variables: [],
+        router_markets: [],
+        router_market_sides: [],
+        partners: [],
+        opportunities: [],
+        loading: false
+    });
+
+    const [partnerState, setPartnerState] = useState<PartnerState>({
+        partners: [],
+        loading: false
+    });
+
+    const [_, setMarketState] = useState<MarketState>({
+        router_markets: [],
+        router_market_sides: [],
+        router_market_variables: [],
+        loading: false
+    });
+
+    // ========== Computed Values ==========
+    //const isMobile = uiState.size.width <= 768;
+    const isDesktop = uiState.size.width > 768;
+
+    // ========== Initialization ==========
+    useEffect(() => {
+        BetRouterApi.setEnvironment();
+        if (!me?.player_id) return;
+
+        // Load all initial data in parallel
+        Promise.all([
+            loadPartners(),
+            loadLeagues(),
+            loadMarkets(),
+            loadMarketSides(),
+            loadMarketVariables(),
+            loadOpportunities()
+        ]);
+    }, [me?.player_id]);
+
+    // ========== Load contests when league changes ==========
+    useEffect(() => {
+        if (leagueState.selectedLeague) {
+            loadContests();
+        }
+    }, [leagueState.selectedLeague]);
+
+    // ========== Filter contests when search/date changes ==========
+    useEffect(() => {
+        filterContests();
+    }, [contestState.contests, contestState.searchValue, contestState.selectedDate]);
+
+    // ========== Data Loading Functions ==========
+    const loadPartners = async () => {
+        try {
+            setPartnerState(prev => ({ ...prev, loading: true }));
+            const data = await BetRouterApi.BetRouter.PartnerApi.getPartners();
+            setPartnerState({
+                partners: data,
+                loading: false
+            });
+        } catch (error) {
+            console.error('Error loading partners:', error);
+            setPartnerState(prev => ({ ...prev, loading: false }));
+        }
+    };
+
+    const loadLeagues = async () => {
+        try {
+            setLeagueState(prev => ({ ...prev, loading: true }));
+            const data = await BetRouterApi.BetRouter.LeagueApi.getLeagues('active');
+            setLeagueState(prev => ({
+                ...prev,
+                leagues: data,
+                loading: false
+            }));
+        } catch (error) {
+            console.error('Error loading leagues:', error);
+            setLeagueState(prev => ({ ...prev, loading: false }));
+        }
+    };
+
+    const loadContests = async () => {
+        if (!leagueState.selectedLeague) return;
+
+        try {
+            setContestState(prev => ({ ...prev, loading: true }));
+            const contestData = await BetRouterApi.BetRouter.ContestApi.getRouterContests('open');
+
+            // Filter contests by selected league
+            const leagueContests = contestData.filter(
+                c => c.router_league_id === leagueState.selectedLeague!.router_league_id
+            );
+
+            // Sort by scheduled datetime
+            leagueContests.sort((a, b) => {
+                const dateA = new Date(a.scheduled_datetime).getTime();
+                const dateB = new Date(b.scheduled_datetime).getTime();
+                return dateA - dateB;
+            });
+
+            setContestState(prev => ({
+                ...prev,
+                contests: leagueContests,
+                loading: false
+            }));
+        } catch (error) {
+            console.error('Error loading contests:', error);
+            setContestState(prev => ({ ...prev, loading: false }));
+        }
+    };
+
+    const loadContestDetails = async (contest: RouterContestProps) => {
+        try {
+            setContestState(prev => ({
+                ...prev,
+                selectedContest: contest,
+                loading: true
+            }));
+
+            const details = await BetRouterApi.BetRouter.ContestApi.getContest(
+                contest.router_contest_id
+            );
+
+            setContestState(prev => ({
+                ...prev as any,
+                contestDetails: details,
+                loading: false
+            }));
+        } catch (error) {
+            console.error('Error loading contest details:', error);
+            setContestState(prev => ({ ...prev, loading: false }));
+        }
+    };
+
+    const filterContests = () => {
+        let filtered = [...contestState.contests];
+
+        // Filter by search
+        if (contestState.searchValue) {
+            filtered = filtered.filter(c =>
+                c.contest_label.toLowerCase().includes(contestState.searchValue.toLowerCase())
+            );
+        }
+
+        // Filter by date
+        if (contestState.selectedDate) {
+            filtered = filtered.filter(c => {
+                const contestDate = new Date(c.scheduled_datetime).toISOString().split('T')[0];
+                return contestDate === contestState.selectedDate;
+            });
+        }
+
+        setContestState(prev => ({ ...prev, filteredContests: filtered }));
+    };
+
+    const loadMarkets = async () => {
+        try {
+            setMarketState(prev => ({ ...prev, loading: true }));
+            const data = await BetRouterApi.BetRouter.MarketApi.getRouterMarkets();
+            setMarketState(prev => ({
+                ...prev,
+                router_markets: data,
+                loading: false
+            }));
+        } catch (error) {
+            console.error('Error loading markets:', error);
+            setMarketState(prev => ({ ...prev, loading: false }));
+        }
+    };
+
+    const loadMarketSides = async () => {
+        try {
+            const data = await BetRouterApi.BetRouter.MarketApi.getMarketSides();
+            setMarketState(prev => ({
+                ...prev,
+                router_market_sides: data
+            }));
+        } catch (error) {
+            console.error('Error loading market sides:', error);
+        }
+    };
+
+    const loadMarketVariables = async () => {
+        try {
+            const data = await BetRouterApi.BetRouter.MarketApi.getMarketVariables();
+            setMarketState(prev => ({
+                ...prev,
+                router_market_variables: data
+            }));
+        } catch (error) {
+            console.error('Error loading market variables:', error);
+        }
+    };
+
+    const loadOpportunities = async () => {
+        try {
+            setOpportunityState(prev => ({ ...prev, loading: true }));
+            const data = await BetRouterApi.BetRouter.LiquidityApi.getAllOpportunities();
+            setOpportunityState({
+                router_contests: data.router_contests || [],
+                contests_processed: data.contests_processed || 0,
+                total_liquidity_count: data.total_liquidity_count || 0,
+                total_opportunities: data.total_opportunities || 0,
+                partner_markets: data.partner_markets || [],
+                router_market_variables: data.router_market_variables || [],
+                router_markets: data.router_markets || [],
+                router_market_sides: data.router_market_sides || [],
+                partners: data.partners || [],
+                opportunities: data.opportunities || [],
+                loading: false
+            });
+            setTimeout(() => {
+                //loadOpportunities()
+            }, 20000);
+        } catch (error) {
+            console.error('Error loading opportunities:', error);
+            setOpportunityState(prev => ({ ...prev, loading: false }));
+        }
+    };
+
+    // ========== UI Actions ==========
+    const handleSelectContest = (contest: RouterContestProps | null) => {
+        if (contest) {
+            loadContestDetails(contest);
+        } else {
+            setContestState(prev => ({
+                ...prev,
+                selectedContest: null,
+                contestDetails: undefined
+            }));
+        }
+    };
+
+    const handleOpenAdminPortal = (initialContestId?: string, initialLeagueId?: string) => {
+        setUIState(prev => ({
+            ...prev,
+            showAdminPortal: true,
+            adminPortalInitialContestId: initialContestId,
+            adminPortalInitialLeagueId: initialLeagueId
+        }));
+    };
+
+    const handleCloseAdminPortal = () => {
+        setUIState(prev => ({
+            ...prev,
+            showAdminPortal: false,
+            adminPortalInitialContestId: undefined,
+            adminPortalInitialLeagueId: undefined
+        }));
+    };
+
+    const handleBuyOpportunity = async (opportunity: BuyOpportunity, legIndex?: number) => {
+        console.log(opportunity, legIndex)
+        // BuyOpportunities component handles the actual buying and UI feedback
+        // This handler is just called to refresh data after successful buy
+        try {
+            // Reload opportunities to get updated data
+            await loadOpportunities();
+        } catch (error) {
+            console.error('Error reloading opportunities:', error);
+        }
+    };
+
+    // ========== Render ==========
+    return (
+        <View
+            style={{ flex: 1 }}
+            onLayout={(ev) => {
+                const { height, width } = ev.nativeEvent.layout;
+                setUIState(prev => ({ ...prev, size: { height, width } }));
+            }}
+        >
+            {isDesktop ? (
+                <DesktopLayout
+                    me={me}
+                    partners={partnerState.partners}
+                    leagues={leagueState.leagues}
+                    selectedLeague={leagueState.selectedLeague}
+                    contests={contestState.contests}
+                    filteredContests={contestState.filteredContests}
+                    selectedContest={contestState.selectedContest}
+                    contestDetails={contestState.contestDetails}
+                    opportunities={opportunityState}
+                    opps_loading={opportunityState.loading}
+                    size={uiState.size}
+                    insets={insets}
+                    onSelectLeague={(league) => setLeagueState(prev => ({ ...prev, selectedLeague: league }))}
+                    onSelectContest={handleSelectContest}
+                    onOpenAdminPortal={handleOpenAdminPortal}
+                    onBuyOpportunity={handleBuyOpportunity}
+                    onRefreshOpportunities={loadOpportunities}
+                />
+            ) : (
+                <MobileLayout
+                    me={me}
+                    partners={partnerState.partners}
+                    leagues={leagueState.leagues}
+                    selectedLeague={leagueState.selectedLeague}
+                    contests={contestState.contests}
+                    filteredContests={contestState.filteredContests}
+                    selectedContest={contestState.selectedContest}
+                    contestDetails={contestState.contestDetails}
+                    opportunities={opportunityState}
+                    opps_loading={opportunityState.loading}
+                    size={uiState.size}
+                    insets={insets}
+                    onSelectLeague={(league) => setLeagueState(prev => ({ ...prev, selectedLeague: league }))}
+                    onSelectContest={handleSelectContest}
+                    onOpenAdminPortal={handleOpenAdminPortal}
+                    onBuyOpportunity={handleBuyOpportunity}
+                    onRefreshOpportunities={loadOpportunities}
+                />
+            )}
+
+            {/* Admin Portal Modal - Works for both desktop and mobile */}
+            {uiState.showAdminPortal && (
+                <Modal
+                    visible={uiState.showAdminPortal}
+                    transparent={true}
+                    animationType="fade"
+                    onRequestClose={handleCloseAdminPortal}
+                    statusBarTranslucent={true}
+                >
+                    <View style={{
+                        flex: 1,
+                        backgroundColor: 'rgba(0,0,0,0.5)'
+                    }}>
+                        <View float style={{
+                            flex: 1,
+                            overflow: 'hidden'
+                        }}>
+                            <AdminPortal
+                                insets={insets}
+                                onClose={handleCloseAdminPortal}
+                                initialContestId={uiState.adminPortalInitialContestId}
+                                initialLeagueId={uiState.adminPortalInitialLeagueId}
+                            />
+                        </View>
+                    </View>
+                </Modal>
+            )}
+        </View>
+    );
+};
+
+export default BetRouter;
+export { AdminPortal };