public async Task <MtBackendResponse <IEnumerable <MarginTradingAccountModel> > > InitAccountGroup(
[FromBody] InitAccountGroupRequest request)
{
var tradingCondition = _tradingConditionsCacheService.GetTradingCondition(request.TradingConditionId);
if (tradingCondition == null)
{
return(MtBackendResponse <IEnumerable <MarginTradingAccountModel> > .Error(
$"No trading condition {request.TradingConditionId} found in cache"));
}
var accountGroup =
_accountGroupCacheService.GetAccountGroup(request.TradingConditionId, request.BaseAssetId);
if (accountGroup == null)
{
return(MtBackendResponse <IEnumerable <MarginTradingAccountModel> > .Error(
$"No account group {request.TradingConditionId}_{request.BaseAssetId} found in cache"));
}
var newAccounts = await _accountManager.CreateAccounts(request.TradingConditionId, request.BaseAssetId);
return(MtBackendResponse <IEnumerable <MarginTradingAccountModel> > .Ok(
newAccounts.Select(a => a.ToBackendContract())));
}
public async Task Invoke(HttpContext context)
{
var isMaintenanceMode = false;
try
{
isMaintenanceMode = !context.Request.Path.ToString().StartsWith("/swagger") &&
context.Request.Path != $"/api/service/{LykkeConstants.MaintenanceModeRoute}" &&
_maintenanceModeService.CheckIsEnabled();
}
catch (Exception ex)
{
await _log.WriteErrorAsync("MIDDLEWARE", "MaintenanceModeMiddleware", "", ex);
}
finally
{
if (!isMaintenanceMode)
{
await _next.Invoke(context);
}
else
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = 503;
var response = new MtBackendResponse <string> {
ErrorMessage = "Maintenance Mode"
};
await context.Response.WriteAsync(response.ToJson());
}
}
}
public async Task <MtBackendResponse <MarginTradingAccountModel> > SetTradingCondition(
[FromBody] SetTradingConditionModel model)
{
if (!_tradingConditionsCacheService.IsTradingConditionExists(model.TradingConditionId))
{
return(MtBackendResponse <MarginTradingAccountModel> .Error(
$"No trading condition {model.TradingConditionId} found in cache"));
}
var tradingCondition = _tradingConditionsCacheService.GetTradingCondition(model.TradingConditionId);
var account =
await _accountManager.SetTradingCondition(model.ClientId, model.AccountId, model.TradingConditionId);
if (account == null)
{
return(MtBackendResponse <MarginTradingAccountModel> .Error(
$"Account for client [{model.ClientId}] with id [{model.AccountId}] was not found"));
}
if (tradingCondition.LegalEntity != account.LegalEntity)
{
return(MtBackendResponse <MarginTradingAccountModel> .Error(
$"Account for client [{model.ClientId}] with id [{model.AccountId}] has LegalEntity " +
$"[{account.LegalEntity}], but trading condition wit id [{tradingCondition.Id}] has " +
$"LegalEntity [{tradingCondition.LegalEntity}]"));
}
return(MtBackendResponse <MarginTradingAccountModel> .Ok(account.ToBackendContract()));
}
public async Task <MtBackendResponse <AccountGroupModel> > AddOrReplaceAccountGroup(
[FromBody] AccountGroupModel model)
{
var accountGroup = await _accountGroupManager.AddOrReplaceAccountGroupAsync(model.ToDomainContract());
return(MtBackendResponse <AccountGroupModel> .Ok(accountGroup.ToBackendContract()));
}
public MtBackendResponse <bool> ChangeOrderLimits([FromBody] ChangeOrderLimitsBackendRequest request)
{
var order = _ordersCache.GetOrderById(request.OrderId);
if (_assetDayOffService.IsDayOff(order.Instrument))
{
return(new MtBackendResponse <bool> {
Message = "Trades for instrument are not available"
});
}
try
{
_tradingEngine.ChangeOrderLimits(request.OrderId, request.StopLoss, request.TakeProfit,
request.ExpectedOpenPrice);
}
catch (ValidateOrderException ex)
{
return(new MtBackendResponse <bool> {
Result = false, Message = ex.Message
});
}
var result = new MtBackendResponse <bool> {
Result = true
};
_consoleWriter.WriteLine($"action order.changeLimits for clientId = {request.ClientId}, orderId = {request.OrderId}");
_operationsLogService.AddLog("action order.changeLimits", request.ClientId, order.AccountId, request.ToJson(), result.ToJson());
return(result);
}
public async Task <MtBackendResponse <TradingConditionModel> > AddOrReplaceTradingCondition(
[FromBody] TradingConditionModel model)
{
if (string.IsNullOrWhiteSpace(model.Id))
{
return(MtBackendResponse <TradingConditionModel> .Error("Id cannot be empty"));
}
if (string.IsNullOrWhiteSpace(model.Name))
{
return(MtBackendResponse <TradingConditionModel> .Error("Name cannot be empty"));
}
if (string.IsNullOrWhiteSpace(model.LegalEntity))
{
return(MtBackendResponse <TradingConditionModel> .Error("LegalEntity cannot be empty"));
}
if (_tradingConditionsCacheService.IsTradingConditionExists(model.Id))
{
var existingCondition = _tradingConditionsCacheService.GetTradingCondition(model.Id);
if (existingCondition.LegalEntity != model.LegalEntity)
{
return(MtBackendResponse <TradingConditionModel> .Error("LegalEntity cannot be changed"));
}
}
var tradingCondition = model.ToDomainContract();
tradingCondition = await _tradingConditionsManager.AddOrReplaceTradingConditionAsync(tradingCondition);
return(MtBackendResponse <TradingConditionModel> .Ok(tradingCondition?.ToBackendContract()));
}
public static MtClientResponse <bool> ToClientContract(this MtBackendResponse <bool> src)
{
return(new MtClientResponse <bool>
{
Result = src.Result,
Message = src.Message
});
}
public MtBackendResponse <bool> RemoveFromBestFxPriceCache(string assetPairId)
{
var result = _fxRateCacheService.RemoveQuote(assetPairId);
return(result == RemoveQuoteErrorCode.None
? MtBackendResponse <bool> .Ok(true)
: MtBackendResponse <bool> .Error(result.Message));
}
private async Task SendError(HttpContext ctx, string errorMessage)
{
ctx.Response.ContentType = "application/json";
ctx.Response.StatusCode = 500;
var response = new MtBackendResponse <string> {
Result = "Technical problems", ErrorMessage = errorMessage
};
await ctx.Response.WriteAsync(response.ToJson());
}
public async Task <MtBackendResponse <IEnumerable <AccountAssetPairModel> > > AssignInstruments(
[FromBody] AssignInstrumentsRequest model)
{
try
{
var assetPairs = await _accountAssetsManager.AssignInstruments(model.TradingConditionId, model.BaseAssetId,
model.Instruments);
return(MtBackendResponse <IEnumerable <AccountAssetPairModel> > .Ok(
assetPairs.Select(a => a.ToBackendContract())));
}
catch (Exception e)
{
return(MtBackendResponse <IEnumerable <AccountAssetPairModel> > .Error(e.Message));
}
}
public MtBackendResponse <bool> RemoveFromBestPriceCache(string assetPairId)
{
var positions = _ordersCache.Positions.GetPositionsByInstrument(assetPairId).ToList();
if (positions.Any())
{
return(MtBackendResponse <bool> .Error(
$"Cannot delete [{assetPairId}] best price because there are {positions.Count} opened positions."));
}
var orders = _ordersCache.Active.GetOrdersByInstrument(assetPairId).ToList();
if (orders.Any())
{
return(MtBackendResponse <bool> .Error(
$"Cannot delete [{assetPairId}] best price because there are {orders.Count} active orders."));
}
_quoteCacheService.RemoveQuote(assetPairId);
return(MtBackendResponse <bool> .Ok(true));
}
public async Task <MtBackendResponse <bool> > CloseOrder([FromBody] CloseOrderBackendRequest request)
{
if (!_ordersCache.ActiveOrders.TryGetOrderById(request.OrderId, out var order))
{
return(new MtBackendResponse <bool> {
Message = "Order not found"
});
}
if (_assetDayOffService.IsDayOff(order.Instrument))
{
return(new MtBackendResponse <bool> {
Message = "Trades for instrument are not available"
});
}
if (order.ClientId != request.ClientId || order.AccountId != request.AccountId)
{
return(new MtBackendResponse <bool> {
Message = "Order is not available for user"
});
}
order = await _tradingEngine.CloseActiveOrderAsync(request.OrderId, OrderCloseReason.Close);
var result = new MtBackendResponse <bool>
{
Result = order.Status == OrderStatus.Closed || order.Status == OrderStatus.Closing,
Message = order.CloseRejectReasonText
};
_consoleWriter.WriteLine(
$"action order.close for clientId = {request.ClientId}, orderId = {request.OrderId}");
_operationsLogService.AddLog("action order.close", request.ClientId, order.AccountId, request.ToJson(),
result.ToJson());
return(result);
}
public MtBackendResponse <bool> CancelOrder([FromBody] CloseOrderBackendRequest request)
{
if (!_ordersCache.WaitingForExecutionOrders.TryGetOrderById(request.OrderId, out var order))
{
return(new MtBackendResponse <bool> {
Message = "Order not found"
});
}
if (_assetDayOffService.IsDayOff(order.Instrument))
{
return(new MtBackendResponse <bool> {
Message = "Trades for instrument are not available"
});
}
if (order.ClientId != request.ClientId || order.AccountId != request.AccountId)
{
return(new MtBackendResponse <bool> {
Message = "Order is not available for user"
});
}
_tradingEngine.CancelPendingOrder(order.Id, OrderCloseReason.Canceled);
var result = new MtBackendResponse <bool> {
Result = true
};
_consoleWriter.WriteLine(
$"action order.cancel for clientId = {request.ClientId}, orderId = {request.OrderId}");
_operationsLogService.AddLog("action order.cancel", request.ClientId, order.AccountId, request.ToJson(),
result.ToJson());
return(result);
}
public MtBackendResponse <bool> GetMaintenanceMode()
{
var result = _maintenanceModeService.CheckIsEnabled();
return(MtBackendResponse <bool> .Ok(result));
}
public MtBackendResponse <bool> SetMaintenanceMode([FromBody] bool enabled)
{
_maintenanceModeService.SetMode(enabled);
return(MtBackendResponse <bool> .Ok(enabled));
}
public MtBackendResponse <bool> ClearBestBriceCache(string assetPair)
{
_quoteCacheService.RemoveQuote(assetPair);
return(MtBackendResponse <bool> .Ok(true));
}
