Subversion Repositories Integrator Subversion

Rev

Rev 195 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
106 espaco 1
package br.com.ec.controller.managedbean;
2
 
3
import java.io.Serializable;
4
import java.util.ArrayList;
5
import java.util.List;
6
 
7
import javax.inject.Inject;
8
import javax.inject.Named;
9
 
10
import org.primefaces.event.SelectEvent;
11
import org.springframework.context.annotation.Scope;
12
 
13
import br.com.ec.controller.managedbean.datamodel.ParcelaDataModel;
195 espaco 14
import br.com.ec.core.generic.GenericService;
15
import br.com.ec.core.util.DataUtils;
16
import br.com.ec.core.util.StringUtil;
17
import br.com.ec.core.util.VerificadorUtil;
106 espaco 18
import br.com.ec.domain.dto.ContaGerenciadorDTO;
19
import br.com.ec.domain.model.Categoria;
20
import br.com.ec.domain.model.Compra;
21
import br.com.ec.domain.model.Conta;
304 espaco 22
import br.com.ec.domain.model.FormaPagamento;
106 espaco 23
import br.com.ec.domain.model.Parcela;
24
import br.com.ec.domain.model.Pessoa;
25
import br.com.ec.domain.model.Venda;
26
import br.com.ec.domain.model.tipos.TipoConta;
27
import br.com.ec.domain.service.categoria.CategoriaService;
28
import br.com.ec.domain.service.compra.CompraService;
29
import br.com.ec.domain.service.conta.ContaService;
304 espaco 30
import br.com.ec.domain.service.formapagamento.FormaPagamentoService;
106 espaco 31
import br.com.ec.domain.service.parcela.ParcelaService;
32
import br.com.ec.domain.shared.ConstantesSEC;
195 espaco 33
import br.com.ec.web.exception.VerificadorLancamentoException;
34
import br.com.ec.web.exception.VerificadorLancamentoException.CommandBean;
35
import br.com.ec.web.generic.AbstractBean;
36
import br.com.ec.web.message.LancadorMensagem;
106 espaco 37
 
