public void SendAccountChangedEvent(string source, IAccount account, AccountChangedEventTypeContract eventType,
string operationId, AccountBalanceChangeContract balanceChangeContract = null,
IAccount previousSnapshot = null,
string orderId = null)
{
var metadata = new AccountChangeMetadata {
OrderId = orderId
};
if (previousSnapshot != null)
{
metadata.PreviousAccountSnapshot =
_convertService.Convert <IAccount, AccountContract>(previousSnapshot);
}
CqrsEngine.PublishEvent(
new AccountChangedEvent(
account.ModificationTimestamp,
source,
_convertService.Convert <IAccount, AccountContract>(account),
eventType,
balanceChangeContract,
operationId,
metadata.ToJson()),
_contextNames.AccountsManagement);
}
public async Task <List <AssetPairContract> > List()
{
//Some filters are ignored because they are not relevant anymore
var data = await _assetPairsService.GetAllIncludingFxParisWithFilterAsync();
return(data.Select(x => _convertService.Convert <IAssetPair, AssetPairContract>(x)).ToList());
}
private async Task <CommandHandlingResult> Handle(SuspendAssetPairCommand command,
IEventPublisher publisher)
{
//idempotency handling not required
var updateResult = await _productsDiscontinueService.ChangeSuspendStatusAsync(command.AssetPairId,
true,
username,
command.OperationId);
if (!updateResult.IsSuccess)
{
return(CommandHandlingResult.Fail(_delay));
}
_chaosKitty.Meow(command.OperationId);
var assetPair =
AssetPair.CreateFromProduct(updateResult.NewValue, _defaultLegalEntitySettings.DefaultLegalEntity);
publisher.PublishEvent(new AssetPairChangedEvent
{
OperationId = command.OperationId,
AssetPair = _convertService.Convert <IAssetPair, AssetPairContract>(assetPair),
});
publisher.PublishEvent(CreateProductChangedEvent(updateResult.OldValue,
updateResult.NewValue,
username,
command.OperationId));
return(CommandHandlingResult.Ok());
}
public async Task <bool> TryInsertAsync(ITradingInstrument tradingInstrument)
{
using (var conn = new SqlConnection(_connectionString))
{
try
{
if (null != await conn.QueryFirstOrDefaultAsync <TradingInstrumentEntity>(
$"SELECT * FROM {TableName} WHERE TradingConditionId=@tradingConditionId AND Instrument=@assetPairId",
new
{
tradingConditionId = tradingInstrument.TradingConditionId,
assetPairId = tradingInstrument.Instrument
}))
{
return(false);
}
await conn.ExecuteAsync(
$"insert into {TableName} ({GetColumns}) values ({GetFields})",
_convertService.Convert <ITradingInstrument, TradingInstrumentEntity>(tradingInstrument));
}
catch (Exception ex)
{
_log?.WriteWarningAsync(nameof(AssetPairsRepository), nameof(TryInsertAsync),
$"Failed to insert a trading instrument with assetPairId {tradingInstrument.Instrument} and tradingConditionId {tradingInstrument.TradingConditionId}", ex);
return(false);
}
return(true);
}
}
public async Task Handle(UnderlyingChangedEvent e)
{
switch (e.ChangeType)
{
case ChangeType.Creation:
_underlyingsCache.AddOrUpdateByMdsCode(
_convertService.Convert <UnderlyingContract, UnderlyingsCacheModel>(e.NewValue));
break;
case ChangeType.Edition:
var model = _convertService.Convert <UnderlyingContract, UnderlyingsCacheModel>(e.NewValue);
await UpdateUnderlyingsCache(e, model);
await HandleMdsCodeChanged(e);
await _legacyAssetsCacheUpdater.HandleUnderlyingUpdated(e.OldValue.MdsCode, model, e.Timestamp);
break;
case ChangeType.Deletion:
_underlyingsCache.Remove(
_convertService.Convert <UnderlyingContract, UnderlyingsCacheModel>(e.OldValue));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task AddAsync(IAccountBalanceChange change)
{
var entity = _convertService.Convert <AccountBalanceChangeEntity>(change);
// ReSharper disable once RedundantArgumentDefaultValue
await _tableStorage.InsertAndGenerateRowKeyAsDateTimeAsync(entity, entity.ChangeTimestamp,
RowKeyDateTimeFormat.Iso);
}
private CrossRateCalcInfoModel Convert([CanBeNull] CrossRateCalcInfo settings)
{
if (settings == null)
{
return(null);
}
return(_convertService.Convert <CrossRateCalcInfo, CrossRateCalcInfoModel>(settings));
}
public async Task <List <TradingConditionContract> > List([FromQuery] bool?isDefault = null)
{
var data = await _tradingConditionsRepository.GetAsync();
return(data
.Where(x => isDefault == null || x.IsDefault == isDefault)
.Select(x => _convertService.Convert <ITradingCondition, TradingConditionContract>(x)).ToList());
}
public void PublishGlobalVars(string key, object value, IActionParameter actionParameters)
{
_ = actionParameters ?? throw new ArgumentNullException(nameof(actionParameters));
object dynamicKey = dynamicValueService.GetDynamicValue(key, actionParameters);
string dynamicKeyText = (string)convertService.Convert(dynamicKey, typeof(string));
object dynamicValue = dynamicValueService.GetDynamicValue(value, actionParameters);
actionParameters.GlobalVars[dynamicKeyText] = dynamicValue;
}
public async Task <List <TradingConditionContract> > List([FromQuery] bool?isDefault = null)
{
var data = isDefault.HasValue ?
await _tradingConditionsService.GetByDefaultFilterAsync(isDefault.Value):
await _tradingConditionsService.GetAsync();
return(data
.Select(x => _convertService.Convert <ITradingCondition, TradingConditionContract>(x)).ToList());
}
public async Task <List <ScheduleSettingsContract> > List([FromQuery] string marketId = null)
{
var data = await _scheduleSettingsService.GetFilteredAsync(marketId);
return(data
.Select(x => _convertService.Convert <IScheduleSettings, ScheduleSettings>(x))
.Select(x => _convertService.Convert <ScheduleSettings, ScheduleSettingsContract>(x))
.ToList());
}
public async Task <bool> WillViolateRegulationConstraintAsync(
[FromQuery] CheckRegulationConstraintViolationRequest request)
{
var model =
_convertService.Convert <CheckRegulationConstraintViolationRequest, RegulatorySettingsDto>(request);
var response = await _clientProfileSettingsService
.WillViolateRegulationConstraintAfterRegulatorySettingsUpdateAsync(model);
return(response);
}
private ExtPriceStatusModel Convert(string assetPairId, string exchangeName, ExchangeQuality exchangeQuality, bool isPrimary, BestPrices bestPrice)
{
var model = _convertService.Convert <ExchangeQuality, ExtPriceStatusModel>(exchangeQuality,
o => o.ConfigureMap(MemberList.Source));
model.AssetPairId = assetPairId;
model.ExchangeName = exchangeName;
model.IsPrimary = isPrimary;
model.ErrorState = model.ErrorState ?? "NoOrderbook";
model.BestPrices = _convertService.Convert <BestPrices, BestPricesModel>(bestPrice);
return(model);
}
public async Task <PaginatedResponseContract <AuditContract> > GetAuditTrailAsync([FromQuery] GetAuditLogsRequest request, int?skip = null, int?take = null)
{
var filter = _convertService.Convert <GetAuditLogsRequest, AuditLogsFilterDto>(request);
var result = await _auditService.GetAll(filter, skip, take);
return(new PaginatedResponseContract <AuditContract>(
result.Contents.Select(i => _convertService.Convert <AuditModel, AuditContract>(i)).ToList(),
result.Start,
result.Size,
result.TotalSize
));
}
private ExchangeExtPriceSettingsModel Convert(string assetPairId, string exchangeName, [CanBeNull] ExchangeExtPriceSettings settings)
{
if (settings == null)
{
return(null);
}
var model = _convertService.Convert <ExchangeExtPriceSettings, ExchangeExtPriceSettingsModel>(settings, o => o.ConfigureMap(MemberList.Source));
model.ExchangeName = exchangeName;
model.AssetPairId = assetPairId;
return(model);
}
private async Task PublishMarketSettingsChangedEvent
(MarketSettings oldSettings, MarketSettings newSettings, string username, string correlationId, ChangeType changeType)
{
await _cqrsMessageSender.SendEvent(new MarketSettingsChangedEvent
{
Username = username,
ChangeType = changeType,
CorrelationId = correlationId,
EventId = Guid.NewGuid().ToString(),
Timestamp = DateTime.UtcNow,
OldMarketSettings = _convertService.Convert <MarketSettings, MarketSettingsContract>(oldSettings),
NewMarketSettings = _convertService.Convert <MarketSettings, MarketSettingsContract>(newSettings),
});
}
private async Task PublishCurrencyChangedEvent
(Currency oldCurrency, Currency newCurrency, string username, string correlationId, ChangeType changeType)
{
await _cqrsMessageSender.SendEvent(new CurrencyChangedEvent()
{
Username = username,
ChangeType = changeType,
CorrelationId = correlationId,
EventId = Guid.NewGuid().ToString(),
Timestamp = DateTime.UtcNow,
OldValue = _convertService.Convert <Currency, CurrencyContract>(oldCurrency),
NewValue = _convertService.Convert <Currency, CurrencyContract>(newCurrency),
});
}
public async Task <List <AssetPairContract> > List([FromQuery] string legalEntity = null,
[FromQuery] MatchingEngineModeContract?matchingEngineMode = null, string filter = null)
{
var data = await _assetPairsRepository.GetByLeAndMeModeAsync(legalEntity, matchingEngineMode?.ToString(),
filter);
return(data.Select(x => _convertService.Convert <IAssetPair, AssetPairContract>(x)).ToList());
}
private async Task PublishProductCategoryChangedEvent(ProductCategory oldCategory, ProductCategory newCategory,
string username, string correlationId, ChangeType changeType, string originalCategoryName = null)
{
await _cqrsMessageSender.SendEvent(new ProductCategoryChangedEvent()
{
Username = username,
ChangeType = changeType,
CorrelationId = correlationId,
EventId = Guid.NewGuid().ToString(),
Timestamp = DateTime.UtcNow,
OldValue = _convertService.Convert <ProductCategory, ProductCategoryContract>(oldCategory),
NewValue = _convertService.Convert <ProductCategory, ProductCategoryContract>(newCategory),
OriginalCategoryName = originalCategoryName,
});
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string result;
if (value != null && value is OrderStatus)
{
result = convertService.Convert((OrderStatus)value);
}
else
{
throw new ArgumentOutOfRangeException();
}
return(result);
}
private AssetPairExtPriceSettingsModel Convert(string assetPairId,
[CanBeNull] AssetPairExtPriceSettings setting)
{
if (setting == null)
{
return(null);
}
var model = _convertService.Convert <AssetPairExtPriceSettings, AssetPairExtPriceSettingsModel>(setting,
o => o.ConfigureMap(MemberList.Source).ForSourceMember(s => s.Exchanges, e => e.Ignore()));
model.AssetPairId = assetPairId;
model.Steps = Convert(_extPricesSettingsService.GetDefaultSteps().SetItems(setting.Steps));
return(model);
}
public async Task <List <TradingInstrumentContract> > List([FromQuery] string tradingConditionId)
{
var data = string.IsNullOrWhiteSpace(tradingConditionId)
? await _tradingInstrumentsRepository.GetAsync()
: await _tradingInstrumentsRepository.GetByTradingConditionAsync(tradingConditionId);
return(data.Select(x => _convertService.Convert <ITradingInstrument, TradingInstrumentContract>(x)).ToList());
}
public async Task <GetAssetTypeByIdResponse> GetAssetTypeByIdAsync([FromRoute][Required] string id)
{
var response = new GetAssetTypeByIdResponse();
var type = await _assetTypesService.GetByIdAsync(id);
if (type == null)
{
response.ErrorCode = ClientProfilesErrorCodesContract.AssetTypeDoesNotExist;
return(response);
}
response.AssetType = _convertService.Convert <AssetType, AssetTypeContract>(type);
return(response);
}
private async Task SendEntityChangedEvent <TModel, TContract, TEvent>(TModel oldValue, TModel newValue,
string username, string correlationId, ChangeType changeType)
where TEvent : EntityChangedEvent <TContract>, new()
where TModel : class
{
await _messageSender.SendEvent(new TEvent()
{
Username = username,
ChangeType = changeType,
CorrelationId = correlationId,
EventId = Guid.NewGuid().ToString(),
Timestamp = DateTime.UtcNow,
OldValue = _convertService.Convert <TModel, TContract>(oldValue),
NewValue = _convertService.Convert <TModel, TContract>(newValue),
});
}
public async Task AddAsync(IAccountBalanceChange change)
{
var entity = _convertService.Convert <AccountBalanceChangeEntity>(change);
using (var conn = new SqlConnection(_settings.Db.ConnectionString))
{
try
{
try
{
await conn.ExecuteAsync(
$"insert into {TableName} ({GetColumns}) values ({GetFields})", entity);
}
catch (SqlException)
{
await conn.ExecuteAsync(
$"update {TableName} set {GetUpdateClause} where Id=@Id", entity);
}
}
catch (Exception ex)
{
var msg = $"Error {ex.Message} \n" +
"Entity <AccountBalanceChangeEntity>: \n" +
entity.ToJson();
await _log.WriteWarningAsync(nameof(AccountBalanceChangesRepository), nameof(AddAsync), null, msg);
throw new Exception(msg);
}
}
}
private Task HandleStpOrderbook(ExternalExchangeOrderbookMessage message)
{
var orderbook = _convertService.Convert <ExternalExchangeOrderbookMessage, ExternalOrderBook>(message);
_externalOrderbookService.SetOrderbook(orderbook);
return(Task.CompletedTask);
}
public async Task <GetClientProfileByIdResponse> GetClientProfileByIdAsync([FromRoute][Required] string id)
{
var response = new GetClientProfileByIdResponse();
var profile = await _regulatoryProfilesService.GetByIdAsync(id);
if (profile == null)
{
response.ErrorCode = ClientProfilesErrorCodesContract.ClientProfileDoesNotExist;
return(response);
}
response.ClientProfile = _convertService.Convert <ClientProfile, ClientProfileContract>(profile);
return(response);
}
public async Task Handle(ProductChangedEvent e)
{
switch (e.ChangeType)
{
case ChangeType.Creation:
case ChangeType.Edition:
if (!e.NewValue.IsStarted)
{
return;
}
await _legacyAssetsCacheUpdater.HandleProductUpserted(_convertService.Convert <ProductContract, Product>(e.NewValue), e.Timestamp);
break;
case ChangeType.Deletion:
if (!e.OldValue.IsStarted)
{
return;
}
await _legacyAssetsCacheUpdater.HandleProductRemoved(e.OldValue.ProductId, e.Timestamp);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private async Task <CommandHandlingResult> Handle(SuspendAssetPairCommand command,
IEventPublisher publisher)
{
//idempotency handling not required
var assetPair = await _assetPairsRepository.ChangeSuspendFlag(command.AssetPairId, true);
_chaosKitty.Meow(command.OperationId);
publisher.PublishEvent(new AssetPairChangedEvent
{
OperationId = command.OperationId,
AssetPair = _convertService.Convert <IAssetPair, AssetPairContract>(assetPair),
});
return(CommandHandlingResult.Ok());
}
private static MarginTradingAccount Convert(AccountContract accountContract)
{
return(ConvertService.Convert <AccountContract, MarginTradingAccount>(accountContract,
o => o.ConfigureMap(MemberList.Source)
.ForMember(d => d.LastUpdateTime,
a => a.MapFrom(x =>
x.ModificationTimestamp))));
}
