public async Task HandleAsync(IDomainEvent <Order, OrderId, OrderStartedDomainEvent> domainEvent, CancellationToken cancellationToken)
{
var buyerId = BuyerId.With(Guid.Parse(domainEvent.AggregateEvent.UserId));
var b = await _aggregateStore
.LoadAsync <Buyer, BuyerId>(buyerId, CancellationToken.None)
.ConfigureAwait(false);
var cardTypeId = (domainEvent.AggregateEvent.CardTypeId != 0) ? domainEvent.AggregateEvent.CardTypeId : 1;
await _aggregateStore.UpdateAsync <Buyer, BuyerId>(buyerId, SourceId.New,
(buyer, c) => {
if (buyer.IsNew)
{
buyer.Create(domainEvent.AggregateEvent.UserId, domainEvent.AggregateEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
domainEvent.AggregateEvent.CardNumber,
domainEvent.AggregateEvent.CardSecurityNumber,
domainEvent.AggregateEvent.CardHolderName,
domainEvent.AggregateEvent.CardExpiration,
domainEvent.AggregateIdentity);
return(Task.FromResult(0));
}, CancellationToken.None
).ConfigureAwait(false);
var orderStatusChangedTosubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(domainEvent.AggregateIdentity.Value, OrderStatus.Submitted.Name, "bob");
await _endpoint.Publish(orderStatusChangedTosubmittedIntegrationEvent);
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = await _buyerRepository.FindAsync(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync();
var orderStatusChangedTosubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedTosubmittedIntegrationEvent);
_logger.CreateLogger(nameof(ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler)).LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: {orderStartedEvent.Order.Id}.");
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = await _buyerRepository.FindAsync(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync(cancellationToken);
var orderStatusChangedTosubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
await _messageOutbox.Send(orderStatusChangedTosubmittedIntegrationEvent);
}
public async Task Handle(OrderStatusChangedToSubmittedIntegrationEvent integrationEvent,
[FromServices] IOptions <OrderingSettings> settings, [FromServices] IEmailService emailService)
{
// Gets the order details from Actor state.
var actorId = new ActorId(integrationEvent.OrderId.ToString());
var orderingProcess = ActorProxy.Create <IOrderingProcessActor>(actorId, nameof(OrderingProcessActor));
//
var actorOrder = await orderingProcess.GetOrderDetails();
var readModelOrder = Model.Order.FromActorState(integrationEvent.OrderId, actorOrder);
// Add the order to the read model so it can be queried from the API.
// It may already exist if this event has been handled before (at-least-once semantics).
readModelOrder = await _orderRepository.AddOrGetOrderAsync(readModelOrder);
// Send a SignalR notification to the client.
await SendNotificationAsync(readModelOrder.OrderNumber, integrationEvent.OrderStatus,
integrationEvent.BuyerName);
// Send a confirmation e-mail if enabled.
if (settings.Value.SendConfirmationEmail)
{
await emailService.SendOrderConfirmation(readModelOrder);
}
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = _buyerRepository.Find(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer != null);
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
_buyerRepository.UnitOfWork.SaveEntities();
//Not showing the implementation of this event handler in other aggregate roots
var statusChangedToSubmittedIntegrationEvent
= new OrderStatusChangedToSubmittedIntegrationEvent(
orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
_orderingIntegrationEventService.PublishThroughEventBus(statusChangedToSubmittedIntegrationEvent);
_logger.LogInformation($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: " +
$"{orderStartedEvent.Order.Id}.");
}
public async Task Handle(OrderStartedDomainEvent notification, CancellationToken cancellationToken)
{
var cardTypeId = (notification.CardTypeId != 0) ? notification.CardTypeId : 1;
var userGuid = _identityService.GetUserIdentity();
var buyer = await _buyerRepository.FindAsync();
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(userGuid);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
notification.CardNumber,
notification.CardSecurityNumber,
notification.CardHolderName,
notification.CardExpiration,
notification.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveChangesAsync(cancellationToken);
var orderStatusChangedToSubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(
notification.Order.Id, notification.Order.OrderStatus.Name, buyer.Name);
await _orderIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToSubmittedIntegrationEvent);
_logger.CreateLogger <ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler>()
.LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated " +
$"for order id {notification.Order.Id}");
}
public async Task OrderStarted(OrderStatusChangedToSubmittedIntegrationEvent @event)
{
var handler = _serviceProvider.GetRequiredService <OrderStatusChangedToSubmittedIntegrationEventHandler>();
await handler.Handle(@event);
}
public Task HandleAsync(
OrderStatusChangedToSubmittedIntegrationEvent @event,
[FromServices] OrderStatusChangedToSubmittedIntegrationEventHandler handler)
=> handler.Handle(@event);
