public async Task <InitDataBackendResponse> InitData([FromBody] ClientIdBackendRequest request)
{
if (string.IsNullOrWhiteSpace(request?.ClientId))
{
throw new ArgumentNullException(nameof(ClientIdBackendRequest.ClientId));
}
var accounts = _accountsCacheService.GetAll(request.ClientId).ToArray();
if (accounts.Length == 0 && !_marginSettings.IsLive)
{
accounts = await _accountManager.CreateDefaultAccounts(request.ClientId);
}
if (accounts.Length == 0)
{
return(InitDataBackendResponse.CreateEmpty());
}
var assets = _accountAssetsCacheService.GetClientAssets(accounts);
var result = BackendContractFactory.CreateInitDataBackendResponse(accounts, assets, _marginSettings.IsLive);
result.IsLive = _marginSettings.IsLive;
return(result);
}
public async Task <OpenOrderBackendResponse> PlaceOrder([FromBody] OpenOrderBackendRequest request)
{
var code = await _identityGenerator.GenerateIdAsync(nameof(Order));
var order = new Order
{
Id = Guid.NewGuid().ToString("N"),
Code = code,
CreateDate = DateTime.UtcNow,
ClientId = request.ClientId,
AccountId = request.Order.AccountId,
Instrument = request.Order.Instrument,
Volume = request.Order.Volume,
ExpectedOpenPrice = request.Order.ExpectedOpenPrice,
TakeProfit = request.Order.TakeProfit,
StopLoss = request.Order.StopLoss
};
var placedOrder = await _tradingEngine.PlaceOrderAsync(order);
var result = BackendContractFactory.CreateOpenOrderBackendResponse(placedOrder);
_consoleWriter.WriteLine($"action order.place for clientId = {request.ClientId}");
_operationsLogService.AddLog("action order.place", request.ClientId, request.Order.AccountId, request.ToJson(), result.ToJson());
return(result);
}
public ClientOrdersBackendResponse GetClientOrders([FromBody] ClientIdBackendRequest request)
{
var accountIds = _accountsCacheService.GetAll(request.ClientId).Select(item => item.Id).ToArray();
var positions = _ordersCache.ActiveOrders.GetOrdersByAccountIds(accountIds).ToList();
var orders = _ordersCache.WaitingForExecutionOrders.GetOrdersByAccountIds(accountIds).ToList();
var result = BackendContractFactory.CreateClientOrdersBackendResponse(positions, orders);
return(result);
}
public InitChartDataBackendResponse InitGraph([FromBody] InitChartDataBackendRequest request)
{
var chartData = _micrographCacheService.GetGraphData();
if (request?.AssetIds?.Length > 0)
{
chartData = chartData.Where(d => request.AssetIds.Contains(d.Key))
.ToDictionary(k => k.Key, v => v.Value);
}
return(BackendContractFactory.CreateInitChartDataBackendResponse(chartData));
}
public InitAccountInstrumentsBackendResponse AccountInstruments([FromBody] ClientIdBackendRequest request)
{
var accounts = _accountsCacheService.GetAll(request.ClientId).ToArray();
if (accounts.Length == 0)
{
return(InitAccountInstrumentsBackendResponse.CreateEmpty());
}
var accountAssets = _accountAssetsCacheService.GetClientAssets(accounts);
var result = BackendContractFactory.CreateInitAccountInstrumentsBackendResponse(accountAssets);
return(result);
}
public async Task <AccountHistoryBackendResponse> GetAccountHistory(string clientId, string accountId)
{
var now = DateTime.UtcNow;
var accounts = (await _accountsHistoryRepository.GetAsync(new[] { accountId }, now.AddYears(-1), now))
.Where(item => item.Type != AccountHistoryType.OrderClosed)
.OrderByDescending(item => item.Date);
var historyOrders = (await _ordersHistoryRepository.GetHistoryAsync(clientId, new[] { accountId }, now.AddYears(-1), now))
.Where(item => item.Status != OrderStatus.Rejected);
var openPositions = _ordersCache.ActiveOrders.GetOrdersByAccountIds(accountId);
return(BackendContractFactory.CreateAccountHistoryBackendResponse(accounts, openPositions, historyOrders));
}
public async Task <AccountNewHistoryBackendResponse> GetHistory([FromBody] AccountHistoryBackendRequest request)
{
var clientAccountIds = string.IsNullOrEmpty(request.AccountId)
? _accountsCacheService.GetAll(request.ClientId).Select(item => item.Id).ToArray()
: new[] { request.AccountId };
var accounts = (await _accountsHistoryRepository.GetAsync(clientAccountIds, request.From, request.To))
.Where(item => item.Type != AccountHistoryType.OrderClosed);
var openOrders = _ordersCache.ActiveOrders.GetOrdersByAccountIds(clientAccountIds);
var historyOrders = (await _ordersHistoryRepository.GetHistoryAsync(request.ClientId, clientAccountIds, request.From, request.To))
.Where(item => item.Status != OrderStatus.Rejected);
var result = BackendContractFactory.CreateAccountNewHistoryBackendResponse(accounts, openOrders, historyOrders);
return(result);
}
public OrderbooksBackendResponse GetOrderBooks([FromBody] OrderbooksBackendRequest request)
{
//TODO: handle different MEs
return(BackendContractFactory.CreateOrderbooksBackendResponse(_matchingEngine.GetOrderBook(request.Instrument)));
}
public InitChartDataBackendResponse InitChardData()
{
var chartData = _micrographCacheService.GetGraphData();
return(BackendContractFactory.CreateInitChartDataBackendResponse(chartData));
}
