public static void Execute()
{
MediatorHandler mediator = new MediatorHandler();
User user1 = new User("Lucas", mediator);
User user2 = new User("Joao", mediator);
User user3 = new User("Jose", mediator);
User user4 = new User("Maria", mediator);
//Register to Mediator
mediator.Register(user1);
mediator.Register(user2);
mediator.Register(user3);
mediator.Register(user4);
//Display Items
mediator.Notify();
user1.Send("First Message");
user2.Send("First Message");
user3.Send("First Message");
user4.Send("First Message");
//Send to a User
mediator.Send(user1, user2, "hi");
mediator.Send(user2, user1, "hello, how are you?");
Read();
}
public async Task <bool> Handle(UpdateOrderItemCommand request, CancellationToken cancellationToken)
{
if (!CheckCommand(request))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(request.ClientId);
if (order == null)
{
await MediatorHandler.PostNotification(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var pedidoItem = await _orderRepository.GetOrderItemByOrder(order.Id, request.ProductId);
if (!order.OrderItemExistent(pedidoItem))
{
await MediatorHandler.PostNotification(new DomainNotification("pedido", "Item do pedido não encontrado!"));
return(false);
}
order.UpdateQuantity(pedidoItem, request.Quantity);
order.AddEvent(new OrderUpdatedEvent(order.ClientId, order.Id, order.TotalValue));
order.AddEvent(new OrderItemUpdatedEvent(request.ClientId, order.Id, request.ProductId, request.Quantity));
_orderRepository.UpdateOrderItem(pedidoItem);
_orderRepository.Update(order);
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(RemoverOrderItemCommand request, CancellationToken cancellationToken)
{
if (!CheckCommand(request))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(request.ClientId);
if (order == null)
{
await MediatorHandler.PostNotification(new DomainNotification("pedido", "Order not found!"));
return(false);
}
var orderItem = await _orderRepository.GetOrderItemByOrder(order.Id, request.ProductId);
if (orderItem != null && !order.OrderItemExistent(orderItem))
{
await MediatorHandler.PostNotification(new DomainNotification("order", "Order Item not found!"));
return(false);
}
order.RemoveOrderItem(orderItem);
order.AddEvent(new OrderUpdatedEvent(order.ClientId, order.Id, order.TotalValue));
order.AddEvent(new OrderItemRemovedEvent(request.ClientId, order.Id, request.ProductId));
_orderRepository.RemoveOrderItem(orderItem);
_orderRepository.Update(order);
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <CommandResponse> Handle(EditContactCommand request, CancellationToken cancellationToken)
{
var contact = await _contactRepository.GetByIdAsync(request.ContactId);
if (contact == null)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail("The Contact is invalid !"));
return(CommandResponse.Fail());
}
var contactType = await _contactTypeRepository.GetByIdAsync(request.ContactTypeId);
if (contactType == null)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail("The Contact Type is invalid !"));
return(CommandResponse.Fail());
}
contact.ChangeName(request.ContactName);
contact.ChangeBirthDate(request.ContactBirthDate);
contact.ChangePhoneNumber(request.ContactPhone);
contact.ChangeContactType(contactType);
if (!contact.IsValid())
{
foreach (var item in contact.ValidationResult.Errors)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail(item.ErrorMessage));
}
return(CommandResponse.Fail("Contact invalid !"));
}
_contactRepository.Update(contact);
var result = await _contactRepository.CommitAsync();
return(result.Success
? CommandResponse.Ok()
: CommandResponse.Fail("Fail recording the register in database !"));
}
public async Task <bool> Handle(CancelProcessOrderReverseStockCommand request, CancellationToken cancellationToken)
{
if (!CheckCommand(request))
{
return(false);
}
var order = await _orderRepository.GetOrderById(request.ClientId);
if (order == null)
{
await MediatorHandler.PostNotification(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(ApplyVoucherOrderCommand request, CancellationToken cancellationToken)
{
if (!CheckCommand(request))
{
return(false);
}
var order = await _orderRepository.GetDraftOrderByClientId(request.ClientId);
if (order == null)
{
await MediatorHandler.PostNotification(new DomainNotification("order", "Order not found!"));
return(false);
}
var voucher = await _orderRepository.GetVoucherByCode(request.VoucherCode);
if (voucher == null)
{
await MediatorHandler.PostNotification(new DomainNotification("order", "Voucher not found!"));
return(false);
}
var voucherApplied = order.ApplyVoucher(voucher);
if (!voucherApplied.IsValid)
{
foreach (var error in voucherApplied.Errors)
{
await MediatorHandler.PostNotification(new DomainNotification(error.ErrorCode, error.ErrorMessage));
}
return(false);
}
order.AddEvent(new OrderUpdatedEvent(order.ClientId, order.Id, order.TotalValue));
order.AddEvent(new OrderVoucherAppliedEvent(request.ClientId, order.Id, voucher.Id));
_orderRepository.Update(order);
return(await _orderRepository.UnitOfWork.Commit());
}
public async Task <CommandResponse> Handle(DeleteContactCommand request, CancellationToken cancellationToken)
{
var contact = await _contactRepository.GetByIdAsync(request.ContactId);
if (contact == null)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail("The Contact is invalid !"));
return(CommandResponse.Fail());
}
//the system does not exclude, just mark the Valid as false;
contact.Remove();
_contactRepository.Update(contact);
var result = await _contactRepository.CommitAsync();
return(result.Success
? CommandResponse.Ok()
: CommandResponse.Fail("Fail recording the register in database !"));
}
private Contact CreateContact(CreateReservationCommand request)
{
var contactType = _contactTypeRepository.GetByIdAsync(request.ContactTypeId).GetAwaiter().GetResult();
if (contactType == null)
{
MediatorHandler.NotifyDomainNotification(
DomainNotification.Fail("The contact type is invalid !"));
return(null);
}
var contact = new Contact(
name: request.ContactName,
phoneNumber: request.ContactPhone,
birthDate: request.ContactBirthdate,
contactType: contactType
);
if (!contact.IsValid())
{
foreach (var item in contact.ValidationResult.Errors)
{
DomainNotification.Fail(item.ErrorMessage);
}
return(null);
}
_contactRepository.AddAsync(contact);
var result = _contactRepository.CommitAsync().GetAwaiter().GetResult();
return(result.Success ? contact : null);
}
public async Task <CommandResponse> Handle(CreateContactCommand request, CancellationToken cancellationToken)
{
var contactType = await _contactTypeRepository.GetByIdAsync(request.ContactTypeId);
if (contactType == null)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail("The Contact Id is not valid !"));
return(CommandResponse.Fail());
}
var contact = new Contact(
name: request.ContactName,
phoneNumber: request.ContactPhone,
birthDate: request.ContactBirthDate,
contactType: contactType
);
if (!contact.IsValid())
{
foreach (var item in contact.ValidationResult.Errors)
{
await MediatorHandler.NotifyDomainNotification(DomainNotification.Fail(item.ErrorMessage));
}
return(CommandResponse.Fail("Contact invalid !"));
}
await _contactRepository.AddAsync(contact);
var result = await _contactRepository.CommitAsync();
return(result.Success
? CommandResponse.Ok(contact.Id)
: CommandResponse.Fail("Fail recording the register in database !"));
}
public AddOrderItemCommandHandler(IOrderRepository orderRepository, MediatorHandler mediatorHandler)
: base(mediatorHandler)
{
_orderRepository = orderRepository;
}
public MediatorHandlerTests()
{
_mocker = new AutoMocker();
_handler = _mocker.CreateInstance <MediatorHandler>();
}
