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)))); }