be-components 7.3.9 → 7.4.2

package/src/MyAction/api/index.ts

@@ -0,0 +1,393 @@
+import moment, { type Moment } from "moment-mini";
+import { APIOverrides } from "../../ApiOverrides";
+import type { ActionListProps, AthleteProps, BracketCompetitionProps, CompetitionPayoutTypeProps, CompetitionPlayerBracketProps, CompetitionPlayerProps, CompetitionProps, CompetitionRecordProps, CompetitionResultProps, CompetitionResultTypeProps, CompetitionSeasonPlayerProps, CompetitionSeasonProps, CompetitionSeasonResultProps, CompetitionTypeProps, EventProps, LeagueProps, MatchProps, OrderProps, OrderStatsProps, ParlayPositionProps, ParlayProps, PlayerBracketProps, PollOptionProps, PollProps, PollResponseProps, SquaresCompetitionProps, TeamProps, TournamentProps } from "../../types";
+import axios from 'axios';
+import { MarketComponentHelpers } from "../../MarketComponents/api";
+
+
+let EVENT_SVC_API = '';
+let MK_SVC_API = '';
+let AUTH_SVC_API = '';
+let TP_SVC_API = '';
+
+export const MyActionApi = {
+    setEnvironment: () => {
+        const endpoints = APIOverrides.getEndpoints();
+        EVENT_SVC_API = endpoints['EVENT_SVC_API'] as string;
+        MK_SVC_API = endpoints['MK_SVC_API'] as string;
+        AUTH_SVC_API = endpoints['AUTH_SVC_API'] as string;
+        TP_SVC_API = endpoints['TP_SVC_API'] as string;
+    },
+    ContestApi: {
+        getLeagues:async():Promise<LeagueProps[]> => {
+            try {
+                const resp = await axios.get(`${EVENT_SVC_API}/v1/leagues`);
+                return resp.data.leagues
+            } catch (e) {
+                return []
+            }
+        },
+        getTournamentsByIds: 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:'tournament_id', values: tournament_ids });
+                return resp.data.tournaments
+            } catch (e) {
+                return []
+            }
+        },
+        getEventsByIds: 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 []
+            }
+        },
+        getMatchesByIds: 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 []
+            }
+        },
+        getMatchesByTournamentId: async(tournament_id:string):Promise<MatchProps[]> => {
+            try {
+                const resp = await axios.get(`${EVENT_SVC_API}/v1/matches/tournament/${tournament_id}`);
+                return resp.data.matches
+            } catch (e) {
+                return []
+            }
+        },
+        getAthletesByIds : async(athlete_ids:string[]):Promise<AthleteProps[]> => {
+            if(athlete_ids.length == 0){ return [] }
+            try {
+                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 []
+            }
+        },
+        getTeamsByIds: async(team_ids:string[]):Promise<TeamProps[]> => {
+            if(team_ids.length == 0){ return [] }
+            try {
+                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 []
+            }
+        },
+    },
+    OrderApi: {
+        getMyAction: async():Promise<{orders: OrderProps[], parlays:ParlayProps[], parlay_positions:ParlayPositionProps[], parlay_orders:OrderProps[]}> => {
+            try {
+                const resp = await axios.get(`${MK_SVC_API}/v1/orders/action/me`);
+                return resp.data
+            } catch (e) {
+                return { orders: [], parlay_orders: [], parlay_positions: [], parlays: [] }
+            }
+        },
+    },
+    FlashApi: {
+        getMyFlashAction: async():Promise<{ polls:PollProps[], poll_responses:PollResponseProps[], poll_options:PollOptionProps[] }> => {
+            try {
+                const resp = await axios.get(`${AUTH_SVC_API}/v2/pm/action/me`);
+                console.log(resp.data)
+                return resp.data
+            } catch (e) {
+                return { polls:[], poll_responses:[], poll_options: [] }
+            }
+        },
+    },
+    EngagementApi: {
+        getCompetitionOptions: async():Promise<{competition_types:CompetitionTypeProps[], competition_result_types:CompetitionResultTypeProps[], competition_payout_types:CompetitionPayoutTypeProps[]}> => {
+            try {
+                const resp = await axios.get(`${TP_SVC_API}/v1/competitions/options`)
+                return resp.data
+            } catch (e) {
+                return { competition_payout_types:[], competition_result_types:[], competition_types:[] }
+            }
+        },
+        getMyActiveSquaresCompetitions:async():Promise<{ squares_competitions:SquaresCompetitionProps[] }> => {
+            try {
+                const resp = await axios.get(`${TP_SVC_API}/v1/squares/me/active`);
+                return resp.data
+            } catch (error) {
+                return { squares_competitions: [] }
+            }
+        },
+        
+        getMyActiveCompetitions:async():Promise<{ competitions:CompetitionProps[], competition_players:CompetitionPlayerProps[], competition_records:CompetitionRecordProps[], competition_results:CompetitionResultProps[] }> => {
+            try {
+                const resp = await axios.get(`${TP_SVC_API}/v2/competitions/me/active`);
+                return resp.data
+            } catch (e) {
+                return { competitions: [], competition_players:[], competition_records:[], competition_results:[] }
+            }
+        },
+        
+        getMyActiveSeasons:async():Promise<{ competition_seasons:CompetitionSeasonProps[], competition_season_players:CompetitionSeasonPlayerProps[], competition_season_results:CompetitionSeasonResultProps[] }> => {
+            try {
+                const resp = await axios.get(`${TP_SVC_API}/v2/competitions/seasons/me/active`);
+                return resp.data   
+            } catch (e) {
+                return { competition_seasons:[], competition_season_players:[], competition_season_results:[] }
+            }
+        },
+        getMyActiveBracketCompetitions:async():Promise<{ bracket_competitions:BracketCompetitionProps[], competition_player_brackets:CompetitionPlayerBracketProps[], player_brackets:PlayerBracketProps[] }> => {
+            try {
+                const resp = await axios.get(`${TP_SVC_API}/v1/brackets/me/active`);
+                return resp.data   
+            } catch (e) {
+                return { bracket_competitions:[], competition_player_brackets:[], player_brackets:[] }
+            }
+        },
+        getMyActiveAdminBracketCompetitions: async() => {
+            try {
+                const resp = await axios.get(`${TP_SVC_API}/v1/brackets/admin/active`);
+                return resp.data.bracket_competitions
+            } catch (e) {
+                return []
+            }
+        }
+    }
+}
+
+
+export const MyActionHelpers = {
+    sortAction: (orders:OrderProps[], parlays:ParlayProps[], parlay_orders:OrderProps[], polls:PollProps[], competitions:CompetitionProps[], squares_competitions:SquaresCompetitionProps[], bracket_competitions:BracketCompetitionProps[]) => {
+        //Lets set up an array of data types
+        let action_types:ActionListProps[] = []
+        //Go through orders and we will group these into contests
+        let contests = [ ...new Set(orders.map(o => `${o.event_type}:${o.event_id}`)) ]
+        //Go through orders
+        contests.map(c => {
+            let event_id = c.split(':')[1]
+            let event_type = c.split(':')[0] as 'team'|'tournament'|'match'|undefined
+            if(!event_id || !event_type){ return }
+            let c_orders = orders.filter(o => o.event_id == event_id && o.event_type == event_type)
+            let expire_time = c_orders[0]?.expire_datetime
+            action_types.push({ id:event_id, contest_type:event_type, action_datetime: moment(expire_time), type: 'contest', orders: c_orders });
+        })
+        parlays.map(p => {
+            const p_orders = parlay_orders.filter(po => po.parlay_id == p.parlay_id);
+            action_types.push({ id: p.parlay_id, type:'parlay', action_datetime:moment(p.create_datetime), orders: p_orders});
+        });
+
+        polls.map(p => {
+            action_types.push({ id: p.poll_id, action_datetime: moment(p.end_datetime), type:'flash', orders:[] })
+        });
+
+        competitions.map(c => {
+            action_types.push({ id: c.competition_id, type:'competition', action_datetime:moment(c.scheduled_datetime), orders:[] });
+        });
+
+        squares_competitions.map(sc => {
+            action_types.push({ id: sc.sq_comp_id, type:'squares', action_datetime:moment(sc.begin_datetime), orders:[] });
+        });
+
+        bracket_competitions.map(bc => {
+            action_types.push({ id:bc.bracket_competition_id, type:'bracket', action_datetime: moment(bc.scheduled_datetime), orders: [] });
+        });
+
+        return action_types.sort((a,b) => moment(b.action_datetime).unix() - moment(a.action_datetime).unix());
+    },
+    getContestsFromOrders: (orders:OrderProps[]) => {
+        let event_ids = [ ...new Set(orders.filter(o => o.event_type == 'team').map(o => o.event_id))]
+        let tournament_ids = [ ...new Set(orders.filter(o => o.event_type == 'tournament').map(o => o.event_id))]
+        let match_ids = [ ...new Set(orders.filter(o => o.event_type == 'match').map(o => o.event_id))]
+
+        //Now lets grab all the athletes and teams that are needed as well
+        let athlete_ids = [ ...new Set(orders.filter(o => o.side_type == 'athlete').map(o => o.side_id)) ]
+        let team_ids = [ ...new Set(orders.filter(o => o.side_type == 'team').map(o => o.side_id)) ]
+
+        return { event_ids, tournament_ids, match_ids, athlete_ids, team_ids }
+    },
+    getContestsByIds: async(event_ids:string[], tournament_ids:string[], match_ids:string[], athlete_ids:string[], team_ids:string[]) => {
+            const events = await MyActionApi.ContestApi.getEventsByIds(event_ids);
+            const tournaments = await MyActionApi.ContestApi.getTournamentsByIds(tournament_ids);
+            const matches = await MyActionApi.ContestApi.getMatchesByIds(match_ids);
+            const athletes = await MyActionApi.ContestApi.getAthletesByIds(athlete_ids);
+            const teams = await MyActionApi.ContestApi.getTeamsByIds(team_ids);
+            return { events, tournaments, matches, athletes, teams }
+    },
+    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: '', scheduled_datetime: moment() } }
+                return { contest_title: event.event_title, scheduled_datetime: moment(event.scheduled_datetime) }
+            case 'tournament':
+                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: '', scheduled_datetime: moment() } }
+                return { contest_title: match.match_title, scheduled_datetime: moment(match.scheduled_datetime) }
+            default: return { contest_title: '', scheduled_datetime: moment() }
+        }
+    },
+    calcAllOrderStats: (orders:OrderProps[], parlay_positions?:ParlayPositionProps[], flash_responses?:PollResponseProps[]):OrderStatsProps => {
+        let open_order_count = 0, open_amt = 0, potential_winnings = 0, called_amt = 0, commission = 0;
+        let resolved_stake = 0, original_stake = 0, delayed_cash = 0, winnings = 0, net_winnings = 0, unresolved_stake = 0, resolved_potential_winnings = 0, unresolved_potential_winnings = 0, unresolved_potential_net_winnings = 0, num_trades = 0, cash_rcvd = 0; 
+        let unique_order_titles = [ ...new Set(orders.map(o => o.title)) ]
+        let result_ind:string|undefined = undefined
+        let order_ids:string[] = []
+        let open_orders:string[] = []
+        let wins = 0, losses = 0, draws = 0;
+        console.log(flash_responses)
+        orders.map(o => {
+            let commission_pct = 0
+            if(o.commission_pct){ commission_pct = o.commission_pct }
+            order_ids.push(o.order_id)
+            if(o.status === 'approved'){
+                open_orders.push(o.order_id)
+                open_amt += o.open_amt
+                open_order_count += 1
+                potential_winnings += o.potential_winnings
+                called_amt += o.called_amt
+            }
+            if(!o.positions){ return }
+            o.positions.map(p => {
+                if(!p){ return }
+                num_trades += 1
+                cash_rcvd += p.cash_rcvd
+                if(!p.result_ind){
+                    delayed_cash += p.delayed_cash
+                    unresolved_stake += p.stake
+                    unresolved_potential_winnings += p.potential_winnings
+                    unresolved_potential_net_winnings += (p.potential_winnings - ((p.potential_winnings - p.stake) * commission_pct))
+
+                } else {
+                    resolved_stake += p.stake
+                    original_stake += p.original_stake
+                    winnings += p.winnings
+                    net_winnings += p.net_winnings
+                    result_ind = p.result_ind
+                    commission += p.commission
+                    resolved_potential_winnings += p.potential_winnings
+                }
+            })
+            if(result_ind == 'win'){ wins += 1 }
+            if(result_ind == 'lose'){ losses += 1 }
+            if(result_ind == 'draw'){ draws += 1 }
+        })
+
+        if(parlay_positions && parlay_positions.length > 0){
+            parlay_positions.map(pp => {
+                if(!pp.result_ind){
+                    unresolved_stake += pp.stake
+                    original_stake += pp.stake
+                    unresolved_potential_winnings += pp.potential_winnings
+                    unresolved_potential_net_winnings += (pp.potential_winnings - ((pp.potential_winnings - pp.stake) * pp.commission_pct))
+                } else {
+                    resolved_stake += pp.stake
+                    original_stake += pp.stake
+                    winnings += pp.winnings
+                    net_winnings += pp.net_winnings
+                    commission += pp.commission
+                    resolved_potential_winnings += pp.potential_winnings
+                }
+                if(pp.result_ind == 'win'){ wins += 1 }
+                if(pp.result_ind == 'lose'){ losses += 1 }
+                if(pp.result_ind == 'draw'){ draws += 1 }
+            })
+        }
+    
+        let unresolved_position_probability = unresolved_stake / unresolved_potential_winnings
+        let resolved_position_probability = resolved_stake / resolved_potential_winnings
+        let unresolved_position_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(unresolved_position_probability)
+        let resolved_position_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(resolved_position_probability)
+        let offer_probability = open_amt / potential_winnings
+        let offer_odds = MarketComponentHelpers.calcAmericanOddsFromProbability(offer_probability)
+        let earnings = winnings + cash_rcvd - original_stake
+        let net_earnings = net_winnings + cash_rcvd - original_stake
+        let roi = earnings / resolved_stake
+        return {
+            stat_id: 'ALL',
+            unresolved_stake,
+            earnings,
+            resolved_stake,
+            original_stake,
+            net_earnings,
+            roi,
+            wins,
+            losses,
+            commission,
+            net_winnings,
+            unresolved_potential_net_winnings,
+            unique_order_titles,
+            draws,
+            unresolved_position_odds,
+            resolved_position_odds,
+            result_ind,
+            delayed_cash,
+            unresolved_potential_winnings,
+            resolved_potential_winnings,
+            resolved_position_probability,
+            unresolved_position_probability,
+            num_trades,
+            cash_rcvd,
+            winnings,
+            player_id: orders[0]?.player_id??'0',
+            event_id: 'ALL',
+            event_type: 'ALL',
+            open_amt, potential_winnings, called_amt, offer_odds, offer_probability,
+            orders: order_ids,
+            open_orders
+        }
+    },
+    getDetailsForOrder: (order:OrderProps, events:EventProps[], tournaments:TournamentProps[], matches:MatchProps[], athletes:AthleteProps[], teams:TeamProps[], leagues:LeagueProps[]) => {
+        let event = order.event_type == 'team' ? events.find(e => e.event_id == order.event_id) : undefined
+        let tournament = order.event_type == 'tournament' ? tournaments.find(t => t.tournament_id == order.event_id) : undefined
+        let match = order.event_type == 'match' ? matches.find(m => m.match_id == order.event_id) : undefined
+        let match_tournament = tournaments.find(t => t.tournament_id == match?.tournament_id)
+        let deets = MyActionHelpers.getContestDetails(order.event_type, event, tournament, match);
+        let athlete = order.side_type == 'athlete' ? athletes.find(a => a.athlete_id == order.side_id) : undefined
+        let team = order.side_type == 'team' ? teams.find(t => t.team_id == order.side_id) : undefined
+        let league = event ? leagues.find(l => l.league_id == event.league_id) : tournament ? leagues.find(l => l.league_id == tournament.league_id) : match_tournament ? leagues.find(l => l.league_id == match_tournament.league_id) : undefined
+        return { event, tournament, match, athlete, team, contest_title: deets.contest_title, scheduled_datetime: deets.scheduled_datetime, league }
+    },
+    aggregatePositions: (parlay:ParlayProps, pp:ParlayPositionProps[]) => {
+        let stake = 0, potential_winnings = 0, winnings = 0, net_winnings = 0, offer_side = parlay.offer_side, commission = 0, status = 'inprogress'
+        let result_ind = pp[0]?.result_ind
+        pp.map(p => {
+            stake += p.stake
+            commission += p.commission
+            net_winnings += p.net_winnings
+            winnings += p.winnings
+            result_ind = p.result_ind
+            potential_winnings += p.potential_winnings
+            if(p.side == 'maker'){ offer_side = 'maker' }
+            if(p.status != 'inprogress'){ status = 'closed' }
+        });
+        let earnings = winnings - stake
+        return { stake, potential_winnings, earnings, winnings, commission, status, net_winnings , offer_side, result_ind}
+    },
+    getActionStats: (orders:OrderProps[], parlays:ParlayProps[], parlay_positions:ParlayPositionProps[], competitions:CompetitionProps[], squares_competitions:SquaresCompetitionProps[], bracket_competitions:BracketCompetitionProps[]) => {
+        let risk = 0
+        console.log(parlays)
+        orders.map(o => {
+            if(!o.positions || !o.positions[0]){ return }
+            o.positions.map(p => {
+                risk += p.stake
+            })
+        });
+        competitions.map(c => {
+            risk += parseFloat(c.buy_in as string)
+        });
+        squares_competitions.map(sc => {
+            console.log(sc);
+            risk += 0
+        });
+        bracket_competitions.map(bc => {
+            risk += bc.buy_in
+        });
+        parlay_positions.map(pp => {
+            risk += pp.stake
+        });
+        
+        return { risk }
+    }
+}

