示例#1
0
 protected async Task NotificarErrosValidacao(Command message)
 {
     foreach (var error in message.ValidationResult.Errors)
     {
         await _mediatorHandler.PublicarNotificacao(new DomainNotification(message.MessageType, error.ErrorMessage));
     }
 }
示例#2
0
        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());
        }
示例#3
0
        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());
        }
示例#4
0
        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());
        }
示例#6
0
        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());
        }
示例#7
0
        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);
        }
示例#8
0
        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);
        }
示例#9
0
        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());
        }
示例#10
0
        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);
        }
示例#14
0
        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);
        }
示例#15
0
        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);
        }
示例#17
0
        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());
        }
示例#18
0
        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));
 }
示例#20
0
        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());
        }
示例#21
0
        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());
        }