private async Task PublishPaymentEvents(Payment payment)
{
if (!payment.HasNotifications())
{
return;
}
foreach (var paymentEvent in payment.Notifications)
{
await _mediatrHandler.PublishEvent(paymentEvent);
}
}
public async Task Handle(StartedOrderEvent message, CancellationToken cancellationToken)
{
var result = await _stockService.DebitListOrderProducts(message.OrderProducts);
if (result)
{
await _mediatorHandler.PublishEvent(new OrderStockConfirmedEvent(message.OrderId, message.ClientId, message.Total, message.OrderProducts, message.CardName, message.CardNumber, message.ExpirationDate, message.CvvCard ));
}
else
{
await _mediatorHandler.PublishEvent(new OrderStockRejectedEvent(message.OrderId, message.ClientId));
}
}
public async Task Handle(OrderStartedEvent message, CancellationToken cancellationToken)
{
bool IsStockReservedForOrder = await _stockService.DebitStock(message.OrderProducts);
if (IsStockReservedForOrder)
{
await _mediatrHandler.PublishEvent(new StockReservedForOrderEvent(message.CustomerId, message.OrderId, message.TotalPrice, message.CardName, message.CardNumber,
message.CardExpirationDate, message.CardCvv, message.OrderProducts));
}
else
{
await _mediatrHandler.PublishEvent(new InsufficientStockForOrderEvent(message.CustomerId, message.OrderId));
}
}
private async Task <bool> DebitStockItem(Guid productId, int quantity)
{
var product = await _productRepository.GetById(productId);
if (product == null)
{
return(false);
}
if (!product.HasStock(quantity))
{
await _mediatorHandler.PublishNotification(new DomainNotification("Stock", $"Product - {product.Name} out of stock."));
return(false);
}
product.DebitStock(quantity);
// TODO: 10 can parameterizable in config file
if (product.StockQuantity < 10)
{
await _mediatorHandler.PublishEvent(new ProductBelowStockEvent(product.Id, product.StockQuantity));
}
_productRepository.Update(product);
return(true);
}
public async Task <bool> DebitStock(Guid productId, int quantity)
{
var product = await _productRepository.GetById(productId);
if (product == null)
{
return(false);
}
if (!product.HasStock(quantity))
{
await _mediatrHandler.PublishNotification(new DomainNotification("Stock", $"The product {product.Name} is out of stock."));
return(false);
}
product.DebitStock(quantity);
// TODO: To parameterize the low stock quantity
if (product.StockQuantity < 10)
{
await _mediatrHandler.PublishEvent(new LowProductStockEvent(product.Id, product.StockQuantity));
}
_productRepository.Update(product);
return(await _productRepository.UnitOfWork.Commit());
}
public async Task <bool> DecreaseInventory(Guid productId, int amount)
{
var product = await _productRepository.GetById(productId);
if (product == null)
{
return(false);
}
if (!product.HasInventory(amount))
{
return(false);
}
product.DecreaseInventory(amount);
//TODO: Set minimum inventory amount as parameter
if (product.InventoryAmount < 10)
{
await _bus.PublishEvent(new LowProductInventoryEvent(product.Id, product.InventoryAmount));
}
_productRepository.Update(product);
return(await _productRepository.UnitOfWork.Commit());
}
public static async Task PublishEvents(this IMediatrHandler mediator, PaymentContext ctx)
{
var domainEntities = ctx.ChangeTracker
.Entries <Entity>()
.Where(x => x.Entity.Notifications != null && x.Entity.Notifications.Any());
var domainEvents = domainEntities
.SelectMany(x => x.Entity.Notifications)
.ToList();
domainEntities.ToList()
.ForEach(entity => entity.Entity.CleanEvents());
var tasks = domainEvents
.Select(async(domainEvent) => {
await mediator.PublishEvent(domainEvent);
});
await Task.WhenAll(tasks);
}
public async Task <bool> DecreaseStock(Guid productId, int quantity)
{
var product = await _productRepository.GetById(productId);
if (product == null)
{
return(false);
}
product.DecreaseStock(quantity);
if (product.QuantityInStock < 10)
{
await _mediatrHandler.PublishEvent(new ProductOutOfStockEvent(product.Id, product.QuantityInStock));
}
_productRepository.UpdateProduct(product);
return(await _productRepository.UnitOfWork.Commit());
}
public async Task <Transaction> MakeOrderPayment(PaymentOrder paymentOrder)
{
var order = new Order
{
Id = paymentOrder.OrderId,
Value = paymentOrder.Total
};
var payment = new Payment
{
Value = paymentOrder.Total,
CardName = paymentOrder.CardName,
CardNumber = paymentOrder.CardNumber,
ExpirationCard = paymentOrder.ExpirationCard,
CvvCard = paymentOrder.CvvCard,
OrderId = paymentOrder.OrderId
};
var transaction = _paymentCreditCardFacade.MakePayment(order, payment);
if (transaction.StatusTransaction == StatusTransaction.Paid)
{
payment.AddEvent(new PaymentMadeEvent(order.Id, paymentOrder.ClientId, transaction.PaymentId, transaction.Id, order.Value));
_paymentRepository.Add(payment);
_paymentRepository.AddTransaction(transaction);
await _paymentRepository.UnitOfWork.Commit();
return(transaction);
}
await _mediatorHandler.PublishNotification(new DomainNotification("payment", "Card operator refused the payment"));
await _mediatorHandler.PublishEvent(new PaymentOrderRefusedEvent(order.Id, paymentOrder.ClientId, transaction.PaymentId, transaction.Id, order.Value));
return(transaction);
}