package/src/MyAction/components/BracketRow.tsx

@@ -0,0 +1,34 @@
+import React from 'react';
+import { Text, View } from "../../Components/Themed"
+import type { BracketCompetitionProps } from "../../types"
+import { useColors } from '../../constants/useColors';
+import { Icons } from '../../Components';
+
+type BracketRowProps = {
+    market_type:'FOR_MONEY'|'FREE',
+    bracket_competition:BracketCompetitionProps,
+    width:number
+}
+
+const BracketRow = ({ market_type, bracket_competition, width }:BracketRowProps) => {
+    const Colors = useColors();
+    const cl = market_type == 'FOR_MONEY' ? '$' : 'E'
+
+    return (
+        <View>
+            <View type='row' style={{ padding:10, borderBottomWidth:1, borderColor:Colors.borders.light, flexWrap:'wrap' }}>
+                <Icons.BracketIcon size={22} color={Colors.text.h1} />
+                <View transparent style={{ borderRadius:0, padding:0, borderLeftWidth:1, borderColor:Colors.borders.light, flexGrow:1, marginLeft:6, paddingLeft:6, minWidth:75 }}>
+                    <Text theme='h1' style={{ maxWidth:width * 0.55 }}>{bracket_competition.competition_name}</Text>
+                    <Text theme='light' style={{ marginTop:3 }} color={Colors.text.action}>{}</Text>
+                </View>
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1'>{cl}{(bracket_competition.buy_in as number).toFixed(2)}</Text>
+                    <Text theme='light'>Risk</Text>
+                </View>
+            </View>
+        </View>
+    )
+}
+
+export default BracketRow

