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)));
}
