be-components 5.5.0 → 5.5.1

package/src/GolfScoreboard/index.tsx

@@ -4,7 +4,7 @@ import type { AthleteProps, BestAvailableOrderProps, GolfCourseProps, GolfHolePr
 import { GolfApi, GolfHelpers } from './api';
 import { ActivityIndicator, FlatList, Image } from 'react-native';
 import { useColors } from '../constants/useColors';
-import moment from 'moment-mini';
+import moment, { type Moment } from 'moment-mini';
 import { AthleteImage } from '../Components/Jerseys';
 import { Icons, Toggle } from '../Components';
 import SearchBox from '../Components/SearchBox';
@@ -17,11 +17,12 @@ type GolfScoreboardProps = {
     tournament_id:string,
     markets:MarketProps[],
     best_available:BestAvailableOrderProps[],
-    onOrder:(order:OrderProps) => void
+    onOrder:(order:OrderProps) => void,
+    onClose:() => void
 }
 
 const scorecard_sections = ['course', 'toggle','search','leaderboard', 'open_bets', 'holes'];
-const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:GolfScoreboardProps) => {
+const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder, onClose }:GolfScoreboardProps) => {
     const Colors = useColors();
     const [ active_tab, setActiveTab ] = useState<'scorecard'|'holes'|'bets'>('scorecard');
     const [ search, setSearch ] = useState<string>('');
@@ -31,16 +32,18 @@ const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:Golf
         tournament?:TournamentProps,
         league?:LeagueProps,
         athletes:AthleteProps[],
+        prior_year?:boolean,
         golf_leaders:GolfLeaderProps[],
         golf_course?:GolfCourseProps,
         golf_statistics?:GolfTournamentStatisticsProps,
-        active_round?:number
+        active_round?:number,
+        loaded_timestamp?:Moment
     }>({
         loading:false,
         golf_leaders:[],
         athletes:[]
     });
-    const { loading, tournament, athletes, golf_leaders, golf_course, league, active_round, golf_statistics } = scorecard_state;
+    const { loading, tournament, athletes, golf_leaders, golf_course, league, active_round, golf_statistics, prior_year, loaded_timestamp } = scorecard_state;
     const [ active_leader, setActiveLeader ] = useState<string|undefined>(undefined);
     const golf_leader = golf_leaders.find(l => l.athlete_id == active_leader);
     const golf_athlete = athletes.find(a => a.athlete_id == active_leader);
@@ -53,16 +56,16 @@ const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:Golf
 
     useEffect(() => {
         GolfApi.setEnvironment();
-        getData(tournament_id)
+        getData(tournament_id, moment())
     },[tournament_id]);
 
