Subversion Repositories Integrator Subversion

package br.com.ec.domain.service.impl;

import java.util.Date;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import br.com.ec.core.consulta.ParametrosConsulta;

import br.com.ec.core.exception.NegocioException;

import br.com.ec.core.generic.AbstractService;

import br.com.ec.core.generic.GenericRepository;

import br.com.ec.core.util.DataUtils;

import br.com.ec.core.util.VerificadorUtil;

import br.com.ec.core.validador.Validador;

import br.com.ec.domain.dto.FormaPagamentoDTO;

import br.com.ec.domain.dto.ParcelaDTO;

import br.com.ec.domain.dto.VigenciaDTO;

import br.com.ec.domain.dto.consulta.ParametrosConsultaParcelasDTO;

import br.com.ec.domain.model.Conta;

import br.com.ec.domain.model.Parcela;

import br.com.ec.domain.model.Vigencia;

import br.com.ec.domain.model.tipos.TipoFrequencia;

import br.com.ec.domain.service.ContaService;

import br.com.ec.domain.service.ParcelaService;

import br.com.ec.domain.service.VigenciaService;

import br.com.ec.repository.ParcelaRepository;

@Service

public class ParcelaServiceImpl extends AbstractService<Parcela> implements ParcelaService {

        private ParcelaRepository parcelaRepository;

        private ContaService contaService;

        private VigenciaService vigenciaService;

        /*

        private TaxaService taxaService;

        private CategoriaService categoriaService;

        private ContaFormaPagamentoService contaFormaPagamentoService;

        private VendaFormaPagamentoService vendaFormaPagamentoService;

        */

        @Autowired

        public ParcelaServiceImpl(Validador validador, ParcelaRepository parcelaRepository, ContaService contaService,

                        VigenciaService vigenciaService/*, TaxaService taxaService,

                        CategoriaService categoriaService, ContaFormaPagamentoService contaFormaPagamentoService,

                        VendaFormaPagamentoService vendaFormaPagamentoService*/) {

                super(validador);

                this.parcelaRepository = parcelaRepository;

                this.contaService = contaService;

                this.vigenciaService = vigenciaService;

                /*

                this.taxaService = taxaService;

                this.contaFormaPagamentoService = contaFormaPagamentoService;

                this.vendaFormaPagamentoService = vendaFormaPagamentoService;

                this.categoriaService = categoriaService;

                */

        }

        @Override

        protected GenericRepository<Parcela> getRepository() {

                return this.parcelaRepository;

        }

        @Override

        protected void regrasNegocioCadastrar(Parcela parcela) {

                verificarParcela(parcela);

                parcela.setIndicadorNegociacao(false);

        }

        @Override

        protected void regrasNegocioAlterar(Parcela parcela) {

                verificarParcela(parcela);

        }

        private void verificarParcela(Parcela parcela) {

                if (VerificadorUtil.estaNulo(parcela.getDataVencimento()) && VerificadorUtil.estaNulo(parcela.getDataPagamento())) {

                        throw new NegocioException("INFORME A DATA DE VENCIMENTO OU A DATA DE PAGAMENTO");

                }

                cadastrarContaCasoNaoTenhaSidoCadastrada(parcela.getConta());

        }

        @Override

        public List<ParcelaDTO> consultarParcelas(ParametrosConsultaParcelasDTO parametrosConsultaParcelasDTO) {

                return parcelaRepository.consultarParcelas(parametrosConsultaParcelasDTO);

        }

        @Override

