public async Task <decimal> GetEstimatedAmount(decimal btcAmount, int currencyId) { if (currencyId == Constant.BITCOIN_ID) { return(btcAmount); } var tradePair = await TradePairReader.GetTradePair(currencyId, Constant.BITCOIN_ID).ConfigureAwait(false); if (tradePair == null) { var ltcTradePair = await TradePairReader.GetTradePair(currencyId, Constant.LITECOIN_ID).ConfigureAwait(false); var ltcbtcTradePair = await TradePairReader.GetTradePair(Constant.LITECOIN_ID, Constant.BITCOIN_ID).ConfigureAwait(false); if (ltcTradePair == null || ltcbtcTradePair == null) { return(0); } return((btcAmount / Math.Max(0.00000001m, ltcTradePair.LastTrade)) * Math.Max(0.00000001m, ltcbtcTradePair.LastTrade)); } return(btcAmount / Math.Max(0.00000001m, tradePair.LastTrade)); }
private async Task <List <TradeSummaryData> > GetOrCacheBaseSummary(string baseCurrency) { var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ExchangeSummary(baseCurrency), TimeSpan.FromMinutes(5), async() => { var tradeHistory = await GetOrCacheTradeHistory().ConfigureAwait(false); var tradePairs = await TradePairReader.GetTradePairs().ConfigureAwait(false); var basepairs = tradePairs.Where(x => x.BaseSymbol == baseCurrency).ToList(); var ids = basepairs.Select(x => x.TradePairId); var tradeHistoryData = tradeHistory.Where(tp => ids.Contains(tp.TradePairId)).ToList(); var results = new List <TradeSummaryData>(); foreach (var x in basepairs) { var data = tradeHistoryData.Where(t => t.TradePairId == x.TradePairId); results.Add(new TradeSummaryData { CurrencyId = x.CurrencyId, TradePairId = x.TradePairId, Name = x.Name, Symbol = x.Symbol, Change = GetChangePercent(data.FirstOrDefault()?.Rate ?? x.LastTrade, x.LastTrade).ToString("F2"), BaseVolume = data.Sum(t => t.Amount *t.Rate).ToString("F8"), Volume = data.Sum(t => t.Amount).ToString("F8"), Low = (data.OrderBy(t => t.Rate).FirstOrDefault()?.Rate ?? x.LastTrade).ToString("F8"), High = (data.OrderByDescending(t => t.Rate).FirstOrDefault()?.Rate ?? x.LastTrade).ToString("F8"), Last = x.LastTrade.ToString("F8"), BaseSymbol = x.BaseSymbol }); } return(results.ToList()); }).ConfigureAwait(false); return(cacheResult); }
public async Task <decimal> GetNZDPerCoin(int currencyId) { var cacheResult = await CacheService.GetOrSetHybridValueAsync(CacheKey.NZDPerCoin(currencyId), TimeSpan.FromHours(2), async() => { if (currencyId == Constant.NZDT_ID) { return(1); } var estBtc = await GetEstimatedBTC(1, currencyId); if (estBtc == 0) { return(0); } var nzdPrice = await ExternalApiService.ConvertDollarToBTC(1, ConvertDollarToBTCType.NZD); if (nzdPrice != 0) { return(estBtc / nzdPrice); } var btc_nzdt = await TradePairReader.GetTradePair(Constant.BITCOIN_ID, Constant.NZDT_ID).ConfigureAwait(false); if (btc_nzdt == null || btc_nzdt.LastTrade == 0) { return(0); } return(estBtc *btc_nzdt.LastTrade); }); return(cacheResult); }
public async Task <decimal> GetEstimatedNZD(decimal amount, int currencyId) { if (amount == 0) { return(0); } if (currencyId == Constant.NZDT_ID) { return(amount); } var estBtc = await GetEstimatedBTC(amount, currencyId); if (estBtc == 0) { return(0); } var nzdPrice = await ExternalApiService.ConvertDollarToBTC(1, ConvertDollarToBTCType.NZD); if (nzdPrice != 0) { return(estBtc / nzdPrice); } var btc_nzdt = await TradePairReader.GetTradePair(Constant.BITCOIN_ID, Constant.NZDT_ID).ConfigureAwait(false); if (btc_nzdt == null || btc_nzdt.LastTrade == 0) { return(0); } return(estBtc * btc_nzdt.LastTrade); }
public async Task <CreateTradeResponseModel> SubmitUserTrade(ApiSubmitUserTradeRequest request) { var tradePair = request.TradePairId.HasValue ? await TradePairReader.GetTradePair(request.TradePairId.Value).ConfigureAwait(false) : await TradePairReader.GetTradePair(request.Market.Replace('/', '_')).ConfigureAwait(false); if (tradePair == null) { var marketName = request.TradePairId.HasValue ? request.TradePairId.ToString() : request.Market; return(new CreateTradeResponseModel { Error = $"Market '{marketName}' not found." }); } var totalTrade = request.Amount * request.Rate; if (totalTrade < tradePair.BaseMinTrade) { return new CreateTradeResponseModel { Error = $"Invalid trade amount, Minimum total trade is {tradePair.BaseMinTrade} {tradePair.BaseSymbol}" } } ; var response = await TradeService.CreateTrade(request.UserId.ToString(), new CreateTradeModel { Amount = request.Amount, Price = request.Rate, TradePairId = tradePair.TradePairId, IsBuy = request.Type == TradeHistoryType.Buy, }, true).ConfigureAwait(false); return(response); }
public async Task <decimal> GetEstimatedValue(decimal amount, int currencyId, int baseCurrency) { var tradePair = await TradePairReader.GetTradePair(currencyId, baseCurrency).ConfigureAwait(false); if (tradePair != null) { return(amount * tradePair.LastTrade); } return(0); }
public async Task <decimal> GetEstimatedBTC(decimal amount, int currencyId) { if (amount == 0) { return(0); } if (currencyId == Constant.BITCOIN_ID) { return(amount); } if (currencyId == Constant.USDT_ID) { var btc_usdt = await TradePairReader.GetTradePair(Constant.BITCOIN_ID, Constant.USDT_ID).ConfigureAwait(false); if (btc_usdt == null || btc_usdt.LastTrade == 0) { return(0); } return(amount / btc_usdt.LastTrade); } if (currencyId == Constant.NZDT_ID) { var btc_nzdt = await TradePairReader.GetTradePair(Constant.BITCOIN_ID, Constant.NZDT_ID).ConfigureAwait(false); if (btc_nzdt == null || btc_nzdt.LastTrade == 0) { return(0); } return(amount / btc_nzdt.LastTrade); } var tradePair = await TradePairReader.GetTradePair(currencyId, Constant.BITCOIN_ID).ConfigureAwait(false); if (tradePair == null) { var ltcTradePair = await TradePairReader.GetTradePair(currencyId, Constant.LITECOIN_ID).ConfigureAwait(false); var ltcbtcTradePair = await TradePairReader.GetTradePair(Constant.LITECOIN_ID, Constant.BITCOIN_ID).ConfigureAwait(false); if (ltcTradePair == null || ltcbtcTradePair == null) { return(0); } return((amount * ltcTradePair.LastTrade) * ltcbtcTradePair.LastTrade); } return(amount * tradePair.LastTrade); }
public async Task <ActionResult> UpdateTradePair(int id) { var model = await TradePairReader.AdminGetTradePair(id); if (model == null) { return(ViewMessageModal(new ViewMessageModel(ViewMessageType.Danger, "Error", $"TradePair '{id}' not found"))); } return(View("UpdateTradePairModal", model)); }
public async Task <ActionResult> SubmitTrade(SubmitTradeModel model) { if (!ModelState.IsValid) { return(JsonError(ModelState.FirstError())); } var tradePair = await TradePairReader.GetTradePair(model.TradePairId); if (tradePair == null) { return(JsonError(Resources.Exchange.tradeNoMarketError)); } if (model.Amount * model.Price < tradePair.BaseMinTrade) { return(JsonError(string.Format(Resources.Exchange.tradeMinTotalError, $"{tradePair.BaseMinTrade:F8}", tradePair.BaseSymbol))); } if (model.Amount >= 1000000000 || (model.Amount * model.Price) >= 1000000000) { return(JsonError(string.Format(Resources.Exchange.tradeMaxAmountError, "1000000000"))); } if (model.Price < 0.00000001m) { return(JsonError(string.Format(Resources.Exchange.tradeMinPriceError, "0.00000001"))); } if (model.Price > 1000000000) { return(JsonError(string.Format(Resources.Exchange.tradeMaxPriceError, "1000000000"))); } var response = await TradeService.CreateTrade(User.Identity.GetUserId(), new CreateTradeModel { Amount = model.Amount, IsBuy = model.IsBuy, Price = model.Price, TradePairId = tradePair.TradePairId }); if (response.IsError) { return(JsonError(response.Error)); } await response.Notifications.SendNotifications(); await response.DataUpdates.SendTradeNotifications(); return(JsonSuccess()); }
public async Task <ActionResult> Index() { var tradePairs = await TradePairReader.GetTradePairs(); var balances = await BalanceReader.GetBalances(User.Id()); return(View(new FaucetViewModel { TradePairs = new List <TradePairModel>(tradePairs), Balances = new List <BalanceModel>(balances), })); }
public async Task <ActionResult> Index(string area = "Deposit", string coin = null) { var tradePairs = await TradePairReader.GetTradePairs(); var balances = await BalanceReader.GetBalances(User.Id()); return(View(new HistoryViewModel { Currency = coin, Section = area, TradePairs = new List <TradePairModel>(tradePairs), Balances = new List <BalanceModel>(balances) })); }
public async Task <ActionResult> Index() { var tradePairs = await TradePairReader.GetTradePairs(); var balances = await BalanceReader.GetBalances(User.Id()); var currencyStatus = await CurrencyReader.GetCurrencyStatus(); return(View(new StatusViewModel { TradePairs = new List <TradePairModel>(tradePairs), Balances = new List <BalanceModel>(balances), CurrencyStatus = new List <CurrencyStatusModel>(currencyStatus) })); }
public async Task <ActionResult> Index(string section = "Account") { ViewBag.Section = section; var tradePairs = await TradePairReader.GetTradePairs(); var balances = await BalanceReader.GetBalances(User.Id()); return(View(new UserSettingsModel { SecurityModel = new UserSecurityModel(), UserProfile = new UserProfileModel(), TradePairs = new List <TradePairModel>(tradePairs), Balances = new List <BalanceModel>(balances) })); }
public async Task <ActionResult> Update(int tradePairId) { var user = await UserManager.FindByIdAsync(User.Id()); if (user == null) { return(Unauthorized()); } var model = await TradePairReader.GetTradePairUpdate(tradePairId); if (model == null) { return(ViewMessageModal(ViewMessageModel.Error("Not Found!", "TradePair '{0}' not found.", tradePairId))); } return(View("UpdateTradePairModal", model)); }
public async Task <ActionResult> GetTradePairData(int tradepairId) { var ticker = await TradePairReader.GetTicker(tradepairId); var tradePair = await TradePairReader.GetTradePair(tradepairId); var orderbookData = await ExchangeReader.GetOrderBook(User.Identity.GetUserId(), tradepairId); var historyData = await ExchangeReader.GetTradeHistory(tradepairId); return(Json(new { Success = true, TradePair = tradePair, Ticker = ticker, Buys = orderbookData.BuyData, Sells = orderbookData.SellData, History = historyData })); }
public async Task <ApiTradePairResult> GetTradePairs() { var tradepairs = await TradePairReader.GetTradePairs().ConfigureAwait(false); if (!tradepairs.Any()) { return new ApiTradePairResult { Error = "No currencies found", Success = true, } } ; var results = tradepairs.Select(x => new ApiTradePair { BaseCurrency = x.BaseName, BaseSymbol = x.BaseSymbol, Currency = x.Name, Label = x.Market.Replace('_', '/'), MaximumBaseTrade = 100000000m, MaximumPrice = 100000000m, MaximumTrade = 100000000m, MinimumBaseTrade = x.BaseMinTrade, MinimumPrice = 0.00000001m, MinimumTrade = 0.00000001m, Status = x.Status.ToString(), StatusMessage = x.StatusMessage, Symbol = x.Symbol, Id = x.TradePairId, TradeFee = x.BaseFee }); return(new ApiTradePairResult { Success = true, Data = new List <ApiTradePair>(results) }); }
public async Task <ActionResult> Index(int?id, string market, string basemarket = "BTC") { var viewModel = new ExchangeModel(); var baseCurrencies = await CurrencyReader.GetBaseCurrencies(); var baseMarket = baseCurrencies.FirstOrDefault(x => x.Symbol == basemarket) ?? baseCurrencies.FirstOrDefault(x => x.Symbol == "BTC"); var tradePair = id.HasValue ? await TradePairReader.GetTradePair(id.Value) : await TradePairReader.GetTradePair(market); viewModel.TradePair = tradePair; viewModel.BaseCurrencies = baseCurrencies; viewModel.BaseMarket = baseMarket?.Symbol ?? "BTC"; if (viewModel.TradePair == null) { viewModel.TradePair = new TradePairModel(); viewModel.Summary = await ExchangeReader.GetExchangeSummary(); viewModel.Summary.BaseMarket = baseMarket?.Symbol ?? "BTC"; } return(View("Exchange", viewModel)); }
public async Task <ApiUserOpenOrdersResponse> GetUserOpenOrders(ApiUserOpenOrdersRequest request) { if (request.TradePairId.HasValue || !string.IsNullOrEmpty(request.Market)) { var tradepair = request.TradePairId.HasValue ? await TradePairReader.GetTradePair(request.TradePairId.Value, true).ConfigureAwait(false) : await TradePairReader.GetTradePair(request.Market.Replace('/', '_'), true).ConfigureAwait(false); if (tradepair == null) { return new ApiUserOpenOrdersResponse { Success = false, Error = "Market not found." } } ; using (var context = ExchangeDataContextFactory.CreateReadOnlyContext()) { var openOrders = context.Trade .AsNoTracking() .Where(x => x.UserId == request.UserId && x.TradePairId == tradepair.TradePairId && (x.Status == TradeStatus.Partial || x.Status == TradeStatus.Pending)) .OrderByDescending(x => x.Id) .Select(x => new ApiOpenOrder { Amount = x.Amount, Market = string.Concat(x.TradePair.Currency1.Symbol, "/", x.TradePair.Currency2.Symbol), OrderId = x.Id, Rate = x.Rate, Remaining = x.Remaining, TimeStamp = x.Timestamp, TradePairId = x.TradePairId, Type = x.Type.ToString() }); return(new ApiUserOpenOrdersResponse { Success = true, Data = await openOrders.ToListNoLockAsync().ConfigureAwait(false) }); } } else { using (var context = ExchangeDataContextFactory.CreateReadOnlyContext()) { var openOrders = context.Trade .AsNoTracking() .Where(x => x.UserId == request.UserId && (x.Status == TradeStatus.Partial || x.Status == TradeStatus.Pending)) .OrderByDescending(x => x.Id) .Select(x => new ApiOpenOrder { Amount = x.Amount, Market = string.Concat(x.TradePair.Currency1.Symbol, "/", x.TradePair.Currency2.Symbol), OrderId = x.Id, Rate = x.Rate, Remaining = x.Remaining, TimeStamp = x.Timestamp, TradePairId = x.TradePairId, Type = x.Type.ToString() }); return(new ApiUserOpenOrdersResponse { Success = true, Data = await openOrders.ToListNoLockAsync().ConfigureAwait(false) }); } } }
public async Task <ApiMarketsResult> GetMarkets(string baseMarket, int hours) { hours = Math.Min(hours, 168); var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ApiMarkets(baseMarket, hours), TimeSpan.FromSeconds(20), async() => { var lastTime = DateTime.UtcNow.AddHours(-hours); var tradePairs = await TradePairReader.GetTradePairs().ConfigureAwait(false); if (!tradePairs.Any()) { return new ApiMarketsResult { Error = $"Markets not found", Success = true, } } ; var markets = string.IsNullOrEmpty(baseMarket) ? tradePairs : tradePairs.Where(x => x.BaseSymbol == baseMarket).ToList(); using (var context = ExchangeDataContextFactory.CreateReadOnlyContext()) { var allTrades = await context.Trade .AsNoTracking() .Where(x => (x.Status == Enums.TradeStatus.Partial || x.Status == Enums.TradeStatus.Pending)) .Select(x => new { TradePairId = x.TradePairId, Type = x.Type, Rate = x.Rate, Amount = x.Amount }).ToListNoLockAsync().ConfigureAwait(false); var allTradeHistory = await context.TradeHistory .AsNoTracking() .Where(x => x.Timestamp > lastTime) .Select(x => new { Id = x.Id, TradePairId = x.TradePairId, Rate = x.Rate, Amount = x.Amount }) .OrderBy(x => x.Id) .ToListNoLockAsync().ConfigureAwait(false); var results = new ConcurrentBag <ApiMarket>(); foreach (var tradePair in markets) { var trades = allTrades .Where(x => x.TradePairId == tradePair.TradePairId) .Select(x => new { Type = x.Type, Rate = x.Rate, Amount = x.Amount }).ToList(); var tradeHistory = allTradeHistory .Where(x => x.TradePairId == tradePair.TradePairId) .Select(x => new { Id = x.Id, Rate = x.Rate, Amount = x.Amount }) .OrderBy(x => x.Id) .ToList(); var ask = 0m; var bid = 0m; var buyVolume = 0m; var sellVolume = 0m; var buyBaseVolume = 0m; var sellBaseVolume = 0m; if (trades.Any()) { var sellOrders = trades.Where(x => x.Type == Enums.TradeHistoryType.Sell).OrderBy(x => x.Rate).ToList(); if (sellOrders.Any()) { ask = sellOrders.First().Rate; sellVolume = Math.Round(sellOrders.Sum(x => x.Amount), 8); sellBaseVolume = Math.Round(sellOrders.Sum(x => x.Amount *x.Rate), 8); } var buyOrders = trades.Where(x => x.Type == Enums.TradeHistoryType.Buy).OrderByDescending(x => x.Rate).ToList(); if (buyOrders.Any()) { bid = buyOrders.First().Rate; buyVolume = Math.Round(buyOrders.Sum(x => x.Amount), 8); buyBaseVolume = Math.Round(buyOrders.Sum(x => x.Amount *x.Rate), 8); } } var change = 0m; var volume = 0m; var baseVolume = 0m; var open = tradePair.LastTrade; var close = tradePair.LastTrade; var high = tradePair.LastTrade; var low = tradePair.LastTrade; var last = tradePair.LastTrade; if (tradeHistory.Any()) { var firstTrade = tradeHistory.FirstOrDefault(); var lastTrade = tradeHistory.LastOrDefault(); high = tradeHistory.Max(x => x.Rate); low = tradeHistory.Min(x => x.Rate); open = firstTrade.Rate; close = lastTrade.Rate; last = lastTrade.Rate; change = open.GetPercentChanged(close); volume = tradeHistory.Sum(x => x.Amount); baseVolume = Math.Round(tradeHistory.Sum(x => x.Amount *x.Rate), 8); } results.Add(new ApiMarket { Label = tradePair.Market.Replace("_", "/"), TradePairId = tradePair.TradePairId, Change = open.GetPercentChanged(close), AskPrice = ask, BidPrice = bid, BuyVolume = buyVolume, SellVolume = sellVolume, LastPrice = last, High = high, Low = low, Volume = volume, Open = open, Close = close, BaseVolume = baseVolume, BuyBaseVolume = buyBaseVolume, SellBaseVolume = sellBaseVolume }); } return(new ApiMarketsResult { Success = true, Data = results.OrderBy(x => x.Label).ToList() }); } });
public async Task <ApiUserTradeHistoryResponse> GetUserTradeHistory(ApiUserTradeHistoryRequest request) { var count = Math.Min(request.Count ?? 100, 1000); if (request.TradePairId.HasValue || !string.IsNullOrEmpty(request.Market)) { var tradepair = request.TradePairId.HasValue ? await TradePairReader.GetTradePair(request.TradePairId.Value, true).ConfigureAwait(false) : await TradePairReader.GetTradePair(request.Market.Replace('/', '_'), true).ConfigureAwait(false); if (tradepair == null) { return new ApiUserTradeHistoryResponse { Success = false, Error = "Market not found." } } ; var cacheResult = await CacheService.GetOrSetMemoryAsync(CacheKey.ApiUserTradeHistory(request.UserId.ToString(), tradepair.TradePairId), TimeSpan.FromSeconds(1), async() => { using (var context = ExchangeDataContextFactory.CreateReadOnlyContext()) { var history = context.TradeHistory .AsNoTracking() .Where(x => x.TradePairId == tradepair.TradePairId && (x.UserId == request.UserId || x.ToUserId == request.UserId)) .OrderByDescending(x => x.Id) .Take(1000) .Select(x => new ApiTradeHistory { Market = string.Concat(x.TradePair.Currency1.Symbol, "/", x.TradePair.Currency2.Symbol), TradeId = x.Id, Amount = x.Amount, Rate = x.Rate, Type = x.UserId == request.UserId ? TradeHistoryType.Buy.ToString() : TradeHistoryType.Sell.ToString(), TimeStamp = x.Timestamp, TradePairId = x.TradePairId, Fee = x.Fee }); return(await history.ToListNoLockAsync().ConfigureAwait(false)); } }).ConfigureAwait(false); return(new ApiUserTradeHistoryResponse { Success = true, Data = cacheResult.Take(count).ToList() }); } else { var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ApiUserTradeHistory(request.UserId.ToString()), TimeSpan.FromSeconds(20), async() => { using (var context = ExchangeDataContextFactory.CreateReadOnlyContext()) { var history = context.TradeHistory .AsNoTracking() .Where(x => x.UserId == request.UserId || x.ToUserId == request.UserId) .OrderByDescending(x => x.Id) .Take(1000) .Select(x => new ApiTradeHistory { Market = string.Concat(x.TradePair.Currency1.Symbol, "/", x.TradePair.Currency2.Symbol), TradeId = x.Id, Amount = x.Amount, Rate = x.Rate, Type = x.UserId == request.UserId ? TradeHistoryType.Buy.ToString() : TradeHistoryType.Sell.ToString(), TimeStamp = x.Timestamp, TradePairId = x.TradePairId, Fee = x.Fee }); return(await history.ToListNoLockAsync().ConfigureAwait(false)); } }).ConfigureAwait(false); return(new ApiUserTradeHistoryResponse { Success = true, Data = cacheResult.Take(count).ToList() }); } }
public async Task <ActionResult> GetTradePairs(DataTablesModel param) { return(DataTable(await TradePairReader.GetTradePairDataTable(param))); }
public async Task <ExchangeSummary> GetExchangeSummary() { var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ExchangeSummary(), TimeSpan.FromSeconds(20), async() => { var tradeHistoryData = await GetOrCacheTradeHistory().ConfigureAwait(false); var tradePairs = await TradePairReader.GetTradePairs().ConfigureAwait(false); var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false); var baseCurrencies = await CurrencyReader.GetBaseCurrencies().ConfigureAwait(false); var summaryData = new List <ExchangeSummaryModel>(); foreach (var x in tradePairs) { var data = tradeHistoryData.Where(t => t.TradePairId == x.TradePairId); summaryData.Add(new ExchangeSummaryModel { TradePairId = x.TradePairId, Symbol = x.Symbol, BaseSymbol = x.BaseSymbol, TotalTrades = data.Count(), Low = (data.OrderBy(t => t.Rate).FirstOrDefault()?.Rate ?? x.LastTrade), High = (data.OrderByDescending(t => t.Rate).FirstOrDefault()?.Rate ?? x.LastTrade), Volume = data.Sum(t => t.Amount), TotalBase = data.Sum(t => t.Amount *t.Rate), Change = GetChangePercent(data.FirstOrDefault()?.Rate ?? x.LastTrade, x.LastTrade) }); } var now = DateTime.UtcNow; var baseData = summaryData.GroupBy(x => x.BaseSymbol); var totalVolume = baseData.Select(x => new { Symbol = x.Key, Total = x.Sum(u => u.TotalBase) }).ToList(); var topMarket = baseData.Select(x => x.MaxBy(u => u.TotalBase)).OrderBy(x => x.BaseSymbol).ToList(); var featured = currencies.Any(x => x.FeaturedExpires > now) ? currencies.Where(x => x.FeaturedExpires > now).ToList() : currencies.Where(x => x.CurrencyId == Constant.DOTCOIN_ID).ToList(); var baseCurrencyData = new List <ExchangeSummaryBaseCurrency>(); foreach (var currency in baseCurrencies) { var totalVol = totalVolume.FirstOrDefault(x => x.Symbol == currency.Symbol); baseCurrencyData.Add(new ExchangeSummaryBaseCurrency { CurrencyId = currency.CurrencyId, Name = currency.Name, Symbol = currency.Symbol, TotalVolume = totalVol != null ? totalVol.Total : 0, Rank = currency.Rank }); } return(new ExchangeSummary { TopMarkets = topMarket, BaseCurrencies = baseCurrencyData, TotalMarkets = tradePairs.Count, TotalTrades = summaryData.Sum(x => x.TotalTrades), Featured = featured.Select(x => new FeaturedCurrency { Name = x.Name, Symbol = x.Symbol, Website = x.Website, Summary = x.Summary }).ToList() }); }).ConfigureAwait(false); return(cacheResult); }
public async Task <ActionResult> GetTradePairs(DataTablesModel model) { return(DataTable(await TradePairReader.AdminGetTradePairs(model))); }