-    const getData = async(tournament_id:string) => {
+    const getData = async(tournament_id:string, timestamp:Moment):Promise<{ golf_leaders:GolfLeaderProps[], active_round?:number } | undefined> => {
         setScorecard({ ...scorecard_state, loading:true });
         const golf_data = await GolfApi.getScoreboard(tournament_id);
         const tourney = await GolfApi.getTournamentById(tournament_id);
         const golf_stats = await GolfApi.getGolfStats(tournament_id);
         const lg = await GolfApi.getLeagueById(tourney?.league_id ?? '9');
-        if(!golf_data){ return alert('Unable to process') }
+        if(!golf_data){ return undefined }
         if(best_available.length > 0){ setActiveTab('bets') }
         setScorecard({
             ...scorecard_state,
@@ -70,11 +73,36 @@ const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:Golf
             league: lg,
             golf_course: golf_data.golf_course,
             golf_leaders: golf_data.golf_leaders,
-            golf_statistics: golf_stats,
+            golf_statistics: golf_stats?.golf_tournament_statistics,
+            prior_year: golf_stats?.prior_year,
             active_round: golf_data.active_round,
             athletes:golf_data.athletes,
+            loaded_timestamp: timestamp,
             loading: false
-        })
+        });
+        return { golf_leaders : golf_data.golf_leaders, active_round: golf_data.active_round }
+    }
+    const validateOrder = async(order:OrderProps, market:MarketProps, loaded?:Moment):Promise<boolean> => {
+        if(!market || !market.length_variable){ return false }
+        let difference = 100
+        if(loaded){
+            difference = moment().diff(loaded,'seconds')
+        }
+        if(difference > 90){
+            //We need to load the data again and confirm that the bet is valid!
+            let reloaded_data = await getData(order.event_id, moment());
+            if(!reloaded_data){ return false }
+            let leader = reloaded_data.golf_leaders.find(gl => gl.athlete_id == order.side_id);
+            if(!leader){ return false }
+            let curr_hole = GolfHelpers.getCurrentHole(leader, reloaded_data.active_round);
+            //if(curr_hole == 0){ return true }
+            let bet_hole = market.length_variable
+            let hole_buffer = bet_hole - curr_hole
+            if(hole_buffer < 2){ 
+                return false 
+            }
+        }
+        return true
     }
 
     const renderLeaders = (data:{ item:GolfLeaderProps, index:number }) => {
@@ -157,10 +185,13 @@ const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:Golf
                         locked={false}
                         order={data.item}
                         onLongPress={() => console.log('LONG PRESSED')}
-                        onPress={(order) => {
+                        onPress={async(order) => {
                             const order_title = MarketComponentHelpers.getOrderTitleForTournament(order, market, tournament, athlete);
                             if(!order_title){ return alert('Unable to process order') }
-                            onOrder({ ...order, title: order_title, league_id: tournament.league_id })
+                            let new_order = { ...order, title:order_title, league_id:tournament.league_id }
+                            const valid = await validateOrder(new_order, market, loaded_timestamp)
+                            if(!valid){ return alert('Unable to process order') }
+                            onOrder(new_order)
                         }}
                     />
                 </View>
@@ -326,11 +357,19 @@ const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:Golf
                     data={scorecard_sections}
                     key={'golf_list'}
                     refreshing={loading}
-                    onRefresh={() => getData(tournament_id)}
+                    onRefresh={() => getData(tournament_id, moment())}
                     keyExtractor={item => item}
                     renderItem={renderSections}
                 />
             </View>
+            <View type='footer' style={{ padding:10 }}>
+                <Button
+                    title='CLOSE'
+                    type='close'
+                    style={{ padding:10 }}
+                    onPress={() => onClose()}
+                />
+            </View>
             {tournament && golf_leader && golf_course && active_round && golf_athlete ?
             <LeaderBetSelector
                 golf_leader={golf_leader}
@@ -340,10 +379,17 @@ const GolfScoreboard = ({ tournament_id, markets, best_available, onOrder }:Golf
                 latest_trades={[]}
                 tournament={tournament}
                 active_round={active_round}
+                prior_year={prior_year}
                 athlete={golf_athlete}
                 golf_statistics={golf_statistics}
                 onClose={() => setActiveLeader(undefined)}
-                onOrder={onOrder}
+                onOrder={async(order) => {
+                    let market = markets.find(m => m.market_id == order.market_id);
+                    if(!market){ return alert('Unable to process') }
+                    const valid = await validateOrder(order, market, loaded_timestamp);
+                    if(!valid){ return alert('Unable to process this order') }
+                    onOrder(order)
+                }}
             />
             :<></>}
         </View>

package/src/MarketComponents/api/index.ts

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { APIOverrides } from "../../ApiOverrides"
-import type { AthleteProps, BestAvailableResponseProps, ContestStatProps, EventOrderStatProps, EventProps, ExternalPriceProps, LeagueProps, MarketProps, MarketSideOptionProps, MatchProps, OrderProps, PodcastProps, TeamProps, TournamentProps, TradeProps } from "../../types"
+import type { AthleteProps, BestAvailableOrderProps, BestAvailableResponseProps, ContestStatProps, EventOrderStatProps, EventProps, ExternalPriceProps, LeagueProps, MarketProps, MarketSideOptionProps, MatchProps, OrderProps, PodcastProps, TeamProps, TournamentProps, TradeProps } from "../../types"
 import moment from 'moment-mini';
 
 let EVENT_SVC_API = ''
@@ -217,6 +217,15 @@ const MarketComponentHelpers = {
         let open_order_count = event_order_stats.reduce((a,b) => a + parseInt(b.open_order_count as string), 0);
         return { liquidity, open_order_count }
     },
+    calcPotentialWinnings : (amt:number, odds:number):number => {
+        if (odds > 0) {
+            var earningsMultiplyer = ((odds/100) + 1);
+            return earningsMultiplyer * amt;
+        } else {
+            var earningsMultiplyer = ((100/(Math.abs(odds))) + 1);
+            return earningsMultiplyer * amt
+        }
+    },
     getVar1Label: (market:MarketProps, var_1:number, side?:string) => {
         if(side == 'over'){ return `O ${var_1}` }
         if(side == 'under'){ return `U ${var_1}` }
@@ -367,7 +376,7 @@ const MarketComponentHelpers = {
         })
         return new_title
     },
-    getOrderTitleForTournament : (order:OrderProps, market:MarketProps, tournament:TournamentProps, athlete?:AthleteProps, team?:TeamProps):string | undefined => {
+    getOrderTitleForTournament : (order:OrderProps | BestAvailableOrderProps, market:MarketProps, tournament:TournamentProps, athlete?:AthleteProps, team?:TeamProps):string | undefined => {
         if(!tournament){ return undefined }
         let market_side = market.side_options.find(o => o.side == order.side)
         if(!market_side){ return order.side }

package/src/types.d.ts

@@ -1381,6 +1381,8 @@ export interface MarketProps {
     primary_market:boolean,
     suggested?:boolean,
     var_1_required?:boolean;
+    lock_probability?:boolean,
+    max_order?:number,
     show_side_option?:boolean;
     length_variable?:number,
     resolver?:string;
@@ -2044,7 +2046,7 @@ export interface BestAvailableOrderProps {
     show?:boolean,
     potential_winnings:number,
     reversed?:boolean,
-    og_order:BestAvailableOrderProps,
+    og_order?:BestAvailableOrderProps,
     side_id:string,
     side_type:string,
     var_1:number,