package/src/MyAction/components/CompetitionRow.tsx

@@ -0,0 +1,39 @@
+import React from 'react';
+import { Text, View } from "../../Components/Themed"
+import type { CompetitionPlayerProps, CompetitionProps, CompetitionRecordProps, CompetitionResultProps, CompetitionResultTypeProps, CompetitionTypeProps } from "../../types"
+import { useColors } from '../../constants/useColors';
+import { Icons } from '../../Components';
+
+type CompetitionRowProps = {
+    market_type:'FOR_MONEY'|'FREE',
+    competition:CompetitionProps,
+    competition_type:CompetitionTypeProps,
+    competition_result_type:CompetitionResultTypeProps,
+    competition_player:CompetitionPlayerProps,
+    competition_result:CompetitionResultProps,
+    competition_record:CompetitionRecordProps,
+    width:number
+}
+
+const CompetitionRow = ({ market_type, competition, competition_record, width }:CompetitionRowProps) => {
+    const Colors = useColors();
+    const cl = market_type == 'FOR_MONEY' ? '$' : 'E'
+
+    return (
+        <View>
+            <View type='row' style={{ padding:10, borderBottomWidth:1, borderColor:Colors.borders.light, flexWrap:'wrap' }}>
+                <Icons.PickEmIcon size={22} color={Colors.text.h1} />
+                <View transparent style={{ borderRadius:0, padding:0, borderLeftWidth:1, borderColor:Colors.borders.light, flexGrow:1, marginLeft:6, paddingLeft:6, minWidth:75 }}>
+                    <Text theme='h1' style={{ maxWidth:width * 0.55 }}>{competition.competition_name}</Text>
+                    <Text theme='light' style={{ marginTop:3 }} color={Colors.text.action}>{competition_record.wins} - {competition_record.losses}</Text>
+                </View>
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1'>{cl}{(competition.buy_in as number).toFixed(2)}</Text>
+                    <Text theme='light'>Risk</Text>
+                </View>
+            </View>
+        </View>
+    )
+}
+
+export default CompetitionRow

