Ejemplo n.º 1
0
 public static BetfairE.RunnerPrices FindRunnerPrices(BetfairE.MarketPrices marketPrices, int selectionId)
 {
     if (marketPrices == null)
     {
         return(null);
     }
     foreach (BetfairE.RunnerPrices runnerPrices in marketPrices.runnerPrices)
     {
         if (runnerPrices.selectionId == selectionId)
         {
             return(runnerPrices);
         }
     }
     return(null);
 }
Ejemplo n.º 2
0
        private static BetfairE.MarketPrices DecompressMarketPrices(string compressed)
        {
            compressed = DecompressEscapePreParse(compressed);

            // The compressed format:
            //
            // marketId~currencyCode~marketStatus~delay~numberOfWinners~marketInfo~discountAllowed~marketBaseRate~lastRefresh~removedRunners~bspMarket~:
            // selectionId~sortOrder~totalAmountMatched~lastPriceMatched~handicap~reductionFactor~vacant~farBSP~nearBSP~actualBSP~|
            // price~amountAvailable~betType~depth~|
            // price~amountAvailable~betType~depth~:
            // selectionId~sortOrder~totalAmountMatched~lastPriceMatched~handicap~reductionFactor~vacant~farBSP~nearBSP~actualBSP~|
            // price~amountAvailable~betType~depth~|
            // price~amountAvailable~betType~depth~

            BetfairE.MarketPrices        marketPrices     = new BetfairE.MarketPrices();
            List <BetfairE.RunnerPrices> runnerPricesList = new List <BetfairE.RunnerPrices>();

            string[] runners = compressed.Split(':');
            for (int r = 0; r < runners.Length; r++)
            {
                if (r == 0)
                {
                    string[] values = runners[r].Split('~');
                    if (values.Length >= 9)
                    {
                        marketPrices.marketId        = int.Parse(values[0]);
                        marketPrices.currencyCode    = DecompressEscapePostParse(values[1]);
                        marketPrices.marketStatus    = (BetfairE.MarketStatusEnum)Enum.Parse(typeof(BetfairE.MarketStatusEnum), values[2]);
                        marketPrices.delay           = int.Parse(values[3]);
                        marketPrices.numberOfWinners = int.Parse(values[4]);
                        marketPrices.marketInfo      = DecompressEscapePostParse(values[5]);
                        marketPrices.discountAllowed = bool.Parse(values[6]);
                        marketPrices.marketBaseRate  = float.Parse(values[7]);
                        marketPrices.lastRefresh     = long.Parse(DecompressDefault(values[8], "0"));
                        if (values.Length >= 10)
                        {
                            marketPrices.removedRunners = DecompressEscapePostParse(values[9]);
                        }
                        if (values.Length >= 11)
                        {
                            marketPrices.bspMarket = (values[10] == "Y") || (values[10] == "y");
                        }
                    }
                    else
                    {
                        System.Diagnostics.Debug.WriteLine(string.Format("DecompressMarketPrices: too few values for market: {0}", runners[r]));
                    }
                }
                else
                {
                    BetfairE.RunnerPrices runnerPrices         = new BetfairE.RunnerPrices();
                    List <BetfairE.Price> bestPricesToBackList = new List <BetfairE.Price>();
                    List <BetfairE.Price> bestPricesToLayList  = new List <BetfairE.Price>();

                    string[] prices = runners[r].Split('|');
                    for (int p = 0; p < prices.Length; p++)
                    {
                        if (p == 0)
                        {
                            string[] values = prices[p].Split('~');
                            if (values.Length >= 7)
                            {
                                runnerPrices.selectionId        = int.Parse(values[0]);
                                runnerPrices.sortOrder          = int.Parse(values[1]);
                                runnerPrices.totalAmountMatched = double.Parse(DecompressDefault(values[2], "0"));
                                runnerPrices.lastPriceMatched   = double.Parse(DecompressDefault(values[3], "0"));
                                runnerPrices.handicap           = double.Parse(DecompressDefault(values[4], "0"));
                                runnerPrices.reductionFactor    = double.Parse(DecompressDefault(values[5], "0"));
                                runnerPrices.vacant             = bool.Parse(values[6]);
                                if (values.Length >= 10)
                                {
                                    runnerPrices.farBSP    = DecompressStartingPrice(values[7]);
                                    runnerPrices.nearBSP   = DecompressStartingPrice(values[8]);
                                    runnerPrices.actualBSP = DecompressStartingPrice(values[9]);
                                }
                            }
                            else
                            {
                                System.Diagnostics.Debug.WriteLine(string.Format("DecompressMarketPrices: too few values for runner: {0}", prices[p]));
                            }
                        }
                        else
                        {
                            BetfairE.Price price = null;

                            string[] values = prices[p].Split('~');
                            for (int v = 0; v < values.Length; v++)
                            {
                                if (values[v].Length == 0)
                                {
                                    break;
                                }
                                switch (v % 4)
                                {
                                case 0:
                                    price       = new BetfairE.Price();
                                    price.price = double.Parse(values[v]);
                                    break;

                                case 1:
                                    price.amountAvailable = double.Parse(values[v]);
                                    break;

                                case 2:
                                    price.betType = (BetfairE.BetTypeEnum)Enum.Parse(typeof(BetfairE.BetTypeEnum), values[v]);
                                    break;

                                case 3:
                                    price.depth = int.Parse(values[v]);
                                    if (price.betType == BetfairE.BetTypeEnum.B)
                                    {
                                        bestPricesToLayList.Add(price);
                                    }
                                    else
                                    {
                                        bestPricesToBackList.Add(price);
                                    }
                                    price = null;
                                    break;
                                }
                            }
                        }
                    }

                    runnerPrices.bestPricesToBack = bestPricesToBackList.ToArray();
                    runnerPrices.bestPricesToLay  = bestPricesToLayList.ToArray();
                    runnerPricesList.Add(runnerPrices);
                }
            }

            marketPrices.runnerPrices = runnerPricesList.ToArray();
            return(marketPrices);
        }