Beispiel #1
0
//        public static SoundPlayer player=null;

        public static double GetCurrentPrice(string market, string ticker)
        {
            List <MarketCurrentView> prices = Global.marketsState.curMarkets[market];
            string            finder        = ticker;
            MarketCurrentView price         = prices.Single(s => s.ticker == finder);

            return(price.origPrice);
        }
Beispiel #2
0
        public void GetMarketCurrent_UIResultHandler(RequestItemGroup resultResponse)
        {
            if (RequestManager.IsResultHasErrors(resultResponse))
            {
                return;
            }
            Dictionary <string, MarketCurrent> currenciesDict = (Dictionary <string, MarketCurrent>)resultResponse.items[0].result.resultData;

            //            Dictionary<string, TradePair> pairs = (Dictionary<string, TradePair>)resultResponse.items[0].result.resultData;

            if (!marketsLoaded)
            {
                if (Global.marketsState.curMarketPairs[resultResponse.market] == null)
                {
                    Dictionary <string, TradePair> tradePairs = new Dictionary <string, TradePair>();
                    foreach (KeyValuePair <string, MarketCurrent> pair in currenciesDict)
                    {
                        Pair      pairinfo = new Pair(pair.Value.ticker);
                        TradePair tpair    = new TradePair
                        {
                            currency1 = pairinfo.currency1,
                            currency2 = pairinfo.currency2,
                            isActive  = true,
                            ticker    = pair.Value.ticker
                        };

                        tradePairs.Add(pair.Key, tpair);
                    }
                    Global.marketsState.SetPairs(resultResponse.market, tradePairs);
                }


                bool allMarketsReady = true;
                foreach (var marketName in Global.markets.GetMarketList())
                {
                    if (Global.marketsState.curMarketPairs[marketName] == null)
                    {
                        allMarketsReady = false;
                        break;
                    }
                }
                if (allMarketsReady)
                {
                    marketsLoaded = true;
                }
            }

            if (marketsLoaded)
            {
                Market curmarket = ExchangeManager.GetMarketByMarketName(toolStripComboBoxMarket.Text);
                if (curmarket.HaveKey())
                {
                    toolButtonTickerBtc.Enabled = true;
                    toolButtonTickerUsd.Enabled = true;
                    if (curmarket.Options().AllPairRatesSupported)
                    {
                        toolStripButtonAlerts.Enabled = true;
                    }
                }
                if (curmarket.Options().ChartDataSupported)
                {
                    toolStripButtonChart.Enabled = true;
                }
                toolStripButtonBalance.Enabled  = true;
                toolStripComboBoxMarket.Enabled = true;
                labelInfo.Text = "";
            }

            List <MarketCurrentView> currencies = currenciesDict.Values.Select(item => new MarketCurrentView
            {
                ticker        = item.ticker,
                origPrice     = item.lastPrice,
                lastPrice     = item.lastPrice,
                lastPriceUSD  = 0,
                percentChange = item.percentChange,
                volumeBtc     = item.volumeBtc,
                volumeUSDT    = item.volumeUSDT
            }).ToList();


            if (currenciesDict.ContainsKey("USDT_BTC"))
            {
                double btcPrice = currenciesDict["USDT_BTC"].lastPrice;
                foreach (var item in currencies)
                {
                    if (item.ticker.StartsWith("BTC"))
                    {
                        item.volumeUSDT = item.volumeBtc * btcPrice;
                    }

                    if (item.ticker.StartsWith("BTC"))
                    {
                        item.lastPriceUSD = item.lastPrice * btcPrice;
                    }
                    else if (item.ticker.StartsWith("USDT"))
                    {
                        double usdprice = item.lastPrice;
                        item.lastPriceUSD = usdprice;
                        item.lastPrice    = item.lastPrice / btcPrice;
                    }
                }
            }
            currencies = currencies.OrderByDescending(x => x.volumeUSDT).ToList();

            List <MarketCurrentView> currenciesCopy = new List <MarketCurrentView>();

            foreach (MarketCurrentView item in currencies)
            {
                MarketCurrentView newItem = new MarketCurrentView()
                {
                    ticker        = item.ticker,
                    origPrice     = item.origPrice,
                    lastPrice     = item.lastPrice,
                    lastPriceUSD  = item.lastPriceUSD,
                    percentChange = item.percentChange,
                    volumeBtc     = item.volumeBtc,
                    volumeUSDT    = item.volumeUSDT
                };
                currenciesCopy.Add(newItem);
            }
            if (ExchangeManager.GetMarketByMarketName(resultResponse.market).Options().AllPairRatesSupported)
            {
                Global.marketsState.Update(resultResponse.market, currenciesCopy);
            }


            if (resultResponse.market != toolStripComboBoxMarket.Text)
            {
                return;
            }


            var dataView = currencies.Select(item => new
            {
                ticker               = item.ticker,
                lastPrice            = item.lastPrice,
                lastPriceUSDT        = item.lastPriceUSD,
                percentChange        = item.percentChange,
                volumeBtc            = item.volumeBtc,
                volumeUSDT           = item.volumeUSDT,
                lastPriceDisplay     = Helper.PriceToStringBtc(item.lastPrice),
                lastPriceUSDTDisplay = item.lastPriceUSD.ToString("N3") + " $",
                percentChangeDisplay = item.percentChange.ToString("0") + " %",
                volumeBtcDisplay     = item.volumeBtc.ToString("N2"),
                volumeUSDTDisplay    = item.volumeUSDT.ToString("N0") + " $"
            }).ToList();
            List <GVColumn> columns = new List <GVColumn>()
            {
                new GVColumn("ticker", "Currency", "string"),
                new GVColumn("lastPrice", "Price BTC", "DisplayField", "lastPriceDisplay"),
                new GVColumn("lastPriceUSDT", "Price $", "DisplayField", "lastPriceUSDTDisplay"),
                new GVColumn("percentChange", "Change %", "DisplayField", "percentChangeDisplay"),
                new GVColumn("volumeBtc", "Volume BTC", "DisplayField", "volumeBtcDisplay"),
                new GVColumn("volumeUSDT", "Volume $", "DisplayField", "volumeUSDTDisplay"),
                new GVColumn("lastPriceDisplay", "Price BTC", "string", "", false),
                new GVColumn("lastPriceUSDTDisplay", "Price $", "string", "", false),
                new GVColumn("percentChangeDisplay", "Change %", "string", "", false),
                new GVColumn("volumeBtcDisplay", "Volume BTC", "string", "", false),
                new GVColumn("volumeUSDTDisplay", "Volume $", "string", "", false)
            };

            if (gvMarkets == null)
            {
                gvMarkets = new DataGridViewExWrapper();
            }
            gvMarkets.Create(dgridMarkets, dataView, columns, true);
            DataGridViewCellStyle styleTicker = new DataGridViewCellStyle {
                Font = new Font("Tahoma", 9.0F, FontStyle.Bold), ForeColor = Color.Black
            };
            DataGridViewCellStyle stylePrice = new DataGridViewCellStyle {
                Font = new Font("Tahoma", 9.0F, FontStyle.Regular), ForeColor = Color.Black
            };

            gvMarkets.SetColumnStyle("ticker", styleTicker);
            gvMarkets.SetColumnStyle("lastPrice", stylePrice);
            gvMarkets.SetColumnStyle("lastPriceUSDT", stylePrice);
            //gvMarkets.AutoSizeFillExcept("volumeUSDT");
            //            gv.RowColorByCondition("orderType", (string s) => { return s == "1"; }, Color.LightPink);


            timerMarkets.Start();
        }