package/src/MyAction/components/ContestStatRow.tsx

@@ -0,0 +1,153 @@
+import React, { useState } from 'react';
+import { Button, Text, View } from "../../Components/Themed"
+import type { AthleteProps, EventProps, LeagueProps, MatchProps, OrderProps, TeamProps, TournamentProps } from "../../types"
+import { useColors } from '../../constants/useColors';
+import { Icons } from '../../Components';
+import { MyActionHelpers } from '../api';
+import { FlatList, Image } from 'react-native';
+import { AthleteImage, TeamImage } from '../../Components/Jerseys';
+import { MarketComponentHelpers } from '../../MarketComponents/api';
+
+type ContestStatRowProps = {
+    market_type:'FOR_MONEY'|'FREE',
+    contest_label:string,
+    time_detail:string,
+    orders:OrderProps[],
+    leagues:LeagueProps[],
+    events:EventProps[],
+    tournaments:TournamentProps[],
+    matches:MatchProps[],
+    athletes:AthleteProps[],
+    teams:TeamProps[],
+    width:number
+}
+
+const ContestStatRow = ({ market_type, contest_label, orders, width, events, tournaments, matches, athletes, teams, leagues }:ContestStatRowProps) => {
+    const Colors = useColors();
+    const [ expanded, setExpanded ] = useState(false);
+    const stats = MyActionHelpers.calcAllOrderStats(orders);
+    const stake = stats.unresolved_stake + stats.resolved_stake
+    const potential_winnings = stats.unresolved_potential_winnings + stats.resolved_potential_winnings
+    const cl = market_type == 'FOR_MONEY' ? '$' : 'E'
+    //Is this in progress?
+    const in_progress = stats.open_amt > 0 ? true : false
+    const settled = stats.result_ind ? true : false
+
+
+    const renderLegResult = (result_ind?:'win'|'lose'|'draw'|'inprogress') => {
+        switch(result_ind){
+            case 'win':
+                return <Icons.CheckIcon size={14} color={Colors.text.success} />
+            case 'lose':
+                return <Icons.CloseIcon size={14} color={Colors.text.error} />
+            case 'draw':
+                return <Icons.AlertIcon size={14} color={Colors.text.warning}/>
+            default:
+                return <Icons.ActivityIcon size={14} color={Colors.text.h1} />
+        }
+    }
+
+ const renderOrders = (data:{ item:OrderProps, index:number }) => {
+        const { contest_title, athlete, team, league } = MyActionHelpers.getDetailsForOrder(data.item, events, tournaments, matches, athletes, teams, leagues);
+        const result_ind = data.item.positions[0]?.result_ind
+        return (
+            <View type='row' style={{ padding:10, borderBottomWidth:1, borderColor:Colors.borders.light }}>
+                {team ?
+                <TeamImage
+                    team={team}
+                    league={league}
+                    size={10}
+                />
+                :athlete ?
+                <AthleteImage
+                    athlete={athlete}
+                    league={league}
+                    size={24}
+                />
+                :league ?
+                <Image
+                    source={{ uri: league.league_image }}
+                    style={{ height:18, width:18 }}
+                    resizeMode="cover"
+                />
+                :<></>
+                }
+                
+                <View transparent style={{ flex:1, marginLeft:8 }}>
+                    <Text theme='h2'>{data.item.title}</Text>
+                    <View transparent style={{ marginTop:3 }}>                            
+                        <Text theme="description">{contest_title}</Text>
+                    </View>
+                </View>
+                {data.item.resolution_status != 'closed' ?
+                <Button float style={{  marginRight:4, marginLeft:4, padding:10, flexDirection:'row', justifyContent:'center', alignItems:'center' }} onPress={() => console.log('ehy')}>
+                    <Icons.ActivityIcon size={18} color={Colors.text.action} />
+                    <Text theme="action"> View</Text>
+                </Button>
+                :<></>}
+                <View style={{ padding:10 }}>
+                    <Text theme="description">{MarketComponentHelpers.getOddsLabel(data.item.odds)}</Text>
+                </View>
+                {renderLegResult(result_ind)}
+                {result_ind == 'draw' ? 
+                <View type='blur' style={{ position:'absolute', top:0, left:0, right:0, bottom:0, justifyContent:'center' }}>
+                    <View style={{ borderBottomWidth:1, borderColor:Colors.borders.light, marginRight:20, marginLeft:20 }} />
+                </View>
+                :<></>}
+            </View>
+        )
+    }
+
+    return (
+        <View transparent style={{ borderWidth:expanded ? 1: 0, borderColor:expanded ? Colors.text.action: undefined }}>
+            <View type='row' style={{ padding:10, borderBottomWidth:1, borderColor:Colors.borders.light, flexWrap:'wrap' }}>
+                <Button float style={{ padding:5 }}>
+                    <Icons.OrderIcon size={14} color={Colors.text.action} />
+                </Button>
+                <Button transparent style={{ borderRadius:0, padding:0, borderLeftWidth:1, borderColor:Colors.borders.light, flexGrow:1, marginLeft:6, paddingLeft:6, minWidth:75 }} onPress={() => setExpanded(!expanded)}>
+                    <Text theme='h1' style={{ maxWidth: width * 0.5 }}>{contest_label}</Text>
+                    <Text theme='light' color={Colors.text.action} style={{ marginTop:3 }}>See {orders.length} Orders</Text>
+                </Button>
+                {width > 500 ?
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1'>{orders.length}</Text>
+                    <Text theme='light'>Orders</Text>
+                </View>
+                :<></>}
+                {in_progress ?
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1' color={Colors.text.warning}>{stats.open_amt.toFixed(2)}</Text>
+                    <Text theme='light' color={Colors.text.warning}>Open</Text>
+                </View>
+                :<></>}
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1'>{cl}{stake.toFixed(2)}</Text>
+                    <Text theme='light'>Risk</Text>
+                </View>
+                {settled ?
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1'>{cl}{stats.winnings.toFixed(2)}</Text>
+                    <Text theme='light'>Winnings</Text>
+                </View>
+                :
+                <View style={{ margin:5, minWidth:40, justifyContent:'center', alignItems:'center' }}>
+                    <Text theme='h1'>{cl}{potential_winnings.toFixed(2)}</Text>
+                    <Text theme='light'>Potential</Text>
+                </View>
+                }
+            </View>
+            {expanded ?
+            <View transparent style={{ padding:10 }}>
+                <FlatList
+                    data={orders}
+                    keyExtractor={item => item.order_id.toString()}
+                    renderItem={renderOrders}
+                    key={`contest_${contest_label}_orders`}
+                    />
+            </View>
+            :<></>}
+        </View>
+    )
+}
+
+export default ContestStatRow