protected async Task NotificarErrosValidacao(Command message)
{
foreach (var error in message.ValidationResult.Errors)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification(message.MessageType, error.ErrorMessage));
}
}
public async Task <bool> Handle(AtualizarCategoriaCommand command, CancellationToken cancellationToken)
{
if (!command.ValidarCommand(command, _mediator))
{
return(false);
}
var categoria = await _categoriaRepositorio.ObterPorId(command.Id);
if (categoria == null)
{
await _mediatorHandler.PublicarNotificacao(new DominioNotificacao("Categoria", "Categoria não encontrada"));
return(false);
}
categoria.Alterar(command.Nome, command.Codigo, command.Ativo);
if (await CategoriaJaExistente(categoria))
{
return(false);
}
_categoriaRepositorio.Atualizar(categoria);
return(await _categoriaRepositorio.UnitOfWork.Commit());
}
public async Task <bool> Handle(AtualizarItemPedidoCommand request, CancellationToken cancellationToken)
{
if (!ValidarComando(request))
{
return(false);
}
var pedido = await _pedidoRepository.ObterPedidoRascunhoPorClienteId(request.ClienteId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var pedidoItem = await _pedidoRepository.ObterItemPorPedido(pedido.Id, request.ProdutoId);
if (!pedido.PedidoItemExistente(pedidoItem))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Item do pedido não encontrado!"));
return(false);
}
pedido.AtualizarUnidades(pedidoItem, request.Quantidade);
pedido.AdicionarEvento(new PedidoProdutoAtualizadoEvent(request.ClienteId, pedido.Id, request.ProdutoId, request.Quantidade));
_pedidoRepository.AtualizarItem(pedidoItem);
_pedidoRepository.Atualizar(pedido);
return(await _pedidoRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(AdicionarItemPedidoCommand message, CancellationToken cancellationToken)
{
if (!ValidarComando(message))
{
return(false);
}
var pedido = await _pedidoRepository.ObterPedidoPorCliente(message.ClienteId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var pedidoItem = new PedidoItem(0, message.ProdutoId, message.Quantidade, pedido.Id);
_pedidoRepository.AdicionarItem(pedidoItem);
await _pedidoRepository.UnitOfWork.Commit();
_mongo.PedidosItens.InsertOne(new DtoPedidoItem(pedidoItem.Id, pedidoItem.Quantidade, pedidoItem.ProdutoId, pedidoItem.Pedido.Id));
return(true);
}
public async Task <bool> Handle(AgendarConsultaCommand request, CancellationToken cancellationToken)
{
if (!ValidarComando(request))
{
return(false);
}
var agendaMedica = await _agendaMedicaRepository.ObterAgendaMedica(request.MedicoId);
var agendamentoPaciente = new AgendamentoPaciente(request.PacienteId, request.DataInicioConsulta);
if (agendaMedica == null)
{
agendaMedica = new AgendaMedica(request.MedicoId);
agendaMedica.AdicionarAgendamentoPaciente(agendamentoPaciente);
_agendaMedicaRepository.Adicionar(agendaMedica);
}
else if (HorarioAgendamentoNaoDisponivel(request, agendaMedica))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("Agendamento consulta", "Data não está disponível!"));
return(false);
}
else
{
agendaMedica.AdicionarAgendamentoPaciente(agendamentoPaciente);
_agendaMedicaRepository.AdicionarAgendamentoPaciente(agendamentoPaciente);
}
return(await _agendaMedicaRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(AtualizarItemPedidoCommand message, CancellationToken cancellationToken)
{
if (!ValidarComando(message))
{
return(false);
}
var pedido = await _pedidoRepository.ObterPedidoRascunhoPorClienteId(message.ClienteId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var pedidoItem = await _pedidoRepository.ObterItemPorPedido(pedido.Id, message.ProdutoId);
if (!pedido.PedidoItemExistente(pedidoItem))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Item do pedido não encontrado!"));
return(false);
}
pedido.AtualizarUnidades(pedidoItem, message.Quantidade);
pedido.AdicionarEvento(new PedidoAtualizadoEvent(pedido.ClienteId, pedido.Id, pedido.ValorTotal));
pedido.AdicionarEvento(new PedidoProdutoAtualizadoEvent(message.ClienteId, pedido.Id, message.ProdutoId, message.Quantidade));
_pedidoRepository.AtualizarItem(pedidoItem);
_pedidoRepository.Atualizar(pedido); // o Atualizar está aqui mais por uma intenção de mostrar o que está sendo feito, porque o próprio Change Tracker daria conta de atualizar ele sozinho;
return(await _pedidoRepository.UnitOfWork.Commit());
}
private async Task <bool> DebitarItemEstoque(Guid produtoId, int quantidade)
{
var produto = await _produtoRepository.ObterPorId(produtoId);
if (produto == null)
{
return(false);
}
if (!produto.PossuiEstoque(quantidade))
{
await _mediatorHandler.PublicarNotificacao(
new DomainNotification("Estoque", $"Produto - {produto.Nome} sem estoque")
);
return(false);
}
produto.DebitarEstoque(quantidade);
// TODO: Parametrizar a quantidade de estoque baixo
if (produto.QuantidadeEstoque < 10)
{
await _mediatorHandler.PublicarDomainEvent(new ProdutoAbaixoEstoqueEvent(produto.Id, produto.QuantidadeEstoque));
}
_produtoRepository.Atualizar(produto);
var sucesso = await _produtoRepository.UnitOfWork.Commit();
return(sucesso);
}
private async Task <bool> DebitarItemEstoque(Guid produtoId, int quantidade)
{
var produto = await _produtoRepository.ObterPorId(produtoId);
if (produto == null)
{
return(false);
}
if (!produto.PossuiEstoque(quantidade))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("Estoque", $"Produto - {produto.Nome} sem estoque"));
return(false);
}
produto.DebitarEstoque(quantidade);
if (produto.QuantidadeEstoque < 10)
{
await _mediatorHandler.PublicarEventoDominio(new ProdutoAbaixoEstoqueEvent(produto.Id, produto.QuantidadeEstoque));
}
_produtoRepository.Atualizar(produto);
return(true);
}
public async Task <bool> Handle(CancelarPedidoEstornarEstoqueCommand request, CancellationToken cancellationToken)
{
var pedido = await _pedidoRepository.ObterPorId(request.PedidoId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var itensList = new List <Item>();
pedido.PedidoItems.ForEach(i => itensList.Add(new Item {
Id = i.ProdutoId, Quantidade = i.Quantidade
}));
var listaProdutosPedido = new ListaProdutosPedido {
PedidoId = pedido.Id, Itens = itensList
};
pedido.AdicionarEvento(new PedidoProcessamentoCanceladoEvent(pedido.Id, pedido.ClienteId, listaProdutosPedido));
pedido.TornarRascunho();
return(await _pedidoRepository.UnitOfWork.Commit());
}
private async Task <bool> DebitarItemEstoque(Guid produtoId, int quantidade)
{
var produto = await _produtoRepository.ObterPorId(produtoId);
if (produto == null)
{
return(false);
}
if (!produto.PossuiEstoque(quantidade))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("Estoque", $"Produto = {produto.Nome} sem estoque"));
return(false);
}
produto.DebitarEstoque(quantidade);
//Lançando evento para informar que o estoque está baixo, utilizando o Mediatr
// TODO: 10 pode ser parametrizavel em arquivo de configuração
if (produto.QuantidadeEstoque < 10)
{
await _mediatorHandler.PublicarDomainEvent(new ProdutoAbaixoEstoqueEvent(produto.Id, produto.QuantidadeEstoque));
}
_produtoRepository.Atualizar(produto);
return(true);
}
public async Task <Transacao> RealizarPagamentoPedido(PagamentoPedido pagamentoPedido)
{
var pedido = new Pedido
{
Id = pagamentoPedido.PedidoId,
Valor = pagamentoPedido.Total
};
var pagamento = new Pagamento
{
Valor = pagamentoPedido.Total,
NomeCartao = pagamentoPedido.NomeCartao,
NumeroCartao = pagamentoPedido.NumeroCartao,
ExpiracaoCartao = pagamentoPedido.ExpiracaoCartao,
CvvCartao = pagamentoPedido.CvvCartao,
PedidoId = pagamentoPedido.PedidoId
};
var transacao = _pagamentoCartaoCreditoFacade.RealizarPagamento(pedido, pagamento);
if (transacao.StatusTransacao == StatusTransacao.Pago)
{
pagamento.AdicionarEvento(
new PagamentoRealizadoEvent(
pedido.Id,
pagamentoPedido.ClienteId,
transacao.PagamentoId,
transacao.Id,
pedido.Valor
)
);
_pagamentoRepository.Adicionar(pagamento);
_pagamentoRepository.AdicionarTransacao(transacao);
await _pagamentoRepository.UnitOfWork.Commit();
return(transacao);
}
await _mediatorHandler.PublicarNotificacao(
new DomainNotification("pagamento", "A operadora recusou o pagamento")
);
await _mediatorHandler.PublicarEvento(
new PagamentoRecusadoEvent(
pedido.Id,
pagamentoPedido.ClienteId,
transacao.PagamentoId,
transacao.Id,
pedido.Valor
)
);
return(transacao);
}
public async Task <bool> Handle(AplicarVoucherPedidoCommand request, CancellationToken cancellationToken)
{
if (!ValidarComando(request))
{
return(false);
}
var pedido = await _pedidoRepository.ObterPedidoRascunhoPorClienteId(request.ClienteId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var voucher = await _pedidoRepository.ObterVoucherPorCodigo(request.CodigoVoucher);
if (voucher == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Voucher não encontrado!"));
return(false);
}
var voucherAplicacaoValidation = pedido.AplicarVoucher(voucher);
if (!voucherAplicacaoValidation.IsValid)
{
foreach (var error in voucherAplicacaoValidation.Errors)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification(error.ErrorCode, error.ErrorMessage));
}
return(false);
}
pedido.AdicionarEvento(new VoucherAplicadoPedidoEvent(request.ClienteId, pedido.Id, voucher.Id));
_pedidoRepository.Atualizar(pedido);
return(await _pedidoRepository.UnitOfWork.Commit());
}
private async Task <bool> CategoriaJaExistente(Categoria categoria)
{
var _categoria = _categoriaRepositorio.Obter(categoria.Nome, categoria.Codigo).Result;
if (_categoria == null)
{
return(false);
}
if (_categoria.Nome.Trim().Equals(categoria.Nome.Trim()))
{
await _mediatorHandler.PublicarNotificacao(new DominioNotificacao("Categoria", $"Já possui uma Categoria cadastrada com o Nome {categoria.Nome}"));
}
if (_categoria.Codigo.Trim().Equals(categoria.Codigo.Trim()))
{
await _mediatorHandler.PublicarNotificacao(new DominioNotificacao("Categoria", $"Já possui uma Categoria cadastrada com o Codigo {categoria.Codigo}"));
}
return(true);
}
public bool Commit()
{
if (_notifications.TemNotificacao())
{
return(false);
}
if (_uow.Commit())
{
return(true);
}
_bus.PublicarNotificacao(new DomainNotification("Commit", "Houve um problema durante a gravação dos dados."));
return(false);
}
private bool ValidarComando(Command message)
{
if (message.EhValido())
{
return(true);
}
foreach (var error in message.ValidationResult.Errors)
{
_mediatorHandler.PublicarNotificacao(new DomainNotification(message.MessageType, error.ErrorMessage));
}
return(false);
}
protected bool ValidarComando(Command request)
{
if (request.EhValido())
{
return(true);
}
foreach (var error in request.ValidationResult.Errors)
{
_mediatorHandler.PublicarNotificacao(new DomainNotification(request.MessageType, error.ErrorMessage));
}
return(false);
}
public async Task <bool> Handle(CancelarProcessamentoPedidoCommand request, CancellationToken cancellationToken)
{
var pedido = await _pedidoRepository.ObterPorId(request.PedidoId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado"));
return(false);
}
pedido.TornarRascunho();
return(await _pedidoRepository.UnitOfWork.Commit());
}
public async Task <bool> Handle(FinalizarPedidoCommand request, CancellationToken cancellationToken)
{
var pedido = await _pedidoRepository.ObterPorId(request.PedidoId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
pedido.FinalizarPedido();
pedido.AdicionarEvento(new PedidoFinalizadoEvent(request.PedidoId));
return(await _pedidoRepository.UnitOfWork.Commit());
}
protected void NotificarErro(string codigo, string mensagem)
{
_mediatorHandler.PublicarNotificacao(new DomainNotification(codigo, mensagem));
}
public async Task <bool> Handle(AtualizarItemPedidoCommand message, CancellationToken cancellationToken)
{
if (!ValidarComando(message))
{
return(false);
}
var pedido = await _pedidoRepository.ObterPedidoRascunhoPorClienteID(message.ClienteID);
if (pedido is null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrrado!"));
return(false);
}
var pedidoItem = await _pedidoRepository.ObterItemPorPedido(pedido.ID, message.ProdutoID);
if (!pedido.PedidoItemExistente(pedidoItem))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Item do pedido não encontrado!"));
return(false);
}
pedido.AtualizarUnidades(pedidoItem, message.Quantidade);
pedido.AdicionarEvento(new PedidoAtualizadoEvent(pedido.ClienteID, pedido.ID, pedido.ValorTotal));
pedido.AdicionarEvento(new PedidoProdutoAtualizadoEvent(message.ClienteID, pedido.ID, message.ProdutoID, message.Quantidade));
_pedidoRepository.RemoverItem(pedidoItem);
_pedidoRepository.Atualizar(pedido);
return(await _pedidoRepository.UnityOfWork.Commit());
}
public async Task <bool> Handle(AtualizarItemPedidoCommand message, CancellationToken cancellationToken)
{
if (!ValidarComando(message))
{
return(false);
}
var pedido = await _pedidoRepository.ObterPedidoRascunhoPorClienteId(message.ClienteId);
if (pedido == null)
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));
return(false);
}
var pedidoItem = await _pedidoRepository.ObterItemPorPedido(pedido.Id, message.ProdutoId);
if (!pedido.PedidoItemExistente(pedidoItem))
{
await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Item do pedido não encontrado!"));
return(false);
}
pedido.AtualizarUnidades(pedidoItem, message.Quantidade);
//pedido.AdicionarEvento(new PedidoAtualizadoEvent(pedido.ClienteId, pedido.Id, pedido.ValorTotal));
pedido.AdicionarEvento(new PedidoProdutoAtualizadoEvent(message.ClienteId, pedido.Id, message.ProdutoId, message.Quantidade));
_pedidoRepository.AtualizarItem(pedidoItem);
// colocado aqui apenas p ficar mais claro mas nem precisaria pq o atualizar de cima com o changeTracker já atualizaria o pedido
_pedidoRepository.Atualizar(pedido);
return(await _pedidoRepository.UnitOfWork.Commit());
}