private async Task CreateReceiptAsync(MessageHeader header, IssueReceiptCommandContent content)
{
var transactionId = header?.TransactionId;
var executedTransfer = new ExecutedTransfer(transactionId);
Event receiptIssued = executedTransfer.IssueReceipt();
await repository.AddAsync(executedTransfer);
await eventProducer.ProduceAsync(receiptIssued);
}
private async Task ValidateAsync(MessageHeader header, ValidateTransferCommandContent content)
{
var transactionId = header?.TransactionId;
var transaction = content?.Transaction;
var initialTransfer = new InitialTransfer(transactionId, transaction.AccountFromId, transaction.AccountToId, transaction.Amount);
Event validationEvent = initialTransfer.ValidateTransfer();
await repository.AddAsync(initialTransfer);
await eventProducer.ProduceAsync(validationEvent);
}
private async Task CancelTransfer(MessageHeader header, CancelTransferCommandContent content)
{
var transactionId = header?.TransactionId;
var transaction = content?.Transaction;
var initialTransfer = new InitialTransfer(transactionId, transaction.AccountFromId, transaction.AccountToId, transaction.Amount);
Event transferCanceled = initialTransfer.CancelTransfer();
await repository.AddAsync(initialTransfer);
await eventProducer.ProduceAsync(transferCanceled);
}
private async Task CancelTransferAsync(MessageHeader header, CancelTransferCommandContent content)
{
var transactionId = header?.TransactionId;
var transaction = content?.Transaction;
var transfer = new CheckingAccountTransfer();
Event tranferCancelled = transfer.CancelTranferAmountBetweenAccounts(transactionId, transaction.AccountFromId, transaction.AccountToId, transaction.Amount);
foreach (var line in transfer.CheckingAccountLines)
{
await repository.AddAsync(line);
}
await eventProducer.ProduceAsync(tranferCancelled);
}
public async Task SetMarginTradingEnabled(string clientId, bool enabled)
{
var settings = await _clientAccountClient.GetMarginEnabledAsync(clientId);
if (_marginSettings.IsLive)
{
settings.EnabledLive = enabled;
}
else
{
settings.Enabled = enabled;
}
await _clientAccountClient.SetMarginEnabledAsync(clientId, settings.Enabled, settings.EnabledLive,
settings.TermsOfUseAgreed);
var marginEnabledChangedMessage = new MarginTradingEnabledChangedMessage
{
ClientId = clientId,
EnabledDemo = settings.Enabled,
EnabledLive = settings.EnabledLive
};
_marginTradingSettingsCacheService.OnMarginTradingEnabledChanged(marginEnabledChangedMessage);
await _eventsPublisher.ProduceAsync(marginEnabledChangedMessage);
}
public Task ProcessNewExternalOrderbookAsync(ExternalExchangeOrderbookMessage orderbook)
{
if (string.IsNullOrEmpty(orderbook.AssetPairId) || string.IsNullOrEmpty(orderbook.ExchangeName))
{
return(Task.CompletedTask);
}
var settings = _settingsService.TryGetAssetPair(orderbook.ExchangeName, orderbook.AssetPairId);
if (settings == null || (orderbook.Bids?.Count ?? 0) == 0 || (orderbook.Asks?.Count ?? 0) == 0)
{
return(Task.CompletedTask);
}
orderbook.Bids.RemoveAll(e => e == null || e.Price <= 0 || e.Volume == 0);
orderbook.Asks.RemoveAll(e => e == null || e.Price <= 0 || e.Volume == 0);
orderbook.Bids.Sort((a, b) => - a.Price.CompareTo(b.Price));
orderbook.Asks.Sort((a, b) => a.Price.CompareTo(b.Price));
var now = _system.UtcNow;
var externalOrderbook = new ExternalExchangeOrderbookMessage
{
AssetPairId = settings.ResultingAssetPairId,
ExchangeName = orderbook.ExchangeName,
Timestamp = now,
Bids = GetOrderbookPositions(orderbook.Bids, settings.Markups.BidMultiplier),
Asks = GetOrderbookPositions(orderbook.Asks, settings.Markups.AskMultiplier)
};
_watchdogService.OnOrderbookArrived(orderbook.ExchangeName, orderbook.AssetPairId, now);
WriteStats(orderbook, externalOrderbook, now);
return(_messageProducer.ProduceAsync(externalOrderbook));
}
public async Task WriteAsync(TResponse message)
{
if (string.IsNullOrEmpty(_topic))
{
throw new NullOrEmptyTopicException(_topic);
}
await _producer.ProduceAsync(_topic, _resolveKey(message), message);
}
public async Task TrackConfirmedAsync(TrackingToken token)
{
if (!token.IsValid)
{
return;
}
await confirmProducer.ProduceAsync(token.ToString(), new ConfirmMessage { Token = token });
}
private async Task RunAsync()
{
while (true)
{
string newMessage = await producer.ProduceAsync();
await client.SendAsync("ReceiveAsync", newMessage);
}
}
public UserEventPublisherTests()
{
ct = cts.Token;
A.CallTo(() => producer.ProduceAsync(A <string> ._, A <UserEventMessage> ._, A <CancellationToken> ._))
.Invokes(call => publishedUserEvents.Add(call.GetArgument <UserEventMessage>(1) !));
var log = A.Fake <ILogger <UserEventPublisher> >();
sut = new UserEventPublisher(counters, logStore, eventStore, subscriptionStore, templateStore, userStore, producer, log, randomizer);
}
public Task SendAsync(DateTime moment, string type, string sender, string message)
{
var slackMessage = new SlackMessageQueueEntity
{
Type = type,
Message = message,
Sender = $"[{moment.ToString(TimestampFormat)}] {sender}",
};
return(_queue.ProduceAsync(slackMessage));
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var count = 0;
while (!stoppingToken.IsCancellationRequested)
{
var sampleMessage = new SampleMessage($"sample-key-{count}", "sample-property");
await _messageProducer.ProduceAsync(sampleMessage.Key, sampleMessage, stoppingToken);
var anotherSampleMessage = new AnotherSampleMessage($"another-sample-key-{count}", "another-property");
await _messageProducer.ProduceAsync(anotherSampleMessage.Key, anotherSampleMessage, stoppingToken);
var otherSampleMessage = new OtherSampleMessage($"other-sample-key-{count}", "some-other-property");
await _messageProducer.ProduceAsync(otherSampleMessage.Key, otherSampleMessage, stoppingToken);
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
await Task.Delay(1000, stoppingToken);
count++;
}
}
public async Task Handle(PublishEmailNotificationCommand notification, CancellationToken cancellationToken)
{
try
{
await _emailMessageProducer.ProduceAsync(_configurationSection.GetSection("Topics")["EmailNotifications"], null, notification);
_publishNotificationLogger.LogInformation("Message producuded to topic " + _configurationSection.GetSection("Topics")["EmailNotifications"]);
}
catch (Exception e)
{
_publishNotificationLogger.LogError(e.StackTrace);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
//order-created
var fakeOrder = CreateFakeOrder();
await _orderCreatedProducer.ProduceAsync(fakeOrder, fakeOrder.Id, stoppingToken);
_logger.LogInformation("Message: {Id}, {CustomerName}, {CartValue}", fakeOrder.Id, fakeOrder.CustomerName, fakeOrder.CartValue);
_logger.LogInformation("OrderCreatedWorker running at: {time}", DateTimeOffset.Now);
await Task.Delay(1000, stoppingToken);
}
}
public async Task HandleMessageAsync(string MessageType, TKey Key, TValue Value)
{
try
{
string TopicName = _configurationSection.GetSection("MessageTypes")[MessageType];
await _emailMessageProducer.ProduceAsync(TopicName, Key, Value);
_messagingServiceLogger.LogInformation("Message producuded to topic " + TopicName);
}
catch (Exception e)
{
_messagingServiceLogger.LogError(e.StackTrace);
}
}
private async Task PublishAssetUpsertedEvent(Asset asset, string oldMdsCodeIfUpdated = null)
{
var evt = new AssetUpsertedEvent
{
Asset = asset,
EventMetadata = new EventMetadata(
eventId: Guid.NewGuid().ToString(),
eventCreationDate: DateTime.UtcNow),
PropertiesPriorValueIfUpdated = new AssetUpdatedProperties
{
UnderlyingMdsCode = oldMdsCodeIfUpdated
}
};
await _assetUpsertedPublisher.ProduceAsync(evt);
_log.WriteInfo(nameof(LegacyAssetsCacheUpdater), evt, "Published asset upserted event");
}
public async Task Handle(Notification notification, CancellationToken cancellationToken)
{
try
{
var messageConfiguration = new MessageProducerConfiguration
{
Topic = "BookShop.NewRequest.Approved"
};
var deliveryResult = await _messageProducer.ProduceAsync(messageConfiguration, notification);
System.Console.WriteLine($"=> Offset: {deliveryResult?.Offset.Value}");
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
int auxValue = 0;
while (!stoppingToken.IsCancellationRequested)
{
//status-updated
var fakeStatus = CreateFakeStatus(auxValue);
await _statusUpdatedProducer.ProduceAsync(fakeStatus, fakeStatus.Id, stoppingToken);
_logger.LogInformation("Message: {Id}, {Status}", fakeStatus.Id, fakeStatus.Status);
_logger.LogInformation("StatusUpdatedWorker running at: {time}", DateTimeOffset.Now);
await Task.Delay(1000, stoppingToken);
auxValue++;
}
}
public async Task SendSettingsChangedEvent(string route, SettingsChangedSourceType sourceType,
string changedEntityId = null)
{
var message = new SettingsChangedEvent
{
Route = route,
SettingsType = _convertService.Convert <SettingsChangedSourceType, SettingsTypeContract>(sourceType),
Timestamp = _systemClock.UtcNow.DateTime,
ChangedEntityId = changedEntityId,
};
try
{
await _settingsChangedMessageProducer.ProduceAsync(message);
}
catch (Exception ex)
{
_log.WriteError(nameof(EventSender), message.ToJson(), ex);
}
}
public async Task WriteAsync(TResponse message)
{
await _producer.ProduceAsync(_resolveKey(message), message);
}
public async Task WriteAsync(NetStreamResult <TResponse> result)
{
await _producer.ProduceAsync(_resolveKey(result.Message), result.Message, result.Headers);
}
public async Task SendEmailAsync(EmailModel model)
{
await _producer.ProduceAsync(model);
}
public async Task PublshEvent(string rabbitEvent)
{
await _publisher.ProduceAsync(rabbitEvent);
}
public void Produce(TKey key, TMessage message)
{
_producer.ProduceAsync(key, message).Await();
}
