public async Task Handle(RealizarPagamentoParaPedidoPendenteComando message, IMessageHandlerContext context)
        {
            using (var unitOfWork = _unitOfWorkFactory.CriarParaTenant(message.CodigoTenant))
            {
                var pedidosRepositorio = new PedidosRepositorio(unitOfWork);
                var pedidoResultado    = await pedidosRepositorio.RecuperarAsync(message.PedidoId);

                if (await _servicoPagamento.CapturarPagamentoAsync(pedidoResultado.Sucesso) is var capturaResultado && capturaResultado.EhFalha)
                {
                    await context.Send(new FalhaAoRealizarPagamentoComando(message.CodigoTenant, message.PedidoId, capturaResultado.Falha));
                }
                await context.Send(new ConfirmarPagamentoDoPedidoComando(message.CodigoTenant, message.PedidoId, capturaResultado.Sucesso));
            }
        }
        public async Task <IActionResult> RealizarPagamento([FromBody] PedidoModel pedidoModel)
        {
            using (var unitOfWork = _unitOfWorkFactory.CriarParaTenant(_contexto.CodigoTenant))
            {
                var clientesRepositorio = new ClientesRepositorio(unitOfWork);
                var pedidosRepositorio  = new PedidosRepositorio(unitOfWork);

                var cliente = await clientesRepositorio.ObterAsync(pedidoModel.CodigoCliente);

                var pedido    = Pedido.Criar(cliente, pedidoModel.Dividas, pedidoModel.DadosPagamento);
                var pagamento = await _servicoPagamento.PagarAsync(pedido);

                if (!pagamento.Aprovado)
                {
                    return(BadRequest(pagamento.NegadoPor));
                }
                pedido.RealizarPagamento(pagamento);

                await _servicoEmail.EnviarObrigadoPeloPagamentoAsync(pedido);

                await _regrasPosPagamento.ExecutarRegrasPosPagamentoAsync(pedido);

                await pedidosRepositorio.IncluirAsync(pedido);

                await unitOfWork.CommitAsync();

                return(Ok(pagamento));
            }
        }
Esempio n. 3
0
        public async Task <IActionResult> RealizarPagamento([FromBody] PedidoModel pedidoModel)
        {
            using (var unitOfWork = _unitOfWorkFactory.CriarParaTenant(_contexto.CodigoTenant))
            {
                var clientesRepositorio = new ClientesRepositorio(unitOfWork);
                var pedidosRepositorio  = new PedidosRepositorio(unitOfWork);
                var cliente             = await clientesRepositorio.ObterAsync(pedidoModel.CodigoCliente);

                var pedido    = Pedido.Criar(cliente, pedidoModel.Dividas, pedidoModel.DadosPagamento);
                var pagamento = Pagamento.NovoPagamento();
                try
                {
                    pagamento = await _servicoPagamento.AutorizarPagamentoAsync(pedido);

                    if (!pagamento.Aprovado)
                    {
                        return(BadRequest(pagamento.NegadoPor));
                    }
                    pedido.RealizarPagamento(pagamento);
                    try
                    {
                        await _servicoEmail.EnviarObrigadoPeloPagamentoAsync(pedido);
                    }
                    catch (Exception)
                    {
                        await _logger.Error("Email não foi enviado");
                    }
                    try
                    {
                        await _regrasPosPagamento.ExecutarRegrasPosPagamentoAsync(pedido);
                    }
                    catch (Exception)
                    {
                        await _logger.Error("Executar regras manualmente");
                    }

                    await pedidosRepositorio.IncluirAsync(pedido);

                    await unitOfWork.CommitAsync();
                }
                catch (Exception)
                {
                    await unitOfWork.RollBackAsync();

                    return(BadRequest("Falha ao realizar pagamento"));
                }
                try
                {
                    pagamento = await _servicoPagamento.CapturarPagamentoAsync(pedido);

                    return(Ok(pagamento));
                }
                catch (Exception)
                {
                    await _logger.Error("Capturar manualmente o pagamento");
                }
                return(Ok(pagamento));
            }
        }
        public async Task <IActionResult> RealizarPagamento([FromBody] PedidoModel pedidoModel)
        {
            using (var unitOfWork = _unitOfWorkFactory.CriarParaTenant(_contexto.CodigoTenant))
            {
                var clientesRepositorio = new ClientesRepositorio(unitOfWork);
                var pedidosRepositorio  = new PedidosRepositorio(unitOfWork);
                if (await clientesRepositorio.ObterAsync(pedidoModel.CodigoCliente) is var clienteResultado && clienteResultado.EhFalha)
                {
                    return(BadRequest("Cliente inválido"));
                }
                var pedido    = Pedido.NovoPendente(clienteResultado.Sucesso, pedidoModel.Dividas, pedidoModel.DadosPagamento);
                var pagamento = Pagamento.NovoPagamento();

                if (await _servicoPagamento.AutorizarPagamentoAsync(pedido) is var autorizacaoResultado && autorizacaoResultado.EhFalha)
                {
                    return(BadRequest("Aconteceu um problema ao realizar o pagamento"));
                }
                if (!pagamento.Aprovado)
                {
                    return(BadRequest(pagamento.NegadoPor));
                }
                pedido.RealizarPagamento(pagamento);

                if (await _servicoEmail.EnviarObrigadoPeloPagamentoAsync(pedido) is var emailEnviado && emailEnviado.EhFalha)
                {
                    await _logger.Error("Admin favor enviar email de pagamento realizado");
                }
                if (await _regrasPosPagamento.ExecutarRegrasPosPagamentoAsync(pedido) is var regrasExecutadas && regrasExecutadas.EhFalha)
                {
                    await _logger.Error("Admin favor executar regras manualmente");
                }

                await pedidosRepositorio.IncluirOuAtualizarAsync(pedido);

                if (await unitOfWork.CommitAsync() is var transacaoResultado && transacaoResultado.EhFalha)
                {
                    return(BadRequest("Falha ao realizar pagamento"));
                }

                if (await _servicoPagamento.CapturarPagamentoAsync(pedido) is var capturaResultado && capturaResultado.EhFalha)
                {
                    await _logger.Error("Capturar manualmente o pagamento");
                }
                return(Ok(pagamento));
            }
        }
        public async Task <IActionResult> RealizarPagamento([FromBody] PedidoModel pedidoModel)
        {
            using (var unitOfWork = _unitOfWorkFactory.CriarParaTenant(_contexto.CodigoTenant))
            {
                var clientesRepositorio = new ClientesRepositorio(unitOfWork);
                var pedidosRepositorio  = new PedidosRepositorio(unitOfWork);
                if (await clientesRepositorio.ObterAsync(pedidoModel.CodigoCliente) is var clienteResultado && clienteResultado.EhFalha)
                {
                    return(BadRequest("Cliente inválido"));
                }
                var pedido = Pedido.NovoPendente(clienteResultado.Sucesso, pedidoModel.Dividas, pedidoModel.DadosPagamento);
                await pedidosRepositorio.IncluirOuAtualizarAsync(pedido);

                if (await unitOfWork.CommitAsync() is var transacaoResultado && transacaoResultado.EhFalha)
                {
                    return(BadRequest("Falha ao realizar pagamento"));
                }
                await _bus.Enviar(new RealizarPagamentoParaPedidoPendenteComando(_contexto.CodigoTenant, pedido.Id));

                return(Accepted(pedido));
            }
        }