38
@Named
39
@Scope("view")
40
public class ContaGerenciadorBean extends AbstractBean<ContaGerenciadorDTO> implements Serializable {
41
 
42
        private static final long serialVersionUID = 1L;
43
 
44
        private ParcelaService parcelaService;
45
        private ContaService contaService;
46
        private CompraService compraService;
47
        private CategoriaService categoriaService;
304 espaco 48
        private FormaPagamentoService formaPagamentoService;
106 espaco 49
 
50
        private String chavePagamento;
51
        private ParcelaDataModel parcelas;
52
        private Long vincularConta;
304 espaco 53
        private List<FormaPagamento> formasDePagamento;
106 espaco 54
 
55
        @Inject
304 espaco 56
        public ContaGerenciadorBean(ParcelaService parcelaService, ContaService contaService, CompraService compraService, CategoriaService categoriaService,
57
                        FormaPagamentoService formaPagamentoService) {
106 espaco 58
                this.parcelaService = parcelaService;
59
                this.contaService = contaService;
60
                this.compraService = compraService;
61
                this.categoriaService = categoriaService;
304 espaco 62
                this.formaPagamentoService = formaPagamentoService;
106 espaco 63
        }
64
 
65
        @Override
66
        public void preCarregamento() {
67
                setEntidade(new ContaGerenciadorDTO());
68
        }
69
 
70
        @Override
71
        public void limparEntidade() {
72
                setEntidade(new ContaGerenciadorDTO());
73
                setParcelas(null);
74
        }
75
 
76
        @Override
77
        public GenericService<ContaGerenciadorDTO> getService() {
78
                return null;
79
        }
80
 
81
        @Override
82
        public ContaGerenciadorDTO getEntidade() {
83
                return entidade;
84
        }
85
 
86
        @Override
87
        public ContaGerenciadorDTO getId() {
88
                return getEntidade();
89
        }
90
 
91
        public String getChavePagamento() {
92
                return chavePagamento;
93
        }
94
        public void setChavePagamento(String chavePagamento) {
95
                this.chavePagamento = chavePagamento;
96
        }
97
        public void formatarChavePagamento() {
98
                if (VerificadorUtil.naoEstaNulo(getChavePagamento())) {
99
                        setChavePagamento(StringUtil.retornarApenasNumeros(getChavePagamento()));
100
                }
101
        }
102
 
103
        public ParcelaDataModel getParcelas() {
104
                preencherParcelas();
105
        return parcelas;
106
    }
107
    public void setParcelas(ParcelaDataModel parcelas) {
108
        this.parcelas = parcelas;
109
    }
110
    public void preencherParcelas() {
111
        Parcela parcela = new Parcela();
112
        List<Parcela> listaParcelas = new ArrayList<Parcela>();
113
        parcela.setConta(getEntidade().getConta());
114
        if (VerificadorUtil.naoEstaNulo(getEntidade().getSequencialDaConta())) {
115
                        listaParcelas = parcelaService.consultarPassandoEntidade(parcela, 0, parcelaService.obterQuantidadeDeRegistrosPassandoEntidade(parcela));
116
                }
117
        setParcelas(new ParcelaDataModel(listaParcelas));
118
    }
119
    public Double getValorTotalParcelas() {
120
        Double valorTotal = new Double(0);
121
        if (VerificadorUtil.naoEstaNulo(parcelas)) {
122
                for (Parcela parcela : parcelas) {
123
                        valorTotal = valorTotal + parcela.getValor();
124
                }
125
        }
126
        return valorTotal;
127
    }
128
 
129
    public Long getVincularConta() {
130
                return vincularConta;
131
        }
132
        public void setVincularConta(Long vincularConta) {
133
                this.vincularConta = vincularConta;
134
        }
304 espaco 135
 
136
        public List<FormaPagamento> getFormasDePagamento() {
137
                if (VerificadorUtil.estaNulo(formasDePagamento)) {
138
                        setFormasDePagamento(formaPagamentoService.listarFormasPagamentoAtivas());
139
                }
140
                return formasDePagamento;
141
        }
142
        public void setFormasDePagamento(List<FormaPagamento> formasDePagamento) {
143
                this.formasDePagamento = formasDePagamento;
144
        }
106 espaco 145
 
146
        public void onRowSelect(SelectEvent event) {
147
                preencherConta(((Parcela) event.getObject()));
148
    }
149
 
150
        public void preencherConta(Parcela parcelaSelecionada) {
151
                limparEntidade();
152
        if (VerificadorUtil.naoEstaNulo(parcelaSelecionada.getConta())) {
153
                Conta conta = new Conta();
154
                conta.setSequencial(parcelaSelecionada.getConta().getSequencial());
155
                getEntidade().setConta(contaService.consultarPorId(conta));
156
        }
157
        preencherParcelas();
158
        }
159
 
160
        public void inicializarParcelaAReceber() {
161
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
162
                        public void execute() {
163
                                Parcela parcela = new Parcela();
164
                                parcela.setIndicadorAtivo(true);
165
                                parcela.setConta(getEntidade().getConta());
166
                                if (VerificadorUtil.naoEstaNulo(getEntidade().getConta().getVenda())) {
167
                                        parcela.setDataEmissao(getEntidade().getConta().getVenda().getDataVenda());
168
                                        parcela.setObservacao("PARCELA DA VENDA: " + getEntidade().getConta().getVenda().getSequencial());
169
                                } else {
170
                                        parcela.setDataEmissao(DataUtils.getDataAtual());
171
                                }
172
                                getEntidade().setParcela(parcela);
173
                        }
174
                });
175
        }
176
 
177
        public void inicializarParcelaAPagar() {
178
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
179
                        public void execute() {
180
                                Parcela parcela = new Parcela();
181
                                parcela.setIndicadorAtivo(true);
182
                                if (VerificadorUtil.naoEstaNulo(getEntidade().getConta())) {
183
                                        parcela.setDataEmissao(DataUtils.getDataAtual());
184
                                        parcela.setConta(getEntidade().getConta());
185
                                        parcela.setObservacao("PARCELA: " + getEntidade().getConta().getSequencial());
186
                                }
187
                                getEntidade().setParcela(parcela);
188
                        }
189
                });
190
        }
191
 
192
        public void cadastrarParcela() {
193
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
194
                        public void execute() {
195
                                parcelaService.cadastrar(getEntidade().getParcela());
196
                                LancadorMensagem.lancarSucesso("PARCELA CADASTRADA COM SUCESSO!");
197
                        }
198
                });
199
                preencherParcelas();
200
        }
201
 