        public List<ParcelaDTO> consultarParcelas(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {

                return parcelaRepository.consultarParcelas(sequencialContaBancaria, dataRecebimento, formasDePagamento);

        }

        @Override

        public List<ParcelaDTO> consultarParcelas(String sqlConsulta) {

                return parcelaRepository.consultarParcelas(sqlConsulta);

        }

        @Override

        public List<ParcelaDTO> consultarParcelasAReceber(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {

                return parcelaRepository.consultarParcelasAReceber(sequencialContaBancaria, dataRecebimento, formasDePagamento);

        }

        @Override

        public List<ParcelaDTO> consultarParcelasRecebidas(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {

                return parcelaRepository.consultarParcelasRecebidas(sequencialContaBancaria, dataRecebimento, formasDePagamento);

        }

        @Override

        public List<ParcelaDTO> consultarParcelasDaPessoaEeCategoriaEeVigencia(Long sequencialPessoa, Long sequencialCategoria, Long sequencialVigencia) {

                return parcelaRepository.consultarParcelasDaPessoaEeCategoriaEeVigencia(sequencialPessoa, sequencialCategoria, sequencialVigencia);

        }

        @Override

        public void receberParcelas(Date dataConciliacao, List<ParcelaDTO> parcelasSelecionadas) {

                if (VerificadorUtil.estaNulo(dataConciliacao)) {

                        throw new NegocioException("INFORME A DATA DA CONCILIAÇÃO");

                }

                parcelaRepository.conciliarParcelas(dataConciliacao, parcelasSelecionadas);

        }

        @Override

        public Double obterValorPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {

                return parcelaRepository.obterValorPassandoParametrosConsulta(parametrosConsulta);

        }

        @Override

        public List<ParcelaDTO> consultarParcelasPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {

                return parcelaRepository.consultarParcelasPassandoParametrosConsulta(parametrosConsulta);

        }

        @Override

        public void atualizarObservacaoPagamentos(List<ParcelaDTO> parcelas) {

                for (ParcelaDTO parcelaDTO : parcelas) {

                        parcelaRepository.alterarObservacao(parcelaDTO.getSequencial(), parcelaDTO.getObservacao());

                }

        }

        @Override

        public void efetuarPagamentoRecebimento(ParcelaDTO parcelaDTO, Date dataEfetuar) {

                Parcela parcela = this.consultarPorId(new Parcela(parcelaDTO.getSequencial()));

                if (VerificadorUtil.estaNulo(parcela.getDataPagamento())) {

                        parcela.setDataPagamento(dataEfetuar);

                        this.alterar(parcela);

                        cadastrarNovaParcelaPelaFrequencia(parcela);

                }

        }

        private Conta cadastrarContaCasoNaoTenhaSidoCadastrada(Conta conta) {

                if (VerificadorUtil.naoEstaNulo(conta)) {

                        if (VerificadorUtil.estaNulo(conta.getSequencial())) {

                                contaService.cadastrar(conta);

                        }

                }

        return conta;

        }

        @Override

        public void cadastrarNovaParcelaPelaFrequencia(Parcela parcela) {

                if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {

                        if (!this.verificarPossuiParcelaEmAberta(parcela.getConta().getSequencial(), parcela.getConta().getSequencialDaVenda())) {

                                if (!parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.UNICA.getValor())) {

                                        Conta contaNova = new Conta(parcela.getConta());

                                        contaNova.setSequencial(null);

                                        if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.MENSAL.getValor())) {

                                                Vigencia proximaVigencia = vigenciaService.consultarProximaVigencia(parcela.getConta().getVigencia().getSequencial());

                                                contaNova.setVigencia(proximaVigencia);

                                        }

                                        contaService.cadastrar(contaNova);

                                        List<Parcela> parcelas = parcelaRepository.consultarParcelasDaConta(parcela.getConta().getSequencial());

                                        for (Parcela parcelaAnterior : parcelas) {

                                                Parcela parcelaNova = new Parcela(parcelaAnterior);

                                                parcelaNova.setConta(contaNova);

                                                parcelaNova.setDataEmissao(DataUtils.getDataAtual());

                                                parcelaNova.provisionarNovaDataVencimentoPelaFrequencia();

                                                parcelaNova.setDataPagamento(null);

                                                this.cadastrar(parcelaNova);

                                        }

//                                      ContaGerenciadorDTO contaGerenciador = new ContaGerenciadorDTO();

//                                      contaGerenciador.setConta(contaAPagar);

//                                      return contaGerenciador;

                                }

                        }

                }

                //return null;

        }

