Subversion Repositories Integrator Subversion

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

import java.text.DecimalFormat;
import java.util.ArrayList;
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.CartaoDTO;
import br.com.ec.domain.dto.ContaGerenciadorDTO;
import br.com.ec.domain.dto.ParametrosConsultaLancamentosDTO;
import br.com.ec.domain.model.Categoria;
import br.com.ec.domain.model.Compra;
import br.com.ec.domain.model.Conta;
import br.com.ec.domain.model.ContaBancaria;
import br.com.ec.domain.model.ContaFormaPagamento;
import br.com.ec.domain.model.Parcela;
import br.com.ec.domain.model.Taxa;
import br.com.ec.domain.model.Venda;
import br.com.ec.domain.model.VendaFormaPagamento;
import br.com.ec.domain.model.tipos.TipoCartao;
import br.com.ec.domain.model.tipos.TipoConta;
import br.com.ec.domain.model.tipos.TipoFrequencia;
import br.com.ec.domain.service.categoria.CategoriaService;
import br.com.ec.domain.service.conta.ContaService;
import br.com.ec.domain.service.contaformapagamento.ContaFormaPagamentoService;
import br.com.ec.domain.service.parcela.ParcelaService;
import br.com.ec.domain.service.taxa.TaxaService;
import br.com.ec.domain.service.vendaformapagamento.VendaFormaPagamentoService;
import br.com.ec.domain.service.vigencia.VigenciaService;
import br.com.ec.domain.shared.ConstantesSEC;
import br.com.ec.infrastructure.repository.ParcelaRepository;

@Service
public class ParcelaServiceImpl extends AbstractService<Parcela> implements ParcelaService {

        private ParcelaRepository parcelaRepository;
        private TaxaService taxaService;
        private ContaService contaService;
        private CategoriaService categoriaService;
        private ContaFormaPagamentoService contaFormaPagamentoService;
        private VendaFormaPagamentoService vendaFormaPagamentoService;
        private VigenciaService vigenciaService;
       
        @Autowired
        public ParcelaServiceImpl(Validador validador, ParcelaRepository parcelaRepository, TaxaService taxaService,
                        ContaService contaService, CategoriaService categoriaService, ContaFormaPagamentoService contaFormaPagamentoService,
                        VendaFormaPagamentoService vendaFormaPagamentoService, VigenciaService vigenciaService) {
                super(validador);
                this.parcelaRepository = parcelaRepository;
                this.taxaService = taxaService;
                this.contaService = contaService;
                this.contaFormaPagamentoService = contaFormaPagamentoService;
                this.vendaFormaPagamentoService = vendaFormaPagamentoService;
                this.categoriaService = categoriaService;
                this.vigenciaService = vigenciaService;
        }

        @Override
        protected GenericRepository<Parcela> getRepository() {
                return this.parcelaRepository;
        }
       
        @Override
        protected void regrasNegocioCadastrar(Parcela parcela) {
                verificarParcela(parcela);
        }
       
        @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");
                }
                //TODO: VERIFICAR CADASTRO
                cadastrarContaCasoNaoTenhaSidoCadastrada(parcela.getConta());
//              cadastrarContaCasoNaoTenhaSidoCadastrada(parcela.getConta(), TipoConta.CONTA_A_PAGAR.getValor());
//              cadastrarContaCasoNaoTenhaSidoCadastrada(parcela.getConta(), TipoConta.CONTA_A_RECEBER.getValor());
        }
       
        @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> consultarParcelasAReceber(Date dataRecebimento, TipoCartao tipoCartao) {
                return parcelaRepository.consultarParcelasAReceber(dataRecebimento, tipoCartao);
        }
       
        @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, vendaFormaPagamento, conta);}
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {return criarParcelaCredito(valorParcelaCalculado, taxa, vendaFormaPagamento, conta);}
                return conta;
        }

        private Conta criarParcelaDebito(Double valorParcelaCalculado, Taxa taxa, VendaFormaPagamento vendaFormaPagamento, Conta conta) {
                Date dataDebito = vendaFormaPagamento.getVenda().getDataVenda();
                if (taxa.getQuantidadeDiasPrimeiraParcela() > 0) {
                        dataDebito = DataUtils.acrescentarDiasResultadoDiaUtil(dataDebito, taxa.getQuantidadeDiasPrimeiraParcela());
                }
                cadastrarParcelas(vendaFormaPagamento, taxa.getContaBancaria(), dataDebito, valorParcelaCalculado, conta, taxa.getFormaPagamento().getDescricao());
                return conta;
        }
       
        private Conta criarParcelaCredito(Double valorParcelaCalculado, Taxa taxa, VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {
                if (taxa.getReceberParcelado()) {
                        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;}
                        if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh16x()) {quantidadeVezes = 16;}
                        if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh17x()) {quantidadeVezes = 17;}
                        if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh18x()) {quantidadeVezes = 18;}
                        if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh19x()) {quantidadeVezes = 19;}
                        if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh20x()) {quantidadeVezes = 20;}
                        Date dataParcela = vendaFormaPagamento.getVenda().getDataVenda();
                        Date dataInicial = vendaFormaPagamento.getVenda().getDataVenda();
                        for (int i = 1; i <= quantidadeVezes; i++) {
                                if (i == 1) {
                                        dataParcela = DataUtils.acrescentarDias(dataParcela, taxa.getQuantidadeDiasPrimeiraParcela());
                                } else {
                                        dataParcela = DataUtils.acrescentarDias(dataInicial, i * 30);
                                }
                                dataParcela = DataUtils.acrescentarDiasResultadoDiaUtil(dataParcela, 0);
                                cadastrarParcelas(vendaFormaPagamento, taxa.getContaBancaria(), dataParcela, valorParcelaCalculado / quantidadeVezes, contaAReceber, "CRÉDITO " + i + "/" + quantidadeVezes);
                        }
                } else {
                        Date dataParcela = vendaFormaPagamento.getVenda().getDataVenda();
                        if (taxa.getQuantidadeDiasPrimeiraParcela() > 0) {
                                dataParcela = DataUtils.acrescentarDias(dataParcela, taxa.getQuantidadeDiasPrimeiraParcela());
                                dataParcela = DataUtils.acrescentarDiasResultadoDiaUtil(dataParcela, 0);
                        }
                        cadastrarParcelas(vendaFormaPagamento, taxa.getContaBancaria(), dataParcela, valorParcelaCalculado, contaAReceber, "CRÉDITO 1/1");
                }
                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, vendaFormaPagamento, conta);}
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {criarParcelaCredito(valorParcelaCalculado, taxa, 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);
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDinheiro()) {criarParcelaDinheiro(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, vendaFormaPagamento, conta);}
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {criarParcelaCredito(valorParcelaCalculado, taxa, vendaFormaPagamento, conta);}
                        }
                        return conta;
                }
                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");
        }
       
        private Conta cadastrarContaCasoNaoTenhaSidoCadastrada(Conta conta) {
                if (VerificadorUtil.naoEstaNulo(conta)) {
                        if (VerificadorUtil.estaNulo(conta.getSequencial())) {
                                contaService.cadastrar(conta);
                        }
                }
        return conta;
        }
       
        private Conta criarParcelaDinheiro(VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {
                cadastrarParcelas(vendaFormaPagamento, new ContaBancaria(ContaBancaria.getContaCaixa()), vendaFormaPagamento.getVenda().getDataVenda(), vendaFormaPagamento.getValorPagamento(), contaAReceber, "VALOR");
                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() + " (" + vendaFormaPagamento.getDescricaoDaBandeiraCartao() + ")", vendaFormaPagamento.getFormaPagamento(), 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 ContaGerenciadorDTO cadastrarNovaParcelaPelaFrequencia(Parcela parcela) {
                if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {
                        if (!this.verificarPossuiParcelaAbertaParaPagamento(parcela.getConta())) {
                                if (!parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.UNICA.getValor())) {
                                        Conta contaAPagar = new Conta();
                                        contaAPagar.setCategoria(parcela.getConta().getCategoria());
                                        contaAPagar.setPessoa(parcela.getConta().getPessoa());
                                        contaAPagar.setObservacao(parcela.getConta().getObservacao());
                                        contaAPagar.setTipoFrequencia(parcela.getConta().getTipoFrequencia());
                                        contaAPagar.setIndicadorAtivo(true);
                                        contaAPagar.setTipoConta(TipoConta.CONTA_A_PAGAR.getValor());
                                        contaAPagar.setLoja(parcela.getConta().getLoja());
                                        contaAPagar.setVigencia(parcela.getConta().getVigencia());
                                        if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.MENSAL.getValor())) {
                                                contaAPagar.setVigencia(vigenciaService.consultarProximaVigencia(parcela.getConta().getVigencia()));
                                        }
                                        contaService.cadastrar(contaAPagar);
                                       
                                        List<Parcela> parcelas = parcelaRepository.consultarParcelasDaConta(parcela.getConta());
                                        for (Parcela p : parcelas) {
                                                Parcela novaParcela = new Parcela();
                                                novaParcela.setConta(contaAPagar);
                                                novaParcela.setDataEmissao(DataUtils.getDataAtual());
                                                novaParcela.setContaBancaria(p.getContaBancaria());
                                                novaParcela.setObservacao(p.getObservacao());
                                                novaParcela.setValor(p.getValor());
                                                novaParcela.setIndicadorAtivo(true);
                                                novaParcela.setIndicadorOficial(p.getIndicadorOficial());
                                                if (p.getConta().getTipoFrequencia().equals(TipoFrequencia.DIARIAMENTE.getValor())) {
                                                        novaParcela.setDataVencimento(DataUtils.acrescentarDias(p.getDataVencimento(), 1));
                                                }
                                                if (p.getConta().getTipoFrequencia().equals(TipoFrequencia.SEMANAL.getValor())) {
                                                        novaParcela.setDataVencimento(DataUtils.acrescentarDias(p.getDataVencimento(), 7));
                                                }
                                                if (p.getConta().getTipoFrequencia().equals(TipoFrequencia.MENSAL.getValor())) {
                                                        novaParcela.setDataVencimento(DataUtils.acrescentarMeses(p.getDataVencimento(), 1));
                                                }
                                                if (p.getConta().getTipoFrequencia().equals(TipoFrequencia.ANUAL.getValor())) {
                                                        novaParcela.setDataVencimento(DataUtils.acrescentarAnos(p.getDataVencimento(), 1));
                                                }
                                                this.cadastrar(novaParcela);
                                                novaParcela.setConta(contaAPagar);
                                        }
                                       
                                        ContaGerenciadorDTO contaGerenciador = new ContaGerenciadorDTO();
                                        contaGerenciador.setConta(contaAPagar);
                                        return contaGerenciador;
                                }
                        }
                } else if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {
                        if (!parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.UNICA.getValor())) {
                                Conta contaAReceber = new Conta();
                                contaAReceber.setCategoria(parcela.getConta().getCategoria());
                                contaAReceber.setPessoa(parcela.getConta().getPessoa());
                                contaAReceber.setObservacao(parcela.getConta().getObservacao());
                                contaAReceber.setTipoFrequencia(parcela.getConta().getTipoFrequencia());
                                contaAReceber.setIndicadorAtivo(true);
                                contaAReceber.setTipoConta(TipoConta.CONTA_A_RECEBER.getValor());
                                contaAReceber.setLoja(parcela.getConta().getLoja());
                                contaService.cadastrar(contaAReceber);
                               
                                Parcela novaParcela = new Parcela();
                                novaParcela.setConta(contaAReceber);
                                novaParcela.setDataEmissao(DataUtils.getDataAtual());
                                novaParcela.setContaBancaria(parcela.getContaBancaria());
                                novaParcela.setObservacao(parcela.getObservacao());
                                novaParcela.setValor(parcela.getValor());
                                novaParcela.setIndicadorAtivo(true);
                                if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.DIARIAMENTE.getValor())) {
                                        novaParcela.setDataVencimento(DataUtils.acrescentarDias(parcela.getDataVencimento(), 1));
                                }
                                if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.SEMANAL.getValor())) {
                                        novaParcela.setDataVencimento(DataUtils.acrescentarDias(parcela.getDataVencimento(), 7));
                                }
                                if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.MENSAL.getValor())) {
                                        novaParcela.setDataVencimento(DataUtils.acrescentarMeses(parcela.getDataVencimento(), 1));
                                }
                                if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.ANUAL.getValor())) {
                                        novaParcela.setDataVencimento(DataUtils.acrescentarAnos(parcela.getDataVencimento(), 1));
                                }
                                this.cadastrar(novaParcela);
                                novaParcela.setConta(contaAReceber);
                               
                                ContaGerenciadorDTO contaGerenciador = new ContaGerenciadorDTO();
                                contaGerenciador.setConta(contaAReceber);
                                return contaGerenciador;
                        }
                }
                return null;
        }
       
        @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 Double obterValorPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {
                return parcelaRepository.obterValorPassandoParametrosConsulta(parametrosConsulta);
        }
       
        @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);
        }
*/
}