202
    public void receberParcela() {
203
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
204
                        public void execute() {
205
                                if (VerificadorUtil.estaNulo(getEntidade().getParcela().getDataPagamento())) {
206
                                        getEntidade().getParcela().setDataPagamento(getEntidade().getParcela().getDataVencimento());
207
                                }
208
                                parcelaService.alterar(getEntidade().getParcela());
209
                                cadastrarNovaParcelaPelaFrequencia(getEntidade().getParcela());
210
                                LancadorMensagem.lancarSucesso("PARCELA RECEBIDA COM SUCESSO!");
211
                        }
212
                });
213
    }
214
 
215
        public void pagarParcela() {
216
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
217
                        public void execute() {
218
                                if (VerificadorUtil.estaNulo(getEntidade().getParcela().getDataPagamento())) {
219
                                        getEntidade().getParcela().setDataPagamento(DataUtils.getDataAtual());
220
                                }
221
                                parcelaService.alterar(getEntidade().getParcela());
222
                                cadastrarNovaParcelaPelaFrequencia(getEntidade().getParcela());
223
                                LancadorMensagem.lancarSucesso("PARCELA PAGA COM SUCESSO!");
224
                        }
225
                });
226
    }
227
 
228
        public void alterarParcela() {
229
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
230
                        public void execute() {
231
                                parcelaService.alterar(getEntidade().getParcela());
232
                                getEntidade().setParcela(null);
233
                                preencherParcelas();
234
                                LancadorMensagem.lancarSucesso("PARCELA ALTERADA COM SUCESSO!");
235
                        }
236
                });
237
        }
238
 
239
        public void excluirParcela() {
240
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
241
                        public void execute() {
242
                                parcelaService.excluir(getEntidade().getParcela());
243
                                preencherParcelas();
244
                                excluirContaSemParcela(getEntidade().getParcela());
245
                                LancadorMensagem.lancarSucesso("PARCELA EXCLUÍDA COM SUCESSO");
246
                        }
247
                        private void excluirContaSemParcela(Parcela parcela) {
248
                                if (parcelaService.obterQuantidadeDeRegistrosPassandoEntidade(parcela) == 0) {
249
                                        if (VerificadorUtil.naoEstaNulo(parcela.getConta())) {
250
                                                Compra compraDaConta = compraService.consultarCompraDaConta(parcela.getConta());
251
                                                if (VerificadorUtil.naoEstaNulo(compraDaConta)) {
252
                                                        compraDaConta.setConta(null);
253
                                                        compraService.alterar(compraDaConta);
254
                                                }
255
                                                contaService.excluir(parcela.getConta());
256
                                                prepararParaCadastrarConta(parcela.getConta());
257
                                        }
258
                                }
259
                        }
260
                });
261
    }
262
 
263
        public void cancelarParcela() {
264
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
265
                        public void execute() {
266
                                parcelaService.cancelarParcela(getEntidade().getParcela());
267
                                LancadorMensagem.lancarSucesso("PARCELA CANCELADA COM SUCESSO!");
268
                        }
269
                });
270
    }
271
 
272
        private void cadastrarNovaParcelaPelaFrequencia(Parcela parcela) {
273
                ContaGerenciadorDTO contaGerenciador = parcelaService.cadastrarNovaParcelaPelaFrequencia(parcela);
274
                if (VerificadorUtil.naoEstaNulo(contaGerenciador)) {
275
                        setEntidade(contaGerenciador);
276
                        LancadorMensagem.lancarSucesso("NOVA PARCELA GERADA COM SUCESSO!");
277
                }
278
        }
279
 
280
        public void alterarConta() {
281
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
282
                        public void execute() {
283
                                contaService.alterar(getEntidade().getConta());
284
                                if (VerificadorUtil.naoEstaNulo(getEntidade().getConta().getCompra())) {
285
                                        getEntidade().getConta().getCompra().setConta(getEntidade().getConta());
286
                                        compraService.alterar(getEntidade().getConta().getCompra());
287
                                }
288
                                LancadorMensagem.lancarSucesso("CONTA ALTERADA COM SUCESSO!");
289
                        }
290
                });
291
        }
292
 
293
        public void prepararParaCadastrarContaAReceber(Venda venda) {
294
                Conta contaAReceber = new Conta(TipoConta.CONTA_A_RECEBER.getValor());
295
                contaAReceber.setVenda(venda);
296
                prepararParaCadastrarConta(contaAReceber);
297
        }
298
 
