public async Task <bool> TryHandleAsync(UserCheckoutAcceptedIntegrationEvent @event)
        {
            var result = false;

            // Send Integration event to clean basket once basket is converted to Order and before starting with the order creation process
            var orderStartedIntegrationEvent = new OrderStartedIntegrationEvent(@event.UserId);

            _orderingIntegrationEventService.PublishThroughEventBus(orderStartedIntegrationEvent);

            if (@event.RequestId != Guid.Empty)
            {
                var createOrderCommand = new CreateOrderCommand(@event.Basket.Items, @event.UserId,
                                                                @event.UserName, @event.City, @event.Street,
                                                                @event.State, @event.Country, @event.ZipCode,
                                                                @event.CardNumber, @event.CardHolderName, @event.CardExpiration,
                                                                @event.CardSecurityNumber, @event.CardTypeId);

                var requestCreateOrder = new IdentifiedCommand <CreateOrderCommand, bool>(createOrderCommand, @event.RequestId);
                try
                {
                    result = await _mediator.Send(requestCreateOrder);
                }
                catch (Exception ex)
                {
                    _logger.LogCritical(ex.ToString());
                }
            }

            _logger.LogInformation(result ?
                                   $"UserCheckoutAccepted integration event has been received and a create new order process is started with requestId: {@event.RequestId}"
                : $"UserCheckoutAccepted integration event has been received but a new order process has failed with requestId: {@event.RequestId}");

            return(true);
        }
        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}.");
        }