        @Override

        public Boolean verificarPossuiParcelaEmAberta(Long sequencialConta, Long sequencialVenda) {

                return parcelaRepository.verificarPossuiParcelaEmAberta(sequencialConta, sequencialVenda);

        }

        @Override

        public void atualizarValorParcela(ParcelaDTO parcelaDTO) {

                parcelaRepository.atualizarValorParcela(parcelaDTO);

        }

        @Override

        public void atualizarCentroDeCustos(Long sequencialConta, Long sequencialCentroDeCustos) {

                parcelaRepository.atualizarCentroDeCustos(sequencialConta, sequencialCentroDeCustos);

        }

        @Override

        public void efetivarConciliacaoAntecipacao(String sqlAtualizacaoParcelas) {

                parcelaRepository.efetivarConciliacaoAntecipacao(sqlAtualizacaoParcelas);

        }

        /*

        @Override

        public void cancelarParcela(Parcela parcela) {

                parcela.setIndicadorAtivo(false);

                this.alterar(parcela);

                cancelarContaSemParcelaAtiva(parcela);

        }

        private void cancelarContaSemParcelaAtiva(Parcela parcela) {

                Parcela parcelaAtiva = new Parcela();

                parcelaAtiva.setIndicadorAtivo(true);

                parcelaAtiva.setConta(parcela.getConta());

                if (this.obterQuantidadeDeRegistrosPassandoEntidade(parcelaAtiva) == 0) {

                        if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {

                                parcela.getConta().setIndicadorAtivo(false);

                                contaService.alterar(parcela.getConta());

                        }

                }

        }

        @Override

        public void receberParcelas(Date dataRecebimento, List<Parcela> parcelasSelecionadas) {

                if (VerificadorUtil.estaNulo(dataRecebimento)) {

                        throw new NegocioException("INFORME A DATA DO RECEBIMENTO");

                }

                for (Parcela parcela : parcelasSelecionadas) {

                        parcela.setDataPagamento(dataRecebimento);

                        this.alterar(parcela);

                }

        }

        @Override

        public void lancarParcela(Parcela parcela) {

                verificarParametros(parcela);

                parcela.getConta().setObservacao(parcela.getObservacao());

                contaService.cadastrar(parcela.getConta());

                parcela.setDataEmissao(DataUtils.getDataAtual());

                parcela.setIndicadorAtivo(true);

                this.cadastrar(parcela);

        }

        private void verificarParametros(Parcela parcela) {

                if (VerificadorUtil.estaNulo(parcela.getContaBancaria())) {

                        throw new NegocioException("INFORME A CONTA");

                }

                if (VerificadorUtil.estaNulo(parcela.getDataPagamento())) {

                        throw new NegocioException("INFORME A DATA DO PAGAMENTO");

                }

                if (VerificadorUtil.estaNulo(parcela.getValor())) {

                        throw new NegocioException("INFORME O VALOR DO PAGAMETNO");

                }

        }

        @Override

        public List<Parcela> consultarParcelas(ParametrosConsultaLancamentosDTO parcelaConsulta) {

                return parcelaRepository.consultarParcelas(parcelaConsulta);

        }

        @Override

        public List<Parcela> consultarParcelasAVencer(Conta conta) {

                return parcelaRepository.consultarParcelasAVencer(conta);

        }

        @Override

        public List<Parcela> consultarParcelasRecebidas(Date dataRecebimento, TipoCartao tipoCartao) {

                return parcelaRepository.consultarParcelasRecebidas(dataRecebimento, tipoCartao);

        }

        @Override

        public List<Parcela> consultarParcelasDaVenda(Long sequencialVenda) {

                return parcelaRepository.consultarParcelasDaVenda(sequencialVenda);

        }

        @Override

        public Conta gerarParcelas(VendaFormaPagamento vendaFormaPagamento, Conta conta) {

                Taxa taxa = consultarTaxa(vendaFormaPagamento);

                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDebito()) {return criarParcelaDebito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {return criarParcelaCredito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {return criarParcelaPagseguro(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                return conta;

        }

        private Conta criarParcelaDebito(Double valorParcelaCalculado, ContaBancaria contaBancaria, VendaFormaPagamento vendaFormaPagamento, Conta conta) {

                Date dataDebito = DataUtils.acrescentarDiasResultadoDiaUtil(vendaFormaPagamento.getVenda().getDataVenda(), 1);

                cadastrarParcelas(vendaFormaPagamento, contaBancaria, dataDebito, valorParcelaCalculado, conta, "DÉBITO");

                return conta;

        }

        private Conta criarParcelaCredito(Double valorParcelaCalculado, ContaBancaria contaBancaria, VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {

                Integer quantidadeVezes = 0;

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh1x()) {quantidadeVezes = 1;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh2x()) {quantidadeVezes = 2;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh3x()) {quantidadeVezes = 3;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh4x()) {quantidadeVezes = 4;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh5x()) {quantidadeVezes = 5;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh6x()) {quantidadeVezes = 6;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh7x()) {quantidadeVezes = 7;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh8x()) {quantidadeVezes = 8;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh9x()) {quantidadeVezes = 9;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh10x()) {quantidadeVezes = 10;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh11x()) {quantidadeVezes = 11;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh12x()) {quantidadeVezes = 12;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh13x()) {quantidadeVezes = 13;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh14x()) {quantidadeVezes = 14;}

                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh15x()) {quantidadeVezes = 15;}

                Date dataParcela = vendaFormaPagamento.getVenda().getDataVenda();

                Date dataInicial = vendaFormaPagamento.getVenda().getDataVenda();

                for (int i = 1; i <= quantidadeVezes; i++) {

                        if (i == 1) {

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh1x()) {

                                        dataParcela = DataUtils.acrescentarDias(dataParcela, 2);

                                } else {

                                        dataParcela = DataUtils.acrescentarDias(dataParcela, 31);

                                }

                        } else {

                                dataParcela = DataUtils.acrescentarDias(dataInicial, i * 30);

                        }

                        dataParcela = DataUtils.acrescentarDiasResultadoDiaUtil(dataParcela, 0);

                        cadastrarParcelas(vendaFormaPagamento, contaBancaria, dataParcela, valorParcelaCalculado / quantidadeVezes, contaAReceber, "CRÉDITO " + i + "/" + quantidadeVezes);

                }

                return contaAReceber;

        }

        @Override

        public Conta gerarParcelasDaVenda(Venda venda, Conta conta) {

                if (VerificadorUtil.naoEstaNulo(conta) && VerificadorUtil.naoEstaNulo(venda)) {

                        conta = cadastrarContaCasoNaoTenhaSidoCadastrada(conta);

                        List<VendaFormaPagamento> listaVendaFormaPagamento = new ArrayList<VendaFormaPagamento>();

                        listaVendaFormaPagamento.addAll(vendaFormaPagamentoService.consultarLancamentosDaVenda(venda));

                        for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {

                                Taxa taxa = consultarTaxa(vendaFormaPagamento);

                                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDinheiro()) {criarParcelaDinheiro(vendaFormaPagamento, conta);}

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDebito()) {criarParcelaDebito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {criarParcelaCredito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {criarParcelaPagseguro(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                        }

                        return conta;

                }

                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");

        }

        @Override

        public Conta gerarParcelasDinheiroDaVenda(Venda venda, Conta contaAReceber) {

                if (VerificadorUtil.naoEstaNulo(contaAReceber) && VerificadorUtil.naoEstaNulo(venda)) {

                        contaAReceber = cadastrarContaCasoNaoTenhaSidoCadastrada(contaAReceber);

                        List<VendaFormaPagamento> listaVendaFormaPagamento = new ArrayList<VendaFormaPagamento>();

                        listaVendaFormaPagamento.addAll(vendaFormaPagamentoService.consultarLancamentosDaVenda(venda));

                        for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {

                                Taxa taxa = consultarTaxa(vendaFormaPagamento);

                                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDinheiro()) {criarParcelaDinheiro(vendaFormaPagamento, contaAReceber);}

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {criarParcelaPagseguro(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, contaAReceber);}

                        }

                        return contaAReceber;

                }

                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");

        }

        @Override

        public Conta gerarParcelasCartaoDaVenda(Venda venda, Conta conta) {

                if (VerificadorUtil.naoEstaNulo(conta) && VerificadorUtil.naoEstaNulo(venda)) {

                        conta = cadastrarContaCasoNaoTenhaSidoCadastrada(conta);

                        List<VendaFormaPagamento> listaVendaFormaPagamento = new ArrayList<VendaFormaPagamento>();

                        listaVendaFormaPagamento.addAll(vendaFormaPagamentoService.consultarLancamentosDaVenda(venda));

                        for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {

                                Taxa taxa = consultarTaxa(vendaFormaPagamento);

                                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDebito()) {criarParcelaDebito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {criarParcelaCredito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}

                        }

                        return conta;

                }

                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");

        }

        private Conta criarParcelaDinheiro(VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {

                cadastrarParcelas(vendaFormaPagamento, new ContaBancaria(ContaBancaria.getContaCaixa()), vendaFormaPagamento.getVenda().getDataVenda(), vendaFormaPagamento.getValorPagamento(), contaAReceber, "VALOR");

                return contaAReceber;

        }

        private Conta criarParcelaPagseguro(Double valorParcelaCalculado, ContaBancaria contaBancaria, VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {

                cadastrarParcelas(vendaFormaPagamento, contaBancaria, vendaFormaPagamento.getVenda().getDataVenda(), valorParcelaCalculado, contaAReceber, "PAGSEGURO");

                return contaAReceber;

        }

        private Taxa consultarTaxa(VendaFormaPagamento vendaFormaPagamento) {

                Taxa taxa = new Taxa();

                taxa.setEmpresaAdquirente(vendaFormaPagamento.getEmpresaAdquirenteDaMaquinetaDaVenda());

                taxa.setFormaPagamento(vendaFormaPagamento.getFormaPagamento());

                taxa.setBandeiraCartao(vendaFormaPagamento.getBandeiraCartao());

                taxa = taxaService.consultarTaxa(taxa);

                if (VerificadorUtil.estaNulo(taxa)) {

                        taxa = new Taxa();

                        taxa.setEmpresaAdquirente(vendaFormaPagamento.getEmpresaAdquirenteDaMaquinetaDaVenda());

                        taxa.setFormaPagamento(vendaFormaPagamento.getFormaPagamento());

                        taxa = taxaService.consultarTaxa(taxa);

                }

                if (VerificadorUtil.estaNulo(taxa)) {

                        taxa = new Taxa();

                        taxa.setContaBancaria(new ContaBancaria(new Long(1)));

                }

                return taxa;

        }

        private Double calcularValorParcela(Taxa taxa, Double valorPagamento) {

                Double valorParcelaCalculado = new Double(0.0);

                if (VerificadorUtil.naoEstaNulo(taxa)) {

                        if (VerificadorUtil.naoEstaNulo(taxa.getValor())) {

                                valorParcelaCalculado = descontarTaxa(valorPagamento, taxa.getValor());

                        } else {

                                return valorPagamento;

                        }

                }

                return valorParcelaCalculado;

        }

        private Double descontarTaxa(Double valorPagamento, Double taxa) {

                return new Double (new DecimalFormat("#.##").format(valorPagamento - (valorPagamento * taxa / 100)).replace(",", "."));

        }

        private void cadastrarParcelas(VendaFormaPagamento vendaFormaPagamento, ContaBancaria contaBancaria, Date dataVencimento, Double valorPagamento, Conta conta, String observacao) {

                Parcela parcela = new Parcela(conta, contaBancaria, vendaFormaPagamento.getVenda().getDataVenda(), dataVencimento, null, valorPagamento, observacao + " DA VENDA: " + vendaFormaPagamento.getVenda().getSequencial(), true);

                this.cadastrar(parcela);

        }

        @Override

        public Boolean verificarPossuiParcelaAberta(Venda venda) {

                return parcelaRepository.verificarPossuiParcelaAberta(venda);

        }

        @Override

        public Boolean verificarPossuiParcelaAbertaParaPagamento(Conta conta) {

                return parcelaRepository.verificarPossuiParcelaAbertaParaPagamento(conta);

        }

        @Override

        public Boolean verificarPossuiParcela(Venda venda) {

                return parcelaRepository.verificarPossuiParcela(venda);

        }

        @Override

        public List<CartaoDTO> gerarContasDosCartoes(List<VendaFormaPagamento> listaVendaFormaPagamento) {

                List<CartaoDTO> contas = new ArrayList<CartaoDTO>();

                for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {

                        Conta contaAReceber = new Conta();

                        contaAReceber.setLoja(vendaFormaPagamento.getVenda().getLoja());

                        contaAReceber.setIndicadorAtivo(true);

                        contaAReceber.setTipoFrequencia(TipoFrequencia.UNICA.getValor());

                        contaAReceber.setTipoConta(TipoConta.CONTA_A_RECEBER.getValor());

                        contaAReceber.setObservacao("VENDA: " + vendaFormaPagamento.getSequencialDaVenda());

                        contaAReceber.setVenda(vendaFormaPagamento.getVenda());

                        ContaFormaPagamento contaFormaPagamento = new ContaFormaPagamento(vendaFormaPagamento);

                        contaFormaPagamentoService.cadastrar(contaFormaPagamento);

                        contaAReceber.setFormaDePagamento(contaFormaPagamento);

                        contaService.cadastrar(contaAReceber);

                        List<Parcela> parcelas = new ArrayList<Parcela>();

                        this.gerarParcelas(vendaFormaPagamento, contaAReceber);

                        parcelas = this.consultarParcelasAVencer(contaAReceber);

                        for (Parcela parcela : parcelas) {

                                CartaoDTO cartao = new CartaoDTO();

                                cartao.setParcela(parcela);

                                cartao.setBandeira(vendaFormaPagamento.getDescricaoDaBandeiraCartao());

                                cartao.setFormaDePagamento(vendaFormaPagamento.getFormaPagamento());

                                cartao.setDataVenda(vendaFormaPagamento.getVenda().getDataVenda());

                                cartao.setBruto(vendaFormaPagamento.getValorPagamento());

                                contas.add(cartao);

                        }

                }

                return contas;

        }

        @Override

        public List<CartaoDTO> consultarContasDosCartoes(Date dataInicial, Date dataFinal) {

                List<CartaoDTO> contas = new ArrayList<CartaoDTO>();

                List<Conta> contasAReceber = consultarContasAReceber(dataInicial, dataFinal);

                if (VerificadorUtil.naoEstaNuloOuVazio(contasAReceber)) {

                        for (Conta contaAReceber : contasAReceber) {

                                List<Parcela> parcelas = this.consultarParcelasAVencer(contaAReceber);

                                for (Parcela parcela : parcelas) {

                                        CartaoDTO cartao = new CartaoDTO();

                                        cartao.setParcela(parcela);

                                        if (VerificadorUtil.naoEstaNulo(contaAReceber.getFormaDePagamento())) {

                                                cartao.setBandeira(contaAReceber.getFormaDePagamento().getBandeiraCartao().getDescricao());

                                                cartao.setFormaDePagamento(contaAReceber.getFormaDePagamento().getFormaPagamento());

                                                cartao.setBruto(contaAReceber.getFormaDePagamento().getValorPagamento());

                                        }

                                        cartao.setDataVenda(contaAReceber.getVenda().getDataVenda());

                                        contas.add(cartao);

                                }

                        }

                }

                return contas;

        }

        private List<Conta> consultarContasAReceber(Date dataInicial, Date dataFinal) {

                return contaService.consultarContasAReceberPorPeriodo(dataInicial, dataFinal);

        }

        @Override

        public void cadastrarContaComParcelasNaCompra(Compra compra, List<Parcela> listaParcelas) {

                if (VerificadorUtil.naoEstaNuloOuVazio(listaParcelas)) {

                        Conta contaAPagar = new Conta(TipoConta.CONTA_A_PAGAR.getValor());

                        Categoria categoriaProduto = new Categoria();

                        categoriaProduto.setSequencial(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_PRODUTO_7);

                        contaAPagar.setCategoria(categoriaService.consultarPorId(categoriaProduto));

                        contaAPagar.setPessoa(compra.getFornecedor().getPessoa());

                        contaAPagar.setIndicadorAtivo(true);

                        contaAPagar.setTipoFrequencia(TipoFrequencia.UNICA.getValor());

                        contaService.cadastrar(contaAPagar);

                        for (Parcela parcela : listaParcelas) {

                                parcela.setObservacao(compra.getFornecedor().getNomeAbreviadoDaPessoa() + " " + parcela.getObservacao());

                                parcela.setConta(contaAPagar);

                                this.cadastrar(parcela);

                        }

                        compra.setConta(contaAPagar);

                }

        }

        public static void main(String[] args) {

                String numero = "GBMAX NF 032393 001/003";

                System.out.println(removeZeros(numero));

        }

        public static String removeZeros(String linha) { return linha.replaceFirst("0*", ""); }

        */

