public async Task <Dictionary <string, TradingDayInfoContract> > GetMarketsInfo([FromBody] string[] marketIds = null,
[FromQuery] DateTime?date = null)
{
var allMarkets = (await _marketRepository.GetAsync()).Select(x => x.Id).ToHashSet();
if (marketIds == null || !marketIds.Any())
{
marketIds = allMarkets.ToArray();
}
else
{
foreach (var marketId in marketIds)
{
if (allMarkets.Contains(marketId))
{
continue;
}
throw new ArgumentException($"Market {marketId} does not exist", nameof(marketIds));
}
}
var info = await _marketDayOffService.GetMarketsInfo(marketIds, date);
return(info.ToDictionary(k => k.Key, v => new TradingDayInfoContract()
{
IsTradingEnabled = v.Value.IsTradingEnabled,
LastTradingDay = v.Value.LastTradingDay,
NextTradingDayStart = v.Value.NextTradingDayStart
}));
}
public async Task <Market[]> GetMarketsAsync(Expression <Func <Market, bool> > expression, int skip, int take)
{
var items = await _repository.GetAsync(expression, skip, take);
if (items.Length == 0)
{
throw new NotFoundException(ErrorCode.MarketNotFount);
}
return(items);
}
public async Task Handle(ExchangeOrderBookUpdatedIntegrationEvent @event)
{
try
{
var quoteCurrency = @event.QuoteCurrency.ToUpper() == "USDT" ? "USD" : @event.QuoteCurrency.ToUpper();
var baseCurrency = @event.BaseCurrency.ToUpper();
var marketId = new MarketId(baseCurrency, quoteCurrency);
var market = await _marketRepository.GetAsync(marketId);
var exchange = await _exchangeRepository.GetAsync(@event.ExchangeId);
var bids = @event.OrderBook.bids.AsEnumerable().Take(1).ToOrderPriceAndQuantitys();
var asks = @event.OrderBook.asks.AsEnumerable().Take(1).ToOrderPriceAndQuantitys();
market.UpdateExchangeMarket(exchange, bids, asks);
await _marketRepository.Update(market);
}
catch (Exception ex)
{
Debug.Write("Handle Event: ExchangeOrderBookUpdatedIntegrationEvent." +
"Result: Failure." +
"Error Message: " + ex.Message
);
throw ex;
}
//var askList = @event.OrderBook.asks;
}
private async Task ValidatePairInsert(AssetPairContract assetPair)
{
if (assetPair == null)
{
throw new ArgumentNullException(nameof(assetPair), "Model is incorrect");
}
if (string.IsNullOrWhiteSpace(assetPair.Id))
{
throw new ArgumentNullException(nameof(assetPair.Id), "AssetPair Id must be set");
}
if (!Enum.IsDefined(typeof(MatchingEngineModeContract), assetPair.MatchingEngineMode))
{
throw new ArgumentNullException(nameof(assetPair.MatchingEngineMode), "AssetPair MatchingEngineMode must be set");
}
if (await _assetsRepository.GetAsync(assetPair.BaseAssetId) == null)
{
throw new InvalidOperationException($"Base Asset {assetPair.BaseAssetId} does not exist");
}
if (await _assetsRepository.GetAsync(assetPair.QuoteAssetId) == null)
{
throw new InvalidOperationException($"Quote Asset {assetPair.QuoteAssetId} does not exist");
}
if (!string.IsNullOrEmpty(assetPair.MarketId) &&
await _marketRepository.GetAsync(assetPair.MarketId) == null)
{
throw new InvalidOperationException($"Market {assetPair.MarketId} does not exist");
}
if (assetPair.StpMultiplierMarkupAsk <= 0)
{
throw new InvalidOperationException($"StpMultiplierMarkupAsk must be greater then zero");
}
if (assetPair.StpMultiplierMarkupBid <= 0)
{
throw new InvalidOperationException($"StpMultiplierMarkupBid must be greater then zero");
}
if (await _assetPairsRepository.GetByBaseQuoteAndLegalEntityAsync(assetPair.BaseAssetId,
assetPair.QuoteAssetId, assetPair.LegalEntity) != null)
{
throw new InvalidOperationException($"Asset pair with base asset [{assetPair.BaseAssetId}], quote asset [{assetPair.QuoteAssetId}] and legal entity [{assetPair.LegalEntity}] already exists");
}
//base pair check <-- the last one
if (assetPair.BasePairId == null)
{
return;
}
if (await _assetPairsRepository.GetAsync(assetPair.BasePairId) == null)
{
throw new InvalidOperationException($"BasePair with Id {assetPair.BasePairId} does not exist");
}
if (await _assetPairsRepository.GetByBaseAssetPairAsync(assetPair.BasePairId) != null)
{
throw new InvalidOperationException($"BasePairId {assetPair.BasePairId} does not exist");
}
if (await _assetPairsRepository.GetByBaseAssetPairAndNotByIdAsync(assetPair.Id, assetPair.BasePairId) != null)
{
throw new InvalidOperationException($"BasePairId {assetPair.BasePairId} cannot be added twice");
}
}
public async Task <List <MarketContract> > List()
{
var data = await _marketRepository.GetAsync();
return(data.Select(x => _convertService.Convert <IMarket, MarketContract>(x)).ToList());
}