Beispiel #3
0
        /*
         * public void CalcTotalBalance(List<ExchangeBalance> balances)
         * {
         *  double totalBtc = 0;
         * //            Dictionary<string, bool> currencyCounted = new Dictionary<string, bool>();
         *  double pairPrice=0;
         *  double BtcInUsdPrice = 0;
         *
         *  foreach (ExchangeBalance balance in balances)
         *  {
         *      pairPrice = 0;
         *
         *      string btcpair ="";
         *      if (balance.currency == "USDT")
         *          btcpair = balance.currency + "_BTC";
         *      else if (balance.currency == "BTC")
         *      {
         *          pairPrice = 1;
         *      }
         *      else
         *          btcpair = "BTC_" + balance.currency;
         *
         *      //if (currencyCounted.ContainsKey(btcpair))
         *      //    continue;
         *
         *      if (pairPrice == 0)
         *      {
         *          foreach (KeyValuePair<string, List<MarketCurrentView>> curMarket in Global.marketsState.curMarkets)
         *          {
         *              if (curMarket.Value == null)
         *                  continue;
         *              foreach (MarketCurrentView curpair in curMarket.Value)
         *              {
         *                  if (curpair.ticker != btcpair)
         *                      continue;
         *                  pairPrice = curpair.origPrice;
         *                  break;
         *              }
         *              if (pairPrice != 0)
         *                  break;
         *          }
         *      }
         *      if (pairPrice != 0)
         *      {
         *          if (balance.currency == "USDT")
         *          {
         *              BtcInUsdPrice = pairPrice;
         *              pairPrice = 1.0 / pairPrice;
         *          }
         *          totalBtc += pairPrice * balance.balance;
         *      }
         *
         *  }
         *
         *  if (totalBtc!=0)
         *  {
         *      labelBalanceBaseValue.Text = Helper.PriceToStringBtc(totalBtc);
         *      double totalUsd = totalBtc * BtcInUsdPrice;
         *      labelBalanceUsd.Text ="=  "+Helper.PriceToStringFinance(totalUsd)+" $";
         *  }
         *
         * }
         */
        public void CalcTotalBalance(List <ExchangeBalance> balances)
        {
            foreach (ExchangeBalance balance in balances)
            {
                string btcpair = "";
                balance.balanceFound = false;
                if (balance.currency == "USDT" || balance.currency == "USD" || balance.currency == "RUR")
                {
                    btcpair = balance.currency + "_BTC";
                }
                else if (balance.currency == "BTC")
                {
                    balance.balanceFound = true;
                    balance.price        = 1;
                }
                else
                {
                    btcpair = "BTC_" + balance.currency;
                }

                if (btcpair != "")
                {
                    foreach (KeyValuePair <string, List <MarketCurrentView> > curMarket in Global.marketsState.curMarkets)
                    {
                        if (curMarket.Value == null)
                        {
                            continue;
                        }
                        MarketCurrentView pair = curMarket.Value.FirstOrDefault(x => x.ticker == btcpair);
                        if (pair == null)
                        {
                            continue;
                        }
                        balance.balanceFound = true;
                        balance.price        = pair.origPrice;
                        break;
                    }
                }
            }

            double BtcInUsdPrice = 0;

            foreach (KeyValuePair <string, List <MarketCurrentView> > curMarket in Global.marketsState.curMarkets)
            {
                if (curMarket.Value == null)
                {
                    continue;
                }
                MarketCurrentView pair = curMarket.Value.FirstOrDefault(x => x.ticker == "USDT_BTC");
                if (pair != null)
                {
                    BtcInUsdPrice = pair.origPrice;
                    break;
                }
                pair = curMarket.Value.FirstOrDefault(x => x.ticker == "USD_BTC");
                if (pair != null)
                {
                    BtcInUsdPrice = pair.origPrice;
                }
            }


            double totalBtc = 0;

            foreach (ExchangeBalance balance in balances)
            {
                balance.btcBalance = 0;
                if (balance.exchangeName == "Yobit")
                {
                    if (balance.currency == "USD" && BtcInUsdPrice != 0)
                    {
                        balance.btcBalance = (1.0 / BtcInUsdPrice) * balance.balance;
                    }
                    else if (balance.currency == "RUR" && BtcInUsdPrice != 0)
                    {
                        balance.btcBalance = (1.0 / (BtcInUsdPrice * 56)) * balance.balance;
                    }
                    else
                    {
                        balance.btcBalance = balance.price * balance.balance;
                    }
                }
                else
                {
                    if (balance.currency == "USDT" || balance.currency == "USD" || balance.currency == "RUR" && balance.price != 0)
                    {
                        balance.btcBalance = (1.0 / balance.price) * balance.balance;
                    }
                    else
                    {
                        balance.btcBalance = balance.price * balance.balance;
                    }
                }

                balance.usdBalance = balance.btcBalance * BtcInUsdPrice;
                totalBtc          += balance.btcBalance;
            }


            if (totalBtc != 0)
            {
                labelBalanceBaseValue.Text = Helper.PriceToStringBtc(totalBtc);
                double totalUsd = totalBtc * BtcInUsdPrice;
                labelBalanceUsd.Text = "=  " + ((int)totalUsd) + " $";// Helper.PriceToStringFinance(totalUsd) + " $";
            }
        }