Пример #1
0
        private Tuple <double?, double?> Get7dAnd30dVariation(string symbol)
        {
            var kline7d      = BinanceBusiness.GetKline7d(symbol);
            var kline30d     = BinanceBusiness.GetKline30d(symbol);
            var variation7d  = GetVariationFromKline(kline7d);
            var variation30d = GetVariationFromKline(kline30d);

            return(new Tuple <double?, double?>(variation7d, variation30d));
        }
Пример #2
0
        private Dictionary <int, TickerDataModel> GetAssetsCurrentValuesAndVariationFromBinanceTicker()
        {
            var ticker    = BinanceBusiness.GetTicker24h();
            var pairs     = PairBusiness.ListPairs();
            var usdtPairs = pairs.Where(p => p.QuoteAssetId == AssetUSDId);
            var btcPairs  = pairs.Where(p => !usdtPairs.Any(usdtPair => usdtPair.BaseAssetId == p.BaseAssetId) && p.QuoteAssetId == AssetBTCId);

            var currentValues = new Dictionary <int, TickerDataModel>();

            foreach (var usdtPair in usdtPairs)
            {
                var currentTicker = ticker.FirstOrDefault(t => t.Symbol == usdtPair.Symbol);
                if (currentTicker != null)
                {
                    currentValues.Add(usdtPair.BaseAssetId, new TickerDataModel()
                    {
                        CurrentValue     = currentTicker.LastPrice,
                        Variation24Hours = currentTicker.PriceChangePercent / 100.0,
                        AskValue         = currentTicker.AskPrice,
                        BidValue         = currentTicker.BidPrice
                    });
                }
            }

            foreach (var btcPair in btcPairs)
            {
                var currentTicker = ticker.FirstOrDefault(t => t.Symbol == btcPair.Symbol);
                if (currentTicker != null && currentValues.ContainsKey(btcPair.QuoteAssetId))
                {
                    currentValues.Add(btcPair.BaseAssetId, new TickerDataModel()
                    {
                        CurrentValue     = currentTicker.LastPrice * currentValues[btcPair.QuoteAssetId].CurrentValue,
                        Variation24Hours = GetVariation24h(currentTicker.LastPrice, currentTicker.PriceChangePercent / 100.0, currentValues[btcPair.QuoteAssetId].CurrentValue, currentValues[btcPair.QuoteAssetId].Variation24Hours.Value),
                        AskValue         = currentTicker.AskPrice * currentValues[btcPair.QuoteAssetId].AskValue,
                        BidValue         = currentTicker.BidPrice * currentValues[btcPair.QuoteAssetId].BidValue
                    });
                }
            }

            return(currentValues);
        }
        public TickerDataModel GetRealCurrentValue(int assetId)
        {
            TickerDataModel currentValue = null;
            var             pairs        = PairBusiness.ListPairs(new int[] { assetId });

            if (pairs.Any())
            {
                var usdQuote = pairs.FirstOrDefault(c => c.QuoteAssetId == AssetUSDId);
                if (usdQuote != null)
                {
                    var ticker = BinanceBusiness.GetTicker24h(usdQuote.Symbol);
                    if (ticker != null)
                    {
                        currentValue = new TickerDataModel()
                        {
                            AskValue         = ticker.AskPrice,
                            BidValue         = ticker.BidPrice,
                            CurrentValue     = ticker.LastPrice,
                            Variation24Hours = ticker.PriceChangePercent / 100
                        };
                    }
                }
                else
                {
                    var btcQuote = pairs.FirstOrDefault(c => c.QuoteAssetId == AssetBTCId);
                    if (btcQuote != null)
                    {
                        var btcPair = PairBusiness.ListPairs(new int[] { AssetBTCId }, new int[] { AssetUSDId }).FirstOrDefault();
                        if (btcPair != null)
                        {
                            var btcValue = BinanceBusiness.GetTicker24h(btcQuote.Symbol);
                            var btcPrice = BinanceBusiness.GetTicker24h(btcPair.Symbol);
                            if (btcPrice != null && btcValue != null)
                            {
                                currentValue = new TickerDataModel()
                                {
                                    AskValue         = btcValue.AskPrice * btcPrice.AskPrice,
                                    BidValue         = btcValue.BidPrice * btcPrice.BidPrice,
                                    CurrentValue     = btcValue.LastPrice * btcPrice.LastPrice,
                                    Variation24Hours = AssetValueBusiness.GetVariation24h(btcValue.LastPrice, btcValue.PriceChangePercent / 100, btcPrice.LastPrice, btcPrice.PriceChangePercent / 100)
                                };
                            }
                        }
                    }
                }
            }
            if (currentValue == null)
            {
                var assetCurrentValue = ListAllAssets(true, new int[] { assetId }).FirstOrDefault();
                if (assetCurrentValue != null && assetCurrentValue.UpdateDate > Data.GetDateTimeNow().AddMinutes(-2))
                {
                    currentValue = new TickerDataModel()
                    {
                        AskValue         = assetCurrentValue.AskValue,
                        BidValue         = assetCurrentValue.BidValue,
                        CurrentValue     = assetCurrentValue.CurrentValue,
                        Variation24Hours = assetCurrentValue.Variation24Hours
                    }
                }
                ;
            }
            return(currentValue);
        }
    }