299
        public void prepararParaCadastrarContaAPagar() {
300
                prepararParaCadastrarConta(new Conta(TipoConta.CONTA_A_PAGAR.getValor()));
301
        }
302
 
303
        public void gerarContaAPagarDaCompra(Compra compra) {
304
                prepararParaCadastrarConta(new Conta(TipoConta.CONTA_A_PAGAR.getValor()));
305
                Categoria categoriaProduto = new Categoria();
306
                categoriaProduto.setSequencial(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_PRODUTO_7);
307
                getEntidade().getConta().setCategoria(categoriaService.consultarPorId(categoriaProduto));
308
                getEntidade().getConta().setPessoa(compra.getFornecedor().getPessoa());
309
                getEntidade().getConta().setCompra(compra);
310
        }
311
 
312
        private void prepararParaCadastrarConta(Conta conta) {
313
                limparEntidade();
314
                preencherParcelas();
315
                Conta contaParaCadastro = new Conta(conta.getTipoConta());
316
                if (VerificadorUtil.naoEstaNulo(conta.ehContaAReceber()) && VerificadorUtil.naoEstaNulo(conta.getSequencialDaVenda())) {
317
                        contaParaCadastro.setVenda(conta.getVenda());
318
                        contaParaCadastro.setObservacao("VENDA: " + contaParaCadastro.getSequencialDaVenda());
319
                }
320
                contaParaCadastro.setIndicadorAtivo(true);
321
                getEntidade().setConta(contaParaCadastro);
322
        }
323
 
324
        public void consultarConta(Compra compra) {
325
                Conta conta = contaService.consultarPorId(compra.getConta());
326
                getEntidade().setConta(conta);
327
        }
328
 
329
        public void selecionarCategoria(Categoria categoria) {
330
                getEntidade().getConta().setCategoria(categoria);
331
        }
332
 
333
        public void retirarCategoria() {
334
                getEntidade().getConta().setCategoria(null);
335
        }
336
 
337
        public void selecionarPessoa(Pessoa pessoa) {
338
                getEntidade().getConta().setPessoa(pessoa);
339
        }
340
 
341
        public void retirarPessoa() {
342
                getEntidade().getConta().setPessoa(null);
343
        }
344
 
345
        public void gerarParcelasDaVenda() {
346
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
347
                        public void execute() {
348
                                getEntidade().setConta(parcelaService.gerarParcelasDaVenda(getEntidade().getConta().getVenda(), getEntidade().getConta()));
349
                                preencherParcelas();
350
                                LancadorMensagem.lancarSucesso("PARCELAS GERADAS COM SUCESSO!");
351
                        }
352
                });
353
    }
354
 
355
    public void gerarParcelasDinheiroDaVenda() {
356
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
357
                        public void execute() {
358
                                getEntidade().setConta(parcelaService.gerarParcelasDinheiroDaVenda(getEntidade().getConta().getVenda(), getEntidade().getConta()));
359
                                preencherParcelas();
360
                                LancadorMensagem.lancarSucesso("PARCELAS GERADAS COM SUCESSO!");
361
                        }
362
                });
363
    }
364
 
365
    public void gerarParcelasCartaoDaVenda() {
366
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
367
                        public void execute() {
368
                                getEntidade().setConta(parcelaService.gerarParcelasCartaoDaVenda(getEntidade().getConta().getVenda(), getEntidade().getConta()));
369
                                preencherParcelas();
370
                                LancadorMensagem.lancarSucesso("PARCELAS GERADAS COM SUCESSO!");
371
                        }
372
                });
373
    }
374
 
375
    public void vincularConta(final Compra compra) {
376
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
377
                        public void execute() {
378
                                Conta conta = new Conta();
379
                                conta.setSequencial(getVincularConta());
380
                                conta = contaService.consultarPorId(conta);
381
                                compraService.vincularConta(compra, conta);
382
                                LancadorMensagem.lancarSucesso("CONTA [" + getVincularConta() + "] VINCULADA COM SUCESSO!");
383
                                setVincularConta(null);
384
                        }
385
                });
386
    }
387
 
388
    public void desvincularConta(final Compra compra) {
389
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
390
                        public void execute() {
391
                                compraService.desvincularConta(compra);
392
                                LancadorMensagem.lancarSucesso("CONTA [" + compra.getConta().getSequencial() + "] DESVINCULADA COM SUCESSO!");
393
                                setVincularConta(null);
394
                        }
395
                });
396
    }
397
 
398
}