be-components 7.3.6 → 7.3.8

package/src/EventComponents/api/index.ts

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { APIOverrides } from "../../ApiOverrides";
-import type { EventProps, TeamProps } from '../../types';
+import type { AthleteProps, EventProps, LeagueProps, MatchProps, TeamProps, TournamentProps } from '../../types';
 
 let EVENT_SVC_API = ''
 //let AUTH_SVC_API = ''
@@ -23,6 +23,69 @@ const EventComponentApi = {
             return undefined
         }
     },
+    getLeagues: async():Promise<LeagueProps[]> => {
+        try {
+            const resp = await axios.get(`${EVENT_SVC_API}/v1/leagues?status=active`)
+            return resp.data.leagues
+        } catch (e) {
+            return []
+        }
+    },
+    getEventsByEventIds: async(event_ids:string[]):Promise<EventProps[]> => {
+        try {
+            if(event_ids.length == 0){ return [] }
+            const resp = await axios.post(`${EVENT_SVC_API}/v1/events/bulk/get`, { attribute:'event_id', values: event_ids })
+            return resp.data.events
+        } catch (e) {
+            return []
+        }
+    },
+    getEventsByDate: async(league_id:string, date:string, timezone?:string):Promise<{day:string, days:string[], events:EventProps[]}> => {
+        try {
+            const resp = await axios.get(`${EVENT_SVC_API}/v1/events/league/date/${league_id}/${date}?timezone=${timezone}`);
+            return resp.data
+        } catch (e) {
+            return { day: date, days:[], events: [] }
+        }
+    },
+    getMatchesByMatchIds: async(match_ids:string[]):Promise<MatchProps[]> => {
+        try {
+            if(match_ids.length == 0){ return [] }
+            const resp = await axios.post(`${EVENT_SVC_API}/v1/matches/bulk/get`, { attribute: 'match_id', values: match_ids })
+            return resp.data.matches
+        } catch (e) {
+            return []
+        }
+
+    },
+    getAthletesByIds : async(athlete_ids:string[]):Promise<AthleteProps[]> => {
+        try {
+            if(athlete_ids.length == 0){ return [] }
+            const resp = await axios.post(`${EVENT_SVC_API}/v1/athletes/bulk/get`, { attribute: 'athlete_id', values: athlete_ids })
+            return resp.data.athletes
+        } catch (e) {
+            return []
+        }
+    },
+    getTournamentsByTournamentIds: async(tournament_ids:string[]):Promise<TournamentProps[]> => {
+        try {
+            if(tournament_ids.length == 0){ return [] }
+            const resp = await axios.post(`${EVENT_SVC_API}/v1/tournaments/bulk/get`, { attribute: 'event_id', values: tournament_ids })
+            return resp.data.tournaments
+        } catch (e) {
+            return []
+        }
+    },
+    getTeamsByIds: async(team_ids:string[]) => {
+        try {
+            if(team_ids.length == 0){ return [] }
+            const resp = await axios.post(`${EVENT_SVC_API}/v1/teams/bulk/get`, { attribute:'team_id', values: team_ids })
+            return resp.data.teams
+        } catch (e) {
+            return []
+        }
+
+    },
     getUpcomingScheduleByTeams: async(team_ids:string, offset:number):Promise<EventProps[]> => {
         try {
             const resp = await axios.get(`${EVENT_SVC_API}/v1/teams/schedule/upcoming/${team_ids}?offset=${offset}`)

package/src/FlashMarket/FlashHolder.tsx

@@ -14,6 +14,7 @@ type FlashHolderProps = {
     player_id?:string,
     float?:boolean,
     distinct_id?:string,
+    restricted_flash_ids?:string[],
     compact?:boolean,
     player?:MyPlayerProps,
     company_id?:string,
@@ -39,7 +40,7 @@ type FlashHolderProps = {
     onRequestAuthenticate: () => void
 }
 const sections = [ 'selector','explainer','flash_market','options','footer' ]
-const FlashHolder = ({ float, poll_campaign_id, company_id, compact, style, default_poll_id, hide_timer, distinct_id, hide_footer, no_highlight, hide_tabs, parent_style, league_id, init_expanded, player_id, player, location, contest_type, contest_id, side_type, side_id, poll_id, onSelectCompactPoll, onRequestAuthenticate, onFocusPosition, onRequestLocation, onManageFlash } : FlashHolderProps) => {
+const FlashHolder = ({ float, poll_campaign_id, restricted_flash_ids, company_id, compact, style, default_poll_id, hide_timer, distinct_id, hide_footer, no_highlight, hide_tabs, parent_style, league_id, init_expanded, player_id, player, location, contest_type, contest_id, side_type, side_id, poll_id, onSelectCompactPoll, onRequestAuthenticate, onFocusPosition, onRequestLocation, onManageFlash } : FlashHolderProps) => {
     const Colors = useColors();
     const [ needs_reload, setNeedsReload ] = useState(false);
     const [ socket_campaigns, setSocketCampaigns ] = useState<PollCampaignProps[]>([]);
@@ -78,8 +79,8 @@ const FlashHolder = ({ float, poll_campaign_id, company_id, compact, style, defa
     const { holder_loading, flash_markets, loaded } = flash_data;
     const [ active_flash_market, setActiveFlashMarket ] = useState<string | undefined>(undefined);
     const flash_market = flash_markets.find(fm => fm.poll_id == active_flash_market);
-    const sorted_flashes = flash_markets.sort((a,b) => moment(a.end_datetime).unix() - moment(b.end_datetime).unix() || parseInt(a.poll_id) - parseInt(b.poll_id))
-    
+    let sorted_flashes = flash_markets.sort((a,b) => moment(a.end_datetime).unix() - moment(b.end_datetime).unix() || parseInt(a.poll_id) - parseInt(b.poll_id))
+    if(restricted_flash_ids && restricted_flash_ids.length > 0){ sorted_flashes = sorted_flashes.filter(f => restricted_flash_ids.includes(f.poll_id)) }
     useEffect(() => {
         loadData();
     },[league_id, contest_type, contest_id, side_type, side_id, poll_id]);

package/src/FlashMarket/components/ManageFlashMarket.tsx

@@ -1,7 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import { Button, Text, TextInput, View } from "../../Components/Themed"
 import { FlatList, Image, type ViewStyle } from 'react-native';
-import type { FocusPositionProps, MyPlayerProps, PollCampaignProps, PollOptionProps, PollProps, PollSummaryProps, PublicPlayerProps } from '../../types';
+import type { EventProps, FocusPositionProps, LeagueProps, MatchProps, MyPlayerProps, PollCampaignProps, PollOptionProps, PollProps, PollSummaryProps, PublicPlayerProps, TournamentProps } from '../../types';
 import { Icons, Switch, Toggle } from '../../Components';
 import { PollApi, PollCampaignApi, PollOptionApi } from '../../Poll/api';
 import ImageUploader from '../../Components/ImageUploader';
@@ -11,6 +11,9 @@ import moment from 'moment-mini';
 import BETimePicker from '../../Components/BETimePicker';
 import { FlashMarketHelpers } from '../api';
 import { showConfirmAlert } from '../../Components/ConfirmAlert';
+import { MarketComponentApi, MarketComponentHelpers } from '../../MarketComponents/api';
+import ContestSelector from '../../CompetitionManager/components/ContestSelector';
+import { ManageCompetitionApi } from '../../CompetitionManager/api';
 
 type ManageFlashMarketProps = {
     poll_id:string,
@@ -22,7 +25,7 @@ type ManageFlashMarketProps = {
     onFocusPosition?:(pos:FocusPositionProps) => void
 }
 
-const sections = ['header','activate','pause_resume','closed','resolve','toggle', 'image','question','options','settings','results', 'danger']
+const sections = ['header','activate','pause_resume','closed','resolve','toggle', 'image','question','options','settings', 'contest_selector','results', 'danger']
 const ManageFlashMarket = ({ float, header_style, player, onClose, poll_id, onFocusPosition }:ManageFlashMarketProps) => {
     const Colors = useColors();
     const [ labels, setLabels ] = useState({
@@ -31,6 +34,17 @@ const ManageFlashMarket = ({ float, header_style, player, onClose, poll_id, onFo
         max_stake: '0'
     });
     const { min_stake, max_stake, base_stake } = labels;
+    const [ contest_state, setContestState ] = useState<{
+        contest_selector:boolean,
+        leagues:LeagueProps[],
+        event?:EventProps,
+        tournament?:TournamentProps,
+        match?:MatchProps,
+    }>({
+        contest_selector: false,
+        leagues:[]
+    });
+    const { event, tournament, match, leagues } = contest_state;
     const [ expand_participants, setExpandParticipants ] = useState(false);
     const [ flash_state, setFlashState ] = useState<{
         loading:boolean,
@@ -59,8 +73,11 @@ const ManageFlashMarket = ({ float, header_style, player, onClose, poll_id, onFo
     const prob_locked = unlocked_options.length <= 1 ? true : false
     const errors = FlashMarketHelpers.isNewValid(real_options, poll_summaries, poll);
     const winning_option = real_options.find(o => o.poll_option_id == poll?.winning_option_id);
+
     useEffect(() => {
         PollCampaignApi.setEnvironment();
+        ManageCompetitionApi.setEnvironment();
+        MarketComponentApi.setEnvironment();
         if(!poll_id){ return }
         getData(poll_id);
     },[poll_id]);
@@ -74,6 +91,35 @@ const ManageFlashMarket = ({ float, header_style, player, onClose, poll_id, onFo
             s.player_ids.map(id => id != '4985' ? player_ids.push(id) : console.log(''))
         })
         const server_players = await PollCampaignApi.getPlayersByPlayerIds([ ...new Set(player_ids.map(id => id))]);
+        const s_leagues = await MarketComponentApi.getLeagues();
+        let ev:EventProps|undefined = undefined
+        let tn:TournamentProps|undefined = undefined
+        let mt:MatchProps|undefined = undefined
+        switch(server_response.poll.contest_type){
+            case 'team':
+                if(!server_response.poll.contest_id){ break }
+                let evs = await MarketComponentApi.getEventsByEventIds([server_response.poll.contest_id]);
+                ev = evs[0]
+                break
+            case 'tournament':
+                if(!server_response.poll.contest_id){ break }
+                let tns = await MarketComponentApi.getTournamentsByTournamentIds([server_response.poll.contest_id]);
+                tn = tns[0]
+                break
+            case 'match':
+                if(!server_response.poll.contest_id){ break }
+                let mtchs = await MarketComponentApi.getMatchesByMatchIds([server_response.poll.contest_id]);
+                mt = mtchs[0]
+                break
+            default: break
+        }
+        setContestState({
+            ...contest_state,
+            event: ev,
+            tournament: tn,
+            leagues: s_leagues.filter(l => l.status == 'active').sort((a,b) => a.priority - b.priority),
+            match: mt
+        })
         setFlashState({
             ...flash_state,
             poll: server_response.poll,
@@ -608,6 +654,40 @@ const ManageFlashMarket = ({ float, header_style, player, onClose, poll_id, onFo
                         :<></>}
                     </View>
                 )
+            case 'contest_selector':
+                if(!poll){ return <></> }
+                if(active_step != 'settings'){ return <></> }
+                const { contest_title, scheduled_datetime } = MarketComponentHelpers.getContestDetails(poll.contest_type ?? 'tean', event, tournament, match);
+                return (
+                    <View transparent style={{ padding:20, borderBottomWidth:1, borderColor:Colors.borders.light }}>
+                        <Text theme='h1'>Select Contest</Text>
+                        <Text theme='description' style={{ marginTop:3 }}>Is this market associated with an existing contest?</Text>
+                        <View transparent style={{ flexDirection:'row', alignItems:'center' }}>
+                            <Button float style={{ flex:1, marginTop:10, padding:10 }} onPress={() => setContestState({ ...contest_state, contest_selector:!contest_state.contest_selector })}>
+                                {contest_title ?
+                                <View transparent>
+                                    <Text theme='h1'>{contest_title}</Text>
+                                    <Text theme='description' style={{ marginTop:3 }}>{scheduled_datetime.format('MMM DD hh:mm a')}</Text>
+                                </View>
+                                :
+                                <Text theme='h1'>{'Select Contest'}</Text>
+                                }
+                            </Button>
+                            {poll.contest_id ?
+                            <Button
+                                title='X'
+                                transparent
+                                style={{ padding:10 }}
+                                title_color={Colors.text.error}
+                                onPress={() => {
+                                    setContestState({ ...contest_state, event: undefined })
+                                    updatePoll({ ...poll, contest_type: undefined, contest_id: undefined });
+                                }}
+                            />
+                            :<></>}
+                        </View>
+                    </View>
+                )
             case 'options':
                 if(!poll){ return <></> }
                 if(active_step != 'options'){ return <></> }
@@ -801,6 +881,43 @@ const ManageFlashMarket = ({ float, header_style, player, onClose, poll_id, onFo
                     renderItem={renderSections}
                 />
             </View>
+            {contest_state.contest_selector ?
+            <View type='blur' style={{ position:'absolute', top:0, left:0, right:0, bottom:0, padding:10 }}>
+                <ContestSelector
+                    leagues={leagues}
+                    action_loading={action_loading}
+                    onClose={() => setContestState({ ...contest_state, contest_selector: false })}
+                    onSelectTeamEvent={(event) => {
+                        if(!poll){ return }
+                        let new_end_time = moment(event.scheduled_datetime)
+                        let new_poll:PollProps = { ...poll, contest_type: 'team', contest_id: event.event_id }
+                        if(moment().isBefore(new_end_time)){ new_poll.end_datetime = new_end_time }
+                        updatePoll(new_poll)
+                        setContestState({ ...contest_state, event: event })
+                    }}
+                    onDeSelectTournament={(_) => {
+                        if(!poll){ return }
+                        setContestState({ ...contest_state, event: undefined, tournament: undefined })
+                        updatePoll({ ...poll, contest_type: undefined, contest_id: undefined });
+                    }}
+                    onSelectTournament={(t) => {
+                        if(!poll){ return }
+                        let new_end_time = moment(t.scheduled_datetime)
+                        let new_poll:PollProps = { ...poll, contest_type: 'tournament', contest_id: t.tournament_id }
+                        if(moment().isBefore(new_end_time)){ new_poll.end_datetime = new_end_time }
+                        updatePoll(new_poll)
+                        setContestState({ ...contest_state, tournament: t, event:undefined })
+                    }}
+                    onDeselectTeamEvent={(_) => {
+                        if(!poll){ return }
+                        setContestState({ ...contest_state, event: undefined })
+                        updatePoll({ ...poll, contest_type: undefined, contest_id: undefined });
+                    }}
+                    selected_tournaments={tournament ? [tournament] : []}
+                    selected_team_events={event ? [event] : []}
+                />
+            </View>
+            :<></>}
             {poll && poll.status == 'inactive' ?
             <View type='blur' style={{ position:'absolute', top:0, left:0, right:0, bottom:0, justifyContent:'center', alignItems:'center' }}>
                 <View float style={{ width: '70%' }}>

package/src/Group/index.tsx

@@ -262,7 +262,7 @@ const GroupComponent = ({ refresh_key, group_id, player, mode, init_invite_code,
         let my_gp = g_data.my_group_player && g_data.my_group_player.status == 'inactive' ? undefined : g_data.my_group_player
         
         let server_flash = await GroupApi.getActivePolls(group_id);
-        setFlashData({ flash_campaigns: server_flash.poll_campaigns, flash_markets: server_flash.polls.filter(p => p.status != 'pending') });
+        setFlashData({ flash_campaigns: server_flash.poll_campaigns, flash_markets: server_flash.polls.filter(p => !['pending','closed'].includes(p.status)) });
 
         setGroupData({
             ...group_data,
@@ -546,6 +546,7 @@ const GroupComponent = ({ refresh_key, group_id, player, mode, init_invite_code,
                 )
             case 'flash':
                 if(flash_campaigns.length == 0){ return <></> }
+                if(flash_markets.length == 0){ return <></> }
                 return (
                     <View float style={{ margin:10 }}>
                         <Button style={{ backgroundColor:Colors.views.header, flexDirection:'row', alignItems:'center', padding:10, borderBottomLeftRadius:expanded?0:8, borderBottomRightRadius:expanded?0:8 }} onPress={() => setFlashData({ ...flash_data, expanded: !expanded })}>

package/src/MarketComponents/api/index.ts

@@ -266,7 +266,6 @@ const MarketComponentApi = {
     },
     getTeamById: async(team_id:string):Promise<undefined | { team:TeamProps, team_rankings:TeamRankingProps[], team_records:TeamRecordProps[], league:LeagueProps }> => {
         try {
-            console.log('getting data')
             const resp = await axios.get(`${EVENT_SVC_API}/v1/teams/team/${team_id}`);
             return resp.data
         } catch (e) {
@@ -486,18 +485,18 @@ const MarketComponentHelpers = {
         });
         return order_ids
     },
-    getContestDetails: (contest_type:string, event?:EventProps, tournament?:TournamentProps, match?:MatchProps):{ contest_title:string } => {
+    getContestDetails: (contest_type:string, event?:EventProps, tournament?:TournamentProps, match?:MatchProps):{ contest_title:string, scheduled_datetime:Moment } => {
         switch(contest_type){
             case 'team':
-                if(!event){ return { contest_title: '' } }
-                return { contest_title: event.event_title }
+                if(!event){ return { contest_title: '', scheduled_datetime: moment() } }
+                return { contest_title: event.event_title, scheduled_datetime: moment(event.scheduled_datetime) }
             case 'tournament':
-                if(!tournament){ return { contest_title: '' } }
-                return { contest_title: tournament.tournament_name }
+                if(!tournament){ return { contest_title: '', scheduled_datetime: moment() } }
+                return { contest_title: tournament.tournament_name, scheduled_datetime: moment(tournament.scheduled_datetime) }
             case 'match':
-                if(!match){ return { contest_title: '' } }
-                return { contest_title: match.match_title }
-            default: return { contest_title: '' }
+                if(!match){ return { contest_title: '', scheduled_datetime: moment() } }
+                return { contest_title: match.match_title, scheduled_datetime: moment(match.scheduled_datetime) }
+            default: return { contest_title: '', scheduled_datetime: moment() }
         }
     },
     getReconFromMarketStats: (ms:MarketStatsProps[]) => {