Subversion Repositories Integrator Subversion

Rev

Rev 439 | Rev 610 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
259 espaco 1 
package br.com.ec.domain.service.impl;
2 
 
282 espaco 3 
import java.util.Date;
4 
import java.util.List;
5 
 
259 espaco 6 
import org.springframework.beans.factory.annotation.Autowired;
7 
import org.springframework.stereotype.Service;
8 
 
296 espaco 9 
import br.com.ec.core.consulta.ParametrosConsulta;
10 
import br.com.ec.core.exception.NegocioException;
259 espaco 11 
import br.com.ec.core.generic.AbstractService;
12 
import br.com.ec.core.generic.GenericRepository;
439 espaco 13 
import br.com.ec.core.util.DataUtils;
296 espaco 14 
import br.com.ec.core.util.VerificadorUtil;
259 espaco 15 
import br.com.ec.core.validador.Validador;
296 espaco 16 
import br.com.ec.domain.dto.FormaPagamentoDTO;
282 espaco 17 
import br.com.ec.domain.dto.ParcelaDTO;
439 espaco 18 
import br.com.ec.domain.dto.VigenciaDTO;
282 espaco 19 
import br.com.ec.domain.dto.consulta.ParametrosConsultaParcelasDTO;
439 espaco 20 
import br.com.ec.domain.model.Conta;
259 espaco 21 
import br.com.ec.domain.model.Parcela;
439 espaco 22 
import br.com.ec.domain.model.Vigencia;
23 
import br.com.ec.domain.model.tipos.TipoFrequencia;
24 
import br.com.ec.domain.service.ContaService;
259 espaco 25 
import br.com.ec.domain.service.ParcelaService;
439 espaco 26 
import br.com.ec.domain.service.VigenciaService;
259 espaco 27 
import br.com.ec.repository.ParcelaRepository;
28 
 
29 
@Service
30 
public class ParcelaServiceImpl extends AbstractService<Parcela> implements ParcelaService {
274 espaco 31 
 
259 espaco 32 
        private ParcelaRepository parcelaRepository;
439 espaco 33 
        private ContaService contaService;
34 
        private VigenciaService vigenciaService;
35 
 
274 espaco 36 
        /*
259 espaco 37 
        private TaxaService taxaService;
38 
        private CategoriaService categoriaService;
39 
        private ContaFormaPagamentoService contaFormaPagamentoService;
40 
        private VendaFormaPagamentoService vendaFormaPagamentoService;
439 espaco 41 
        */
274 espaco 42 
 
259 espaco 43 
        @Autowired
439 espaco 44 
        public ParcelaServiceImpl(Validador validador, ParcelaRepository parcelaRepository, ContaService contaService,
45 
                        VigenciaService vigenciaService/*, TaxaService taxaService,
46 
                        CategoriaService categoriaService, ContaFormaPagamentoService contaFormaPagamentoService,
47 
                        VendaFormaPagamentoService vendaFormaPagamentoService*/) {
259 espaco 48 
                super(validador);
49 
                this.parcelaRepository = parcelaRepository;
439 espaco 50 
                this.contaService = contaService;
51 
                this.vigenciaService = vigenciaService;
259 espaco 52 
                /*
53 
                this.taxaService = taxaService;
54 
                this.contaFormaPagamentoService = contaFormaPagamentoService;
55 
                this.vendaFormaPagamentoService = vendaFormaPagamentoService;
56 
                this.categoriaService = categoriaService;
57 
                */
58 
        }
59 
 
60 
        @Override
61 
        protected GenericRepository<Parcela> getRepository() {
62 
                return this.parcelaRepository;
63 
        }
282 espaco 64 
 
65 
        @Override
439 espaco 66 
        protected void regrasNegocioCadastrar(Parcela parcela) {
67 
                verificarParcela(parcela);
575 blopes 68 
                parcela.setIndicadorNegociacao(false);
439 espaco 69 
        }
70 
 
71 
        @Override
72 
        protected void regrasNegocioAlterar(Parcela parcela) {
73 
                verificarParcela(parcela);
74 
        }
75 
 
76 
        private void verificarParcela(Parcela parcela) {
77 
                if (VerificadorUtil.estaNulo(parcela.getDataVencimento()) && VerificadorUtil.estaNulo(parcela.getDataPagamento())) {
78 
                        throw new NegocioException("INFORME A DATA DE VENCIMENTO OU A DATA DE PAGAMENTO");
79 
                }
80 
                cadastrarContaCasoNaoTenhaSidoCadastrada(parcela.getConta());
81 
        }
82 
 
83 
        @Override
282 espaco 84 
        public List<ParcelaDTO> consultarParcelas(ParametrosConsultaParcelasDTO parametrosConsultaParcelasDTO) {
85 
                return parcelaRepository.consultarParcelas(parametrosConsultaParcelasDTO);
86 
        }
87 
 
88 
        @Override
382 espaco 89 
        public List<ParcelaDTO> consultarParcelas(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {
90 
                return parcelaRepository.consultarParcelas(sequencialContaBancaria, dataRecebimento, formasDePagamento);
91 
        }
92 
 
93 
        @Override
296 espaco 94 
        public List<ParcelaDTO> consultarParcelasAReceber(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {
95 
                return parcelaRepository.consultarParcelasAReceber(sequencialContaBancaria, dataRecebimento, formasDePagamento);
282 espaco 96 
        }
97 
 
98 
        @Override
296 espaco 99 
        public List<ParcelaDTO> consultarParcelasRecebidas(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {
100 
                return parcelaRepository.consultarParcelasRecebidas(sequencialContaBancaria, dataRecebimento, formasDePagamento);
282 espaco 101 
        }
102 
 
296 espaco 103 
        @Override
104 
        public void receberParcelas(Date dataConciliacao, List<ParcelaDTO> parcelasSelecionadas) {
105 
                if (VerificadorUtil.estaNulo(dataConciliacao)) {
106 
                        throw new NegocioException("INFORME A DATA DA CONCILIAÇÃO");
107 
                }
383 espaco 108 
                parcelaRepository.conciliarParcelas(dataConciliacao, parcelasSelecionadas);
296 espaco 109 
        }
110 
 
111 
        @Override
112 
        public Double obterValorPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {
113 
                return parcelaRepository.obterValorPassandoParametrosConsulta(parametrosConsulta);
114 
        }
115 
 
297 espaco 116 
        @Override
117 
        public List<ParcelaDTO> consultarParcelasPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {
118 
                return parcelaRepository.consultarParcelasPassandoParametrosConsulta(parametrosConsulta);
119 
        }
120 
 
402 espaco 121 
        @Override
122 
        public void atualizarObservacaoPagamentos(List<ParcelaDTO> parcelas) {
123 
                for (ParcelaDTO parcelaDTO : parcelas) {
124 
                        parcelaRepository.alterarObservacao(parcelaDTO.getSequencial(), parcelaDTO.getObservacao());
125 
                }
126 
        }
127 
 
259 espaco 128 
        @Override
439 espaco 129 
        public void efetuarPagamentoRecebimento(ParcelaDTO parcelaDTO, Date dataEfetuar) {
130 
                Parcela parcela = this.consultarPorId(new Parcela(parcelaDTO.getSequencial()));
131 
                if (VerificadorUtil.estaNulo(parcela.getDataPagamento())) {
132 
                        parcela.setDataPagamento(dataEfetuar);
133 
                        this.alterar(parcela);
134 
                        cadastrarNovaParcelaPelaFrequencia(parcela);
135 
                }
259 espaco 136 
        }
137 
 
439 espaco 138 
        private Conta cadastrarContaCasoNaoTenhaSidoCadastrada(Conta conta) {
139 
                if (VerificadorUtil.naoEstaNulo(conta)) {
140 
                        if (VerificadorUtil.estaNulo(conta.getSequencial())) {
141 
                                contaService.cadastrar(conta);
142 
                        }
143 
                }
144 
        return conta;
259 espaco 145 
        }
274 espaco 146 
 
439 espaco 147 
        @Override
148 
        public void cadastrarNovaParcelaPelaFrequencia(Parcela parcela) {
149 
                if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {
150 
                        if (!this.verificarPossuiParcelaEmAberta(parcela.getConta().getSequencial(), parcela.getConta().getSequencialDaVenda())) {
151 
                                if (!parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.UNICA.getValor())) {
152 
                                        Conta contaNova = new Conta(parcela.getConta());
153 
                                        contaNova.setSequencial(null);
154 
                                        if (parcela.getConta().getTipoFrequencia().equals(TipoFrequencia.MENSAL.getValor())) {
155 
                                                Vigencia proximaVigencia = vigenciaService.consultarProximaVigencia(parcela.getConta().getVigencia().getSequencial());
156 
                                                contaNova.setVigencia(proximaVigencia);
157 
                                        }
158 
                                        contaService.cadastrar(contaNova);
159 
 
160 
                                        List<Parcela> parcelas = parcelaRepository.consultarParcelasDaConta(parcela.getConta().getSequencial());
161 
                                        for (Parcela parcelaAnterior : parcelas) {
162 
                                                Parcela parcelaNova = new Parcela(parcelaAnterior);
163 
                                                parcelaNova.setConta(contaNova);
164 
                                                parcelaNova.setDataEmissao(DataUtils.getDataAtual());
165 
                                                parcelaNova.provisionarNovaDataVencimentoPelaFrequencia();
166 
                                                parcelaNova.setDataPagamento(null);
167 
                                                this.cadastrar(parcelaNova);
168 
                                        }
169 
//                                      ContaGerenciadorDTO contaGerenciador = new ContaGerenciadorDTO();
170 
//                                      contaGerenciador.setConta(contaAPagar);
171 
//                                      return contaGerenciador;
172 
                                }
173 
                        }
259 espaco 174 
                }
439 espaco 175 
                //return null;
259 espaco 176 
        }
177 
 
178 
        @Override
439 espaco 179 
        public Boolean verificarPossuiParcelaEmAberta(Long sequencialConta, Long sequencialVenda) {
180 
                return parcelaRepository.verificarPossuiParcelaEmAberta(sequencialConta, sequencialVenda);
181 
        }
182 
 
183 
        /*
184 
        @Override
259 espaco 185 
        public void cancelarParcela(Parcela parcela) {
186 
                parcela.setIndicadorAtivo(false);
187 
                this.alterar(parcela);
188 
                cancelarContaSemParcelaAtiva(parcela);
189 
        }
190 
 
191 
        private void cancelarContaSemParcelaAtiva(Parcela parcela) {
192 
                Parcela parcelaAtiva = new Parcela();
193 
                parcelaAtiva.setIndicadorAtivo(true);
194 
                parcelaAtiva.setConta(parcela.getConta());
195 
                if (this.obterQuantidadeDeRegistrosPassandoEntidade(parcelaAtiva) == 0) {
196 
                        if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {
197 
                                parcela.getConta().setIndicadorAtivo(false);
198 
                                contaService.alterar(parcela.getConta());
199 
                        }
200 
                }
201 
        }
202 
 
203 
        @Override
204 
        public void receberParcelas(Date dataRecebimento, List<Parcela> parcelasSelecionadas) {
205 
                if (VerificadorUtil.estaNulo(dataRecebimento)) {
206 
                        throw new NegocioException("INFORME A DATA DO RECEBIMENTO");
207 
                }
208 
                for (Parcela parcela : parcelasSelecionadas) {
209 
                        parcela.setDataPagamento(dataRecebimento);
210 
                        this.alterar(parcela);
211 
                }
212 
        }
213 
 
214 
        @Override
215 
        public void lancarParcela(Parcela parcela) {
216 
                verificarParametros(parcela);
217 
                parcela.getConta().setObservacao(parcela.getObservacao());
218 
                contaService.cadastrar(parcela.getConta());
219 
 
220 
                parcela.setDataEmissao(DataUtils.getDataAtual());
221 
                parcela.setIndicadorAtivo(true);
222 
                this.cadastrar(parcela);
223 
        }
224 
 
225 
        private void verificarParametros(Parcela parcela) {
226 
                if (VerificadorUtil.estaNulo(parcela.getContaBancaria())) {
227 
                        throw new NegocioException("INFORME A CONTA");
228 
                }
229 
                if (VerificadorUtil.estaNulo(parcela.getDataPagamento())) {
230 
                        throw new NegocioException("INFORME A DATA DO PAGAMENTO");
231 
                }
232 
                if (VerificadorUtil.estaNulo(parcela.getValor())) {
233 
                        throw new NegocioException("INFORME O VALOR DO PAGAMETNO");
234 
                }
235 
        }
236 
 
237 
        @Override
238 
        public List<Parcela> consultarParcelas(ParametrosConsultaLancamentosDTO parcelaConsulta) {
239 
                return parcelaRepository.consultarParcelas(parcelaConsulta);
240 
        }
241 
 
242 
        @Override
243 
        public List<Parcela> consultarParcelasAVencer(Conta conta) {
244 
                return parcelaRepository.consultarParcelasAVencer(conta);
245 
        }
246 
 
247 
        @Override
248 
        public List<Parcela> consultarParcelasRecebidas(Date dataRecebimento, TipoCartao tipoCartao) {
249 
                return parcelaRepository.consultarParcelasRecebidas(dataRecebimento, tipoCartao);
250 
        }
251 
 
252 
        @Override
253 
        public List<Parcela> consultarParcelasDaVenda(Long sequencialVenda) {
254 
                return parcelaRepository.consultarParcelasDaVenda(sequencialVenda);
255 
        }
256 
 
257 
        @Override
258 
        public Conta gerarParcelas(VendaFormaPagamento vendaFormaPagamento, Conta conta) {
259 
                Taxa taxa = consultarTaxa(vendaFormaPagamento);
260 
                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());
261 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDebito()) {return criarParcelaDebito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
262 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {return criarParcelaCredito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
263 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {return criarParcelaPagseguro(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
264 
                return conta;
265 
        }
266 
 
267 
        private Conta criarParcelaDebito(Double valorParcelaCalculado, ContaBancaria contaBancaria, VendaFormaPagamento vendaFormaPagamento, Conta conta) {
268 
                Date dataDebito = DataUtils.acrescentarDiasResultadoDiaUtil(vendaFormaPagamento.getVenda().getDataVenda(), 1);
269 
                cadastrarParcelas(vendaFormaPagamento, contaBancaria, dataDebito, valorParcelaCalculado, conta, "DÉBITO");
270 
                return conta;
271 
        }
272 
 
273 
        private Conta criarParcelaCredito(Double valorParcelaCalculado, ContaBancaria contaBancaria, VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {
274 
                Integer quantidadeVezes = 0;
275 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh1x()) {quantidadeVezes = 1;}
276 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh2x()) {quantidadeVezes = 2;}
277 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh3x()) {quantidadeVezes = 3;}
278 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh4x()) {quantidadeVezes = 4;}
279 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh5x()) {quantidadeVezes = 5;}
280 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh6x()) {quantidadeVezes = 6;}
281 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh7x()) {quantidadeVezes = 7;}
282 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh8x()) {quantidadeVezes = 8;}
283 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh9x()) {quantidadeVezes = 9;}
284 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh10x()) {quantidadeVezes = 10;}
285 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh11x()) {quantidadeVezes = 11;}
286 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh12x()) {quantidadeVezes = 12;}
274 espaco 287 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh13x()) {quantidadeVezes = 13;}
288 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh14x()) {quantidadeVezes = 14;}
289 
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh15x()) {quantidadeVezes = 15;}
259 espaco 290 
                Date dataParcela = vendaFormaPagamento.getVenda().getDataVenda();
291 
                Date dataInicial = vendaFormaPagamento.getVenda().getDataVenda();
292 
                for (int i = 1; i <= quantidadeVezes; i++) {
293 
                        if (i == 1) {
294 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEh1x()) {
295 
                                        dataParcela = DataUtils.acrescentarDias(dataParcela, 2);
296 
                                } else {
297 
                                        dataParcela = DataUtils.acrescentarDias(dataParcela, 31);
298 
                                }
299 
                        } else {
300 
                                dataParcela = DataUtils.acrescentarDias(dataInicial, i * 30);
301 
                        }
302 
                        dataParcela = DataUtils.acrescentarDiasResultadoDiaUtil(dataParcela, 0);
303 
                        cadastrarParcelas(vendaFormaPagamento, contaBancaria, dataParcela, valorParcelaCalculado / quantidadeVezes, contaAReceber, "CRÉDITO " + i + "/" + quantidadeVezes);
304 
                }
305 
                return contaAReceber;
306 
        }
307 
 
308 
        @Override
309 
        public Conta gerarParcelasDaVenda(Venda venda, Conta conta) {
310 
                if (VerificadorUtil.naoEstaNulo(conta) && VerificadorUtil.naoEstaNulo(venda)) {
311 
                        conta = cadastrarContaCasoNaoTenhaSidoCadastrada(conta);
312 
                        List<VendaFormaPagamento> listaVendaFormaPagamento = new ArrayList<VendaFormaPagamento>();
313 
                        listaVendaFormaPagamento.addAll(vendaFormaPagamentoService.consultarLancamentosDaVenda(venda));
314 
                        for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {
315 
                                Taxa taxa = consultarTaxa(vendaFormaPagamento);
316 
                                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());
317 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDinheiro()) {criarParcelaDinheiro(vendaFormaPagamento, conta);}
318 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDebito()) {criarParcelaDebito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
319 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {criarParcelaCredito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
320 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {criarParcelaPagseguro(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
321 
                        }
322 
                        return conta;
323 
                }
324 
                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");
325 
        }
326 
 
327 
        @Override
328 
        public Conta gerarParcelasDinheiroDaVenda(Venda venda, Conta contaAReceber) {
329 
                if (VerificadorUtil.naoEstaNulo(contaAReceber) && VerificadorUtil.naoEstaNulo(venda)) {
330 
                        contaAReceber = cadastrarContaCasoNaoTenhaSidoCadastrada(contaAReceber);
331 
                        List<VendaFormaPagamento> listaVendaFormaPagamento = new ArrayList<VendaFormaPagamento>();
332 
                        listaVendaFormaPagamento.addAll(vendaFormaPagamentoService.consultarLancamentosDaVenda(venda));
333 
                        for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {
334 
                                Taxa taxa = consultarTaxa(vendaFormaPagamento);
335 
                                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());
336 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDinheiro()) {criarParcelaDinheiro(vendaFormaPagamento, contaAReceber);}
337 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {criarParcelaPagseguro(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, contaAReceber);}
338 
                        }
339 
                        return contaAReceber;
340 
                }
341 
                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");
342 
        }
343 
 
344 
        @Override
345 
        public Conta gerarParcelasCartaoDaVenda(Venda venda, Conta conta) {
346 
                if (VerificadorUtil.naoEstaNulo(conta) && VerificadorUtil.naoEstaNulo(venda)) {
347 
                        conta = cadastrarContaCasoNaoTenhaSidoCadastrada(conta);
348 
                        List<VendaFormaPagamento> listaVendaFormaPagamento = new ArrayList<VendaFormaPagamento>();
349 
                        listaVendaFormaPagamento.addAll(vendaFormaPagamentoService.consultarLancamentosDaVenda(venda));
350 
                        for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {
351 
                                Taxa taxa = consultarTaxa(vendaFormaPagamento);
352 
                                Double valorParcelaCalculado = calcularValorParcela(taxa, vendaFormaPagamento.getValorPagamento());
353 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhDebito()) {criarParcelaDebito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
354 
                                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCredito()) {criarParcelaCredito(valorParcelaCalculado, taxa.getContaBancaria(), vendaFormaPagamento, conta);}
355 
                        }
356 
                        return conta;
357 
                }
358 
                throw new NegocioException("NENHUMA PARCELA FOI CRIADA");
359 
        }
360 
 
361 
        private Conta criarParcelaDinheiro(VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {
362 
                cadastrarParcelas(vendaFormaPagamento, new ContaBancaria(ContaBancaria.getContaCaixa()), vendaFormaPagamento.getVenda().getDataVenda(), vendaFormaPagamento.getValorPagamento(), contaAReceber, "VALOR");
363 
                return contaAReceber;
364 
        }
365 
 
366 
        private Conta criarParcelaPagseguro(Double valorParcelaCalculado, ContaBancaria contaBancaria, VendaFormaPagamento vendaFormaPagamento, Conta contaAReceber) {
367 
                cadastrarParcelas(vendaFormaPagamento, contaBancaria, vendaFormaPagamento.getVenda().getDataVenda(), valorParcelaCalculado, contaAReceber, "PAGSEGURO");
368 
                return contaAReceber;
369 
        }
370 
 
371 
        private Taxa consultarTaxa(VendaFormaPagamento vendaFormaPagamento) {
372 
                Taxa taxa = new Taxa();
373 
                taxa.setEmpresaAdquirente(vendaFormaPagamento.getEmpresaAdquirenteDaMaquinetaDaVenda());
374 
                taxa.setFormaPagamento(vendaFormaPagamento.getFormaPagamento());
375 
                taxa.setBandeiraCartao(vendaFormaPagamento.getBandeiraCartao());
376 
                taxa = taxaService.consultarTaxa(taxa);
377 
                if (VerificadorUtil.estaNulo(taxa)) {
378 
                        taxa = new Taxa();
379 
                        taxa.setEmpresaAdquirente(vendaFormaPagamento.getEmpresaAdquirenteDaMaquinetaDaVenda());
380 
                        taxa.setFormaPagamento(vendaFormaPagamento.getFormaPagamento());
381 
                        taxa = taxaService.consultarTaxa(taxa);
382 
                }
383 
                if (VerificadorUtil.estaNulo(taxa)) {
384 
                        taxa = new Taxa();
385 
                        taxa.setContaBancaria(new ContaBancaria(new Long(1)));
386 
                }
387 
                return taxa;
388 
        }
389 
 
390 
        private Double calcularValorParcela(Taxa taxa, Double valorPagamento) {
391 
                Double valorParcelaCalculado = new Double(0.0);
392 
                if (VerificadorUtil.naoEstaNulo(taxa)) {
393 
                        if (VerificadorUtil.naoEstaNulo(taxa.getValor())) {
394 
                                valorParcelaCalculado = descontarTaxa(valorPagamento, taxa.getValor());
395 
                        } else {
396 
                                return valorPagamento;
397 
                        }
398 
                }
399 
                return valorParcelaCalculado;
400 
        }
401 
 
402 
        private Double descontarTaxa(Double valorPagamento, Double taxa) {
403 
                return new Double (new DecimalFormat("#.##").format(valorPagamento - (valorPagamento * taxa / 100)).replace(",", "."));
404 
        }
405 
 
406 
        private void cadastrarParcelas(VendaFormaPagamento vendaFormaPagamento, ContaBancaria contaBancaria, Date dataVencimento, Double valorPagamento, Conta conta, String observacao) {
407 
                Parcela parcela = new Parcela(conta, contaBancaria, vendaFormaPagamento.getVenda().getDataVenda(), dataVencimento, null, valorPagamento, observacao + " DA VENDA: " + vendaFormaPagamento.getVenda().getSequencial(), true);
408 
                this.cadastrar(parcela);
409 
        }
410 
 
411 
        @Override
412 
        public Boolean verificarPossuiParcelaAberta(Venda venda) {
413 
                return parcelaRepository.verificarPossuiParcelaAberta(venda);
414 
        }
415 
 
416 
        @Override
417 
        public Boolean verificarPossuiParcelaAbertaParaPagamento(Conta conta) {
418 
                return parcelaRepository.verificarPossuiParcelaAbertaParaPagamento(conta);
419 
        }
420 
 
421 
        @Override
422 
        public Boolean verificarPossuiParcela(Venda venda) {
423 
                return parcelaRepository.verificarPossuiParcela(venda);
424 
        }
425 
 
426 
        @Override
427 
        public List<CartaoDTO> gerarContasDosCartoes(List<VendaFormaPagamento> listaVendaFormaPagamento) {
428 
                List<CartaoDTO> contas = new ArrayList<CartaoDTO>();
429 
                for (VendaFormaPagamento vendaFormaPagamento : listaVendaFormaPagamento) {
430 
                        Conta contaAReceber = new Conta();
431 
                        contaAReceber.setLoja(vendaFormaPagamento.getVenda().getLoja());
432 
                        contaAReceber.setIndicadorAtivo(true);
433 
                        contaAReceber.setTipoFrequencia(TipoFrequencia.UNICA.getValor());
434 
                        contaAReceber.setTipoConta(TipoConta.CONTA_A_RECEBER.getValor());
435 
                        contaAReceber.setObservacao("VENDA: " + vendaFormaPagamento.getSequencialDaVenda());
436 
                        contaAReceber.setVenda(vendaFormaPagamento.getVenda());
437 
 
438 
                        ContaFormaPagamento contaFormaPagamento = new ContaFormaPagamento(vendaFormaPagamento);
439 
                        contaFormaPagamentoService.cadastrar(contaFormaPagamento);
440 
                        contaAReceber.setFormaDePagamento(contaFormaPagamento);
441 
 
442 
                        contaService.cadastrar(contaAReceber);
443 
 
444 
                        List<Parcela> parcelas = new ArrayList<Parcela>();
445 
                        this.gerarParcelas(vendaFormaPagamento, contaAReceber);
446 
                        parcelas = this.consultarParcelasAVencer(contaAReceber);
447 
 
448 
                        for (Parcela parcela : parcelas) {
449 
                                CartaoDTO cartao = new CartaoDTO();
450 
                                cartao.setParcela(parcela);
451 
                                cartao.setBandeira(vendaFormaPagamento.getDescricaoDaBandeiraCartao());
452 
                                cartao.setFormaDePagamento(vendaFormaPagamento.getFormaPagamento());
453 
                                cartao.setDataVenda(vendaFormaPagamento.getVenda().getDataVenda());
454 
                                cartao.setBruto(vendaFormaPagamento.getValorPagamento());
455 
                                contas.add(cartao);
456 
                        }
457 
                }
458 
                return contas;
459 
        }
460 
 
461 
        @Override
462 
        public List<CartaoDTO> consultarContasDosCartoes(Date dataInicial, Date dataFinal) {
463 
                List<CartaoDTO> contas = new ArrayList<CartaoDTO>();
464 
                List<Conta> contasAReceber = consultarContasAReceber(dataInicial, dataFinal);
465 
                if (VerificadorUtil.naoEstaNuloOuVazio(contasAReceber)) {
466 
                        for (Conta contaAReceber : contasAReceber) {
467 
                                List<Parcela> parcelas = this.consultarParcelasAVencer(contaAReceber);
468 
                                for (Parcela parcela : parcelas) {
469 
                                        CartaoDTO cartao = new CartaoDTO();
470 
                                        cartao.setParcela(parcela);
471 
                                        if (VerificadorUtil.naoEstaNulo(contaAReceber.getFormaDePagamento())) {
472 
                                                cartao.setBandeira(contaAReceber.getFormaDePagamento().getBandeiraCartao().getDescricao());
473 
                                                cartao.setFormaDePagamento(contaAReceber.getFormaDePagamento().getFormaPagamento());
474 
                                                cartao.setBruto(contaAReceber.getFormaDePagamento().getValorPagamento());
475 
                                        }
476 
                                        cartao.setDataVenda(contaAReceber.getVenda().getDataVenda());
477 
                                        contas.add(cartao);
478 
                                }
479 
                        }
480 
                }
481 
                return contas;
482 
        }
483 
 
484 
        private List<Conta> consultarContasAReceber(Date dataInicial, Date dataFinal) {
485 
                return contaService.consultarContasAReceberPorPeriodo(dataInicial, dataFinal);
486 
        }
487 
 
488 
        @Override
489 
        public void cadastrarContaComParcelasNaCompra(Compra compra, List<Parcela> listaParcelas) {
490 
                if (VerificadorUtil.naoEstaNuloOuVazio(listaParcelas)) {
491 
                        Conta contaAPagar = new Conta(TipoConta.CONTA_A_PAGAR.getValor());
492 
                        Categoria categoriaProduto = new Categoria();
493 
                        categoriaProduto.setSequencial(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_PRODUTO_7);
494 
                        contaAPagar.setCategoria(categoriaService.consultarPorId(categoriaProduto));
495 
                        contaAPagar.setPessoa(compra.getFornecedor().getPessoa());
496 
                        contaAPagar.setIndicadorAtivo(true);
497 
                        contaAPagar.setTipoFrequencia(TipoFrequencia.UNICA.getValor());
498 
                        contaService.cadastrar(contaAPagar);
499 
 
500 
                        for (Parcela parcela : listaParcelas) {
501 
                                parcela.setObservacao(compra.getFornecedor().getNomeAbreviadoDaPessoa() + " " + parcela.getObservacao());
502 
                                parcela.setConta(contaAPagar);
503 
                                this.cadastrar(parcela);
504 
                        }
505 
                        compra.setConta(contaAPagar);
506 
                }
507 
        }
508 
 
509 
        public static void main(String[] args) {
510 
                String numero = "GBMAX NF 032393 001/003";
511 
                System.out.println(removeZeros(numero));
512 
        }
513 
 
514 
        public static String removeZeros(String linha) { return linha.replaceFirst("0*", ""); }
515 
        */
516 
        /*
517 
        @Override
518 
        public void parcelamento(Parcela parcela, Integer quantidadeParcelas) {
519 
                Double valorTotal = parcela.getValor();
520 
                Double valorDaParcela = valorTotal/quantidadeParcelas;
521 
                Date dataVencimento = new Date(parcela.getDataVencimento().getTime());
522 
                for (int i = 1; i <= quantidadeParcelas; i++) {
523 
                        Parcela parcelado = new Parcela(null, parcela.getContaAPagar(), parcela.getContaBancaria(), DataUtils.getDataAtual(), dataVencimento, null, valorDaParcela, i + "ª PARCELA DA CONTA: " + parcela.getContaAPagar().getSequencial(), true);
524 
                        parcelaRepository.cadastrar(parcelado);
525 
                        dataVencimento = new Date(DataUtils.acrescentarDiasResultadoDiaUtil(dataVencimento, 30).getTime());
526 
                }
527 
        }
528 
 
529 
        private void cadastrarParcelas(VendaFormaPagamento vendaFormaPagamento, ContaBancaria contaBancaria, Date dataVencimento, Double valorPagamento, ContaAReceber contaAReceber, String observacao) {
530 
                Parcela parcela = new Parcela(contaAReceber, null, contaBancaria, vendaFormaPagamento.getVenda().getDataVenda(), dataVencimento, null, valorPagamento, observacao + " DA VENDA: " + vendaFormaPagamento.getVenda().getSequencial(), true);
531 
                parcelaRepository.cadastrar(parcela);
532 
        }
533 
 
534 
        @Override
535 
        public List<Parcela> consultarParcelasPorPeriodo(Parcela parcela, Boolean pagamentoRealizado, Boolean ehContaAReceber, Date dataInicial, Date dataFinal, String ordenacao, int first, int pageSize) {
536 
                return parcelaRepository.consultarParcelasPorPeriodo(parcela, pagamentoRealizado, ehContaAReceber, dataInicial, dataFinal, ordenacao, first, pageSize);
537 
        }
538 
 
539 
        @Override
540 
        public Integer obterQuantidadeRegistrosConsultarParcelasPorPeriodo(Parcela parcela, Boolean pagamentoRealizado, Boolean ehContaAReceber, Date dataInicial, Date dataFinal) {
541 
                return parcelaRepository.obterQuantidadeRegistrosConsultarParcelasPorPeriodo(parcela, pagamentoRealizado, ehContaAReceber, dataInicial, dataFinal);
542 
        }
543 
*/
544 
}