Ejemplo n.º 1
0
        public async Task <IActionResult> AtualizarStatus([FromBody] AtualizarPedidoCommand command)
        {
            await _atualizarPedidoService.Process(command.Map());

            if (_atualizarPedidoService.CodigoPedidoInvalido)
            {
                return(new CodigoPedidoInvalidoError());
            }
            if (_atualizarPedidoService.Aprovado)
            {
                return(new PedidoAprovadoError());
            }
            if (_atualizarPedidoService.Reprovado)
            {
                return(new PedidoReprovadoError());
            }
            if (_atualizarPedidoService.AprovadoValorAMaior)
            {
                return(new PedidoAprovadoValorAMaiorError());
            }
            if (_atualizarPedidoService.AprovadoQtdAMaior)
            {
                return(new PedidoAprovadoQtdAMaiorError());
            }
            if (_atualizarPedidoService.AprovadoValorAMenor)
            {
                return(new PedidoAprovadoValorAMenorError());
            }
            if (_atualizarPedidoService.AprovadoQtdAMenor)
            {
                return(new PedidoAprovadoQtdAMenorError());
            }

            return(Ok(new PedidoAtualizadoResult(_atualizarPedidoService.Pedido)));
        }
Ejemplo n.º 2
0
        public async Task <bool> Handle(AtualizarPedidoCommand request, CancellationToken cancellationToken)
        {
            Pedido pedido = await _pedidoRepository.ObterPorId(request.PedidoId);

            if (pedido == null)
            {
                await _mediatorHandler.PublicarNotificacao(new DomainNotification("pedido", "Pedido não encontrado!"));

                return(false);
            }

            _pedidoRepository.Atualizar(pedido);
            return(true);
        }
        public void Handle(AtualizarPedidoCommand message)
        {
            if (!CommandValido(message))
            {
                return;
            }
            Pedido pedido = Pedido_ProdutoFactory.PedidoFull(message.Id, message.Status, message.Entregue, message.Cancelado, message.Total, message.Id_loja, message.Id_pagamentoTipo, message.Cliente, message.Pedido_Produtos);

            _pedidoRepository.Atualizar(pedido);
            if (!Commit())
            {
                return;
            }
        }
Ejemplo n.º 4
0
        public async Task <string> Put(int id, [FromBody] PedidoModel model)
        {
            try
            {
                AtualizarPedidoCommand atualizarPedidoCommand = new AtualizarPedidoCommand(model.Id, model.Cliente.Id);

                await _mediatorHandler.EnviarComando(atualizarPedidoCommand);

                foreach (var item in model.Itens)
                {
                    AtualizarItemPedidoCommand adicionarItemPedidoCommand = new AtualizarItemPedidoCommand(item.Produto.Id, item.Quantidade);
                    await _mediatorHandler.EnviarComando(adicionarItemPedidoCommand);
                }
            }
            catch (DominioException ex)
            {
                return(ex.Message);
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
            return(null);
        }
Ejemplo n.º 5
0
        public void Atualizar(Pedido pedido)
        {
            AtualizarPedidoCommand command = new AtualizarPedidoCommand(pedido.Id, pedido.Status, pedido.Entregue, pedido.Cancelado, pedido.Total, pedido.Id_loja, pedido.Id_pagamentoTipo, pedido.Cliente, pedido.Pedido_Produtos);

            _bus.SendCommand(command);
        }