public async Task <IActionResult> PlaceMarketOrder(PlaceMarketOrderModel order)
{
var assetPair = _assetPairsReadModel.TryGetIfEnabled(order.AssetPairId);
if (assetPair == null)
{
return(NotFound($"Asset-pair {order.AssetPairId} could not be found or is disabled."));
}
if (!_requestValidator.ValidateAssetPair(order.AssetPairId, assetPair, out var badRequestModel))
{
return(BadRequest(badRequestModel));
}
var baseAsset = _assetsReadModel.TryGetIfEnabled(assetPair.BaseAssetId);
var quotingAsset = _assetsReadModel.TryGetIfEnabled(assetPair.QuotingAssetId);
if (!_requestValidator.ValidateAsset(assetPair, order.Asset, baseAsset, quotingAsset, out badRequestModel))
{
return(BadRequest(badRequestModel));
}
var straight = order.Asset == baseAsset.Id || order.Asset == baseAsset.DisplayId;
var asset = straight ? baseAsset : quotingAsset;
var volume = order.Volume;
var minVolume = straight ? assetPair.MinVolume : assetPair.MinInvertedVolume;
if (!_requestValidator.ValidateVolume(volume, minVolume, asset.DisplayId, out badRequestModel))
{
return(BadRequest(badRequestModel));
}
var walletId = User.GetUserId();
var response = await _matchingEngineAdapter.PlaceMarketOrderAsync(
clientId : walletId,
assetPair : assetPair,
orderAction : order.OrderAction,
volume : volume,
straight : straight,
reservedLimitVolume : null);
if (response.Error != null)
{
return(BadRequest(response));
}
return(Ok(response.Result));
}
public async Task CreateMissedAsync(string userId)
{
string source = _quoteService.GetSources().FirstOrDefault();
IReadOnlyCollection <Balance> balances = await _balanceService.GetAsync();
foreach (Balance balance in balances)
{
if (balance.Amount <= 0)
{
continue;
}
Asset asset = _assetsReadModelRepository.TryGetIfEnabled(balance.AssetId);
if (asset == null)
{
continue;
}
AssetPair assetPair = _assetPairsReadModelRepository.GetAllEnabled()
.FirstOrDefault(o => o.BaseAssetId == asset.Id && o.QuotingAssetId == "USD");
if (assetPair == null)
{
continue;
}
IReadOnlyCollection <Instrument> instruments = await GetAllAsync();
Instrument instrument = instruments.FirstOrDefault(o => o.AssetPairId == assetPair.Id);
if (instrument != null)
{
continue;
}
instrument = new Instrument
{
AssetPairId = assetPair.Id,
QuoteSource = source,
Markup = 0,
Levels = 1,
MinSpread = .2m,
MaxSpread = .8m,
Mode = InstrumentMode.Disabled,
IsApproved = false
};
await _instrumentRepository.InsertAsync(instrument);
_cache.Set(instrument);
}
_log.InfoWithDetails("Missed instruments created", new { userId });
}
public async Task <IActionResult> GetTrades(string assetId, string assetPairId = null, int?skip = 0, int?take = 100)
{
var toTake = take.ValidateAndGetValue(nameof(take), MaxPageSize, 100);
if (toTake.Error != null)
{
return(BadRequest(new ResponseModel {
Error = toTake.Error
}));
}
var toSkip = skip.ValidateAndGetValue(nameof(skip), MaxSkipSize, 0);
if (toSkip.Error != null)
{
return(BadRequest(new ResponseModel {
Error = toSkip.Error
}));
}
if (assetId != null && _assetsReadModel.TryGetIfEnabled(assetId) == null)
{
return(NotFound());
}
if (assetPairId != null && _assetPairsReadModel.TryGetIfEnabled(assetPairId) == null)
{
return(NotFound());
}
var walletId = Guid.Parse(User.GetUserId());
var response = await _historyClient.HistoryApi.GetHistoryByWalletAsync(
walletId : walletId,
new[] { HistoryType.Trade },
assetId : assetId,
assetPairId : assetPairId,
offset : toSkip.Result,
limit : toTake.Result);
var result = response
.Cast <History.Contracts.History.TradeModel>()
.Select(ToModel);
return(Ok(result));
}
public async Task <IActionResult> GetBalances()
{
var clientId = User.GetUserId();
var balances = await _balancesClient.GetClientBalances(clientId);
var walletBalances = balances?.Select(x => new BalanceModel
{
AssetId = x.AssetId,
Balance = x.Balance,
Reserved = x.Reserved
}) ?? Enumerable.Empty <BalanceModel>();
foreach (var wallet in walletBalances)
{
var asset = _assetsReadModel.TryGetIfEnabled(wallet.AssetId);
if (asset != null)
{
wallet.Balance = wallet.Balance.TruncateDecimalPlaces(asset.Accuracy);
wallet.Reserved = wallet.Reserved.TruncateDecimalPlaces(asset.Accuracy);
}
}
return(Ok(walletBalances));
}