        /*

        @Override

        public void parcelamento(Parcela parcela, Integer quantidadeParcelas) {

                Double valorTotal = parcela.getValor();

                Double valorDaParcela = valorTotal/quantidadeParcelas;

                Date dataVencimento = new Date(parcela.getDataVencimento().getTime());

                for (int i = 1; i <= quantidadeParcelas; i++) {

                        Parcela parcelado = new Parcela(null, parcela.getContaAPagar(), parcela.getContaBancaria(), DataUtils.getDataAtual(), dataVencimento, null, valorDaParcela, i + "ª PARCELA DA CONTA: " + parcela.getContaAPagar().getSequencial(), true);

                        parcelaRepository.cadastrar(parcelado);

                        dataVencimento = new Date(DataUtils.acrescentarDiasResultadoDiaUtil(dataVencimento, 30).getTime());

                }

        }

        private void cadastrarParcelas(VendaFormaPagamento vendaFormaPagamento, ContaBancaria contaBancaria, Date dataVencimento, Double valorPagamento, ContaAReceber contaAReceber, String observacao) {

                Parcela parcela = new Parcela(contaAReceber, null, contaBancaria, vendaFormaPagamento.getVenda().getDataVenda(), dataVencimento, null, valorPagamento, observacao + " DA VENDA: " + vendaFormaPagamento.getVenda().getSequencial(), true);

                parcelaRepository.cadastrar(parcela);

        }

        @Override

        public List<Parcela> consultarParcelasPorPeriodo(Parcela parcela, Boolean pagamentoRealizado, Boolean ehContaAReceber, Date dataInicial, Date dataFinal, String ordenacao, int first, int pageSize) {

                return parcelaRepository.consultarParcelasPorPeriodo(parcela, pagamentoRealizado, ehContaAReceber, dataInicial, dataFinal, ordenacao, first, pageSize);

        }

        @Override

        public Integer obterQuantidadeRegistrosConsultarParcelasPorPeriodo(Parcela parcela, Boolean pagamentoRealizado, Boolean ehContaAReceber, Date dataInicial, Date dataFinal) {

                return parcelaRepository.obterQuantidadeRegistrosConsultarParcelasPorPeriodo(parcela, pagamentoRealizado, ehContaAReceber, dataInicial, dataFinal);

        }

*/

}