public async Task RegistrarPagamento(Cliente cliente, Pagamento pagamento)
        {
            if (pagamento.ValorTotal < 20)
            {
                Notificar("O pagamento minímo é R$20,00");
                return;
            }

            if (pagamento.ValorTotal > cliente.SaldoDevedor)
            {
                Notificar("O valor do pagamento não pode ser maior que o valor da divida");
                return;
            }

            pagamento.SetarSaldoDevedorAntes(cliente.SaldoDevedor);
            cliente.EfetuarPagamento(pagamento.ValorTotal);
            pagamento.SetarSaldoDevedorDepois(cliente.SaldoDevedor);

            cliente.Pagamentos.Add(pagamento);

            await _pagamentoRepository.Adicionar(pagamento);

            _clienteRepository.Atualizar(cliente);

            await _UoW.Commit();
        }
        public async Task <bool> AutorizarCompra(Pagamento pagamento)
        {
            if (!pagamento.IsValid)
            {
                return(false);
            }

            return(await _pagamentoRepository.Adicionar(pagamento));
        }
        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);
        }
Example #4
0
        public async Task <bool> Handle(AdicionarPagamentoCartaoCommand message, CancellationToken cancellationToken)
        {
            if (!ValidarComando(message))
            {
                return(false);
            }

            var pagamentoCartao = _mapper.Map <PagamentoCartao>(message);
            await _pagamentoRepository.Adicionar(pagamentoCartao);

            pagamentoCartao.AdicionarEvento(new PagamentoCartaoAdicionadoEvent(pagamentoCartao.Id));
            return(await _pagamentoRepository.UnitOfWork.Commit());
        }
Example #5
0
 public void SalvarPagamento(Pagamento pagamento, List <ItemTrocoPagamento> itensTrocoPagamento)
 {
     try
     {
         _pagamentoRepository.Adicionar(pagamento);
         _itemTrocoPagamentoRepository.Adicionar(itensTrocoPagamento);
     }
     catch (Exception ex)
     {
         throw new PagamentoBusinessException($"Não foi possível realizar a transação. Erro um erro ao gravar as" +
                                              $" informações no servidor: {ex.Message}");
     }
 }
Example #6
0
        public ActionResult Create(Pagamento pagamento)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    //pagamento.Cliente = _RepositoryCliente.BuscarPorId(pagamento.Cliente.Id);

                    Cliente cliente = repositoryCliente.BuscarPorCpf(pagamento.Cliente.Cpf);
                    if (cliente != null && cliente.valorPagar > 0)
                    {
                        pagamento.FormaPagamento = repositoryFormaPagamento.BuscarPorId(pagamento.FormaPagamentoId);
                        pagamento.Cliente        = cliente;

                        repositoryPagamento.Adicionar(pagamento);
                        repositoryPagamento.Salvar();

                        repositoryPagamento.RegistrarPagamento(pagamento);

                        return(RedirectToAction("Listar", "Pagamento"));
                    }
                    else if (cliente.valorPagar == 0)
                    {
                        pagamento.FormaPagamento = repositoryFormaPagamento.BuscarPorId(pagamento.FormaPagamentoId);
                        pagamento.Cliente        = cliente;
                        repositoryPagamento.Adicionar(pagamento);
                        repositoryPagamento.Salvar();
                    }
                }

                return(View(pagamento));
            }
            catch (Exception e)
            {
                return(View(e.Message));
            }
        }
Example #7
0
        public Pagamento Adicionar(Pagamento pagamento)
        {
            if (pagamento.MeioPagamento == MeioPagamento.Cartao)
            {
                // Pagamento na operadora
                pagamento.ValidarCartao();
                if (!PossuiConformidade(pagamento.ValidationResult))
                {
                    return(pagamento);
                }

                // Obtendo detalhes do pedido
                var pedido = _pedidoRepository.ObterPedidoPorId(pagamento.PedidoId);

                // Alterando status para confirmacao do pagamento
                pedido.AlterarStatusPedido(StatusPedido.Pago);
                _pedidoRepository.AtualizarPedido(pedido);

                // Adicionando dados de pedido no pagamento
                pagamento.AssociarPedido(pedido);
            }

            return(_pagamentoRepository.Adicionar(pagamento));
        }