Subversion Repositories Integrator Subversion

Rev

Rev 596 | Rev 688 | Go to most recent revision | 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.List;
5
 
6
import javax.inject.Inject;
7
import javax.inject.Named;
8
 
9
import org.springframework.context.annotation.Scope;
10
 
11
import br.com.ec.controller.managedbean.datamodel.ParcelaDataModel;
195 espaco 12
import br.com.ec.core.consulta.ParametrosConsulta;
13
import br.com.ec.core.exception.NegocioException;
14
import br.com.ec.core.generic.GenericService;
15
import br.com.ec.core.util.VerificadorUtil;
106 espaco 16
import br.com.ec.domain.dto.ParametrosVendaDTO;
17
import br.com.ec.domain.model.BandeiraCartao;
18
import br.com.ec.domain.model.Cliente;
19
import br.com.ec.domain.model.Conta;
20
import br.com.ec.domain.model.Cupom;
305 espaco 21
import br.com.ec.domain.model.Estampa;
106 espaco 22
import br.com.ec.domain.model.FormaPagamento;
23
import br.com.ec.domain.model.Lancamento;
24
import br.com.ec.domain.model.Loja;
25
import br.com.ec.domain.model.Modelo;
26
import br.com.ec.domain.model.NotaFiscal;
27
import br.com.ec.domain.model.Pedido;
28
import br.com.ec.domain.model.PedidoProduto;
29
import br.com.ec.domain.model.Produto;
30
import br.com.ec.domain.model.Venda;
31
import br.com.ec.domain.model.VendaFormaPagamento;
32
import br.com.ec.domain.model.Vendedor;
33
import br.com.ec.domain.model.tipos.TipoCupom;
34
import br.com.ec.domain.model.tipos.TipoFrete;
305 espaco 35
import br.com.ec.domain.model.tipos.TipoPersonalizacao;
106 espaco 36
import br.com.ec.domain.model.tipos.TipoSituacaoPedido;
37
import br.com.ec.domain.service.bandeiracartao.BandeiraCartaoService;
686 blopes 38
import br.com.ec.domain.service.cashback.CashbackService;
106 espaco 39
import br.com.ec.domain.service.cliente.ClienteService;
40
import br.com.ec.domain.service.conta.ContaService;
41
import br.com.ec.domain.service.cupom.CupomService;
42
import br.com.ec.domain.service.email.impl.GerenciadorEmailImpl;
305 espaco 43
import br.com.ec.domain.service.estampa.EstampaService;
106 espaco 44
import br.com.ec.domain.service.formapagamento.FormaPagamentoService;
45
import br.com.ec.domain.service.lancamento.LancamentoService;
46
import br.com.ec.domain.service.loja.LojaService;
47
import br.com.ec.domain.service.modelo.ModeloService;
48
import br.com.ec.domain.service.notafiscal.NotaFiscalService;
49
import br.com.ec.domain.service.parcela.ParcelaService;
50
import br.com.ec.domain.service.pedido.PedidoService;
51
import br.com.ec.domain.service.produto.ProdutoService;
52
import br.com.ec.domain.service.produtodaloja.ProdutoLojaService;
53
import br.com.ec.domain.service.seguranca.ContextoSeguranca;
54
import br.com.ec.domain.service.venda.VendaService;
55
import br.com.ec.domain.service.vendaformapagamento.VendaFormaPagamentoService;
56
import br.com.ec.domain.service.vendedor.VendedorService;
57
import br.com.ec.domain.shared.ConstantesSEC;
195 espaco 58
import br.com.ec.web.exception.VerificadorLancamentoException;
59
import br.com.ec.web.exception.VerificadorLancamentoException.CommandBean;
60
import br.com.ec.web.generic.AbstractBean;
61
import br.com.ec.web.message.LancadorMensagem;
106 espaco 62
import net.sf.jasperreports.engine.JasperExportManager;
63
import net.sf.jasperreports.engine.JasperPrint;
64
 
65
@Named
66
@Scope("view")
67
public class VendaBean extends AbstractBean<Venda> implements Serializable {
68
 
69
        private static final long serialVersionUID = 1L;
70
 
71
        private LojaService lojaService;
72
        private VendaService vendaService;
73
        private ProdutoService produtoService;
74
        private ProdutoLojaService produtoLojaService;
75
        private VendedorService vendedorService;
76
        private FormaPagamentoService formaPagamentoService;
77
        private VendaFormaPagamentoService vendaFormaPagamentoService;
78
        private BandeiraCartaoService bandeiraCartaoService;
79
        private ParcelaService parcelaService;
80
        private ContaService contaAReceberService;
81
        private ClienteService clienteService;
82
        private ModeloService modeloService;
83
        private NotaFiscalService notaFiscalService;
84
        private CupomService cupomService;
85
        private LancamentoService lancamentoService;
86
        private PedidoService pedidoService;
305 espaco 87
        private EstampaService estampaService;
686 blopes 88
        private CashbackService cashbackService;
106 espaco 89
        private ContextoSeguranca contextoSeguranca;
90
 
91
        private String codigoProduto;
92
        private String codigoPedido;
93
        private Lancamento lancamento;
94
        private String localizacaoNova;
95
        private String cpfCnpjCliente;
96
        private ParametrosVendaDTO parametrosVenda;
97
        private Venda vendaSelecionada;
98
        private String observacaoExclusao;
99
        private Cupom cupomSelecionado;
100
        private Lancamento lancamentoSelecionado;
101
 
102
        private FormaPagamento formaPagamento;
103
        private BandeiraCartao bandeiraCartao;
104
        private Double valorPagamento;
105
 
106
        private List<FormaPagamento> formasDePagamentoDeCredito;
107
        private List<BandeiraCartao> bandeirasDeDebito;
108
        private List<BandeiraCartao> bandeirasDeCredito;
109
 
110
        private ParcelaDataModel parcelas;
111
        private Boolean emitirCupom = false;
112
        private String emailParaEnvio;
113
 
114
        private List<Vendedor> vendedoresColaboradores;
115
        private List<Vendedor> vendedoresColaboradoresAtivos;
116
        private List<Vendedor> vendedoresExternos;
117
 
305 espaco 118
        private List<Estampa> estampas;
119
 
106 espaco 120
        @Inject
121
        public VendaBean(LojaService lojaService, VendaService vendaService, ProdutoService produtoService, ProdutoLojaService produtoLojaService,
122
                        VendedorService vendedorService, FormaPagamentoService formaPagamentoService, VendaFormaPagamentoService vendaFormaPagamentoService,
123
                        BandeiraCartaoService bandeiraCartaoService, ParcelaService parcelaService,
124
                        ContaService contaAReceberService, ClienteService clienteService, ModeloService modeloService,
125
                        NotaFiscalService notaFiscalService, CupomService cupomService, LancamentoService lancamentoService, PedidoService pedidoService,
686 blopes 126
                        EstampaService estampaService, CashbackService cashbackService, ContextoSeguranca contextoSeguranca) {
106 espaco 127
                this.lojaService = lojaService;
128
                this.vendaService = vendaService;
129
                this.produtoService = produtoService;
130
                this.produtoLojaService = produtoLojaService;
131
                this.vendedorService = vendedorService;
132
                this.formaPagamentoService = formaPagamentoService;
133
                this.vendaFormaPagamentoService = vendaFormaPagamentoService;
134
                this.bandeiraCartaoService = bandeiraCartaoService;
135
                this.parcelaService = parcelaService;
136
                this.contaAReceberService = contaAReceberService;
137
                this.clienteService = clienteService;
138
                this.modeloService = modeloService;
139
                this.notaFiscalService = notaFiscalService;
140
                this.cupomService = cupomService;
141
                this.lancamentoService = lancamentoService;
142
                this.pedidoService = pedidoService;
305 espaco 143
                this.estampaService = estampaService;
686 blopes 144
                this.cashbackService = cashbackService;
106 espaco 145
                this.contextoSeguranca = contextoSeguranca;
146
        }
147
 
148
        @Override
149
        public void preCarregamento() {
150
                limparEntidade();
151
        }
152
 
153
        private void setarParametrosDaLoja() {
154
                parametrosVenda = new ParametrosVendaDTO();
155
                if (VerificadorUtil.naoEstaNulo(getParametro("sequencialLoja"))) {
156
                        Loja loja = new Loja();
157
                        loja.setSequencial(new Long(getParametro("sequencialLoja").toString()));
158
                        parametrosVenda.setLoja(lojaService.consultarPorId(loja));
159
                        parametrosVenda.setMaquineta(parametrosVenda.getLoja().getMaquineta());
160
                }
161
                parametrosVenda.setUsuario(contextoSeguranca.obterUsuario());
162
        }
163
 
164
        @Override
165
        public void preDetalhar(Venda venda) {
166
                setEntidade(vendaService.detalharVendaCompleta(venda));
167
        }
168
 
169
        @Override
170
        public void limparEntidade() {
171
                entidade = new Venda();
172
                parametrosConsulta = new ParametrosConsulta<Venda>();
173
                parametrosConsulta.setEntidade(entidade);
174
 
175
                setLancamento(new Lancamento());
176
                setarParametrosDaLoja();
177
                setParcelas(new ParcelaDataModel());
178
        }
179
 
180
        @Override
181
        public GenericService<Venda> getService() {
182
                return vendaService;
183
        }
184
 
185
        @Override
186
        public Venda getEntidade() {
187
                return entidade;
188
        }
189
 
190
        @Override
191
        public Venda getId() {
192
                return getEntidade();
193
        }
194
 
195
        public String getCodigoProduto() {
196
                return codigoProduto;
197
        }
198
        public void setCodigoProduto(String codigoProduto) {
199
                this.codigoProduto = codigoProduto;
200
        }
201
 
202
        public String getCodigoPedido() {
203
                return codigoPedido;
204
        }
205
        public void setCodigoPedido(String codigoPedido) {
206
                this.codigoPedido = codigoPedido;
207
        }
208
 
209
        public Lancamento getLancamento() {
210
                return lancamento;
211
        }
212
        public void setLancamento(Lancamento lancamento) {
213
                this.lancamento = lancamento;
214
        }
215
 
216
        public String getLocalizacaoNova() {
217
                return localizacaoNova;
218
        }
219
        public void setLocalizacaoNova(String localizacaoNova) {
220
                this.localizacaoNova = localizacaoNova;
221
        }
222
 
223
        public String getCpfCnpjCliente() {
224
                return VerificadorUtil.naoEstaNulo(cpfCnpjCliente)? cpfCnpjCliente.replace(".", "").replace("-", "") : cpfCnpjCliente;
225
        }
226
        public void setCpfCnpjCliente(String cpfCnpjCliente) {
227
                this.cpfCnpjCliente = cpfCnpjCliente;
228
        }
229
 
230
        public ParametrosVendaDTO getParametrosVenda() {
231
                return parametrosVenda;
232
        }
233
        public void setParametrosVenda(ParametrosVendaDTO parametrosVenda) {
234
                this.parametrosVenda = parametrosVenda;
235
        }
236
 
237
        public Venda getVendaSelecionada() {
238
                return vendaSelecionada;
239
        }
240
        public void setVendaSelecionada(Venda vendaSelecionada) {
241
                this.vendaSelecionada = vendaSelecionada;
242
        }
243
 
244
        public String getObservacaoExclusao() {
245
                return observacaoExclusao;
246
        }
247
        public void setObservacaoExclusao(String observacaoExclusao) {
248
                this.observacaoExclusao = observacaoExclusao;
249
        }
250
 
251
        public Cupom getCupomSelecionado() {
252
                return cupomSelecionado;
253
        }
254
        public void setCupomSelecionado(Cupom cupomSelecionado) {
255
                this.cupomSelecionado = cupomSelecionado;
256
        }
257
 
258
        public Lancamento getLancamentoSelecionado() {
259
                return lancamentoSelecionado;
260
        }
261
        public void setLancamentoSelecionado(Lancamento lancamentoSelecionado) {
262
                this.lancamentoSelecionado = lancamentoSelecionado;
263
        }
264
 
265
        public FormaPagamento getFormaPagamento() {
266
                return formaPagamento;
267
        }
268
        public void setFormaPagamento(FormaPagamento formaPagamento) {
269
                this.formaPagamento = formaPagamento;
270
        }
271
 
272
        public BandeiraCartao getBandeiraCartao() {
273
                return bandeiraCartao;
274
        }
275
        public void setBandeiraCartao(BandeiraCartao bandeiraCartao) {
276
                this.bandeiraCartao = bandeiraCartao;
277
        }
278
 
279
        public Double getValorPagamento() {
280
                return valorPagamento;
281
        }
282
        public void setValorPagamento(Double valorPagamento) {
283
                this.valorPagamento = valorPagamento;
284
        }
285
 
286
        public List<FormaPagamento> getFormasDePagamentoDeCredito() {
287
                if (VerificadorUtil.estaNulo(formasDePagamentoDeCredito)) {
288
                        setFormasDePagamentoDeCredito(formaPagamentoService.consultarFormasDePagamentoDeCredito());
289
                }
290
                return formasDePagamentoDeCredito;
291
        }
292
        public void setFormasDePagamentoDeCredito(List<FormaPagamento> formasDePagamentoDeCredito) {
293
                this.formasDePagamentoDeCredito = formasDePagamentoDeCredito;
294
        }
295
 
296
        public List<BandeiraCartao> getBandeirasDeDebito() {
297
                if (VerificadorUtil.estaNulo(bandeirasDeDebito)) {
298
                        setBandeirasDeDebito(bandeiraCartaoService.consultarBandeiraCartoesDeDebito());
299
                }
300
                return bandeirasDeDebito;
301
        }
302
        public void setBandeirasDeDebito(List<BandeiraCartao> bandeirasDeDebito) {
303
                this.bandeirasDeDebito = bandeirasDeDebito;
304
        }
305
 
306
        public List<BandeiraCartao> getBandeirasDeCredito() {
307
                if (VerificadorUtil.estaNulo(bandeirasDeCredito)) {
308
                        setBandeirasDeCredito(bandeiraCartaoService.consultarBandeiraCartoesDeCredito());
309
                }
310
                return bandeirasDeCredito;
311
        }
312
        public void setBandeirasDeCredito(List<BandeiraCartao> bandeirasDeCredito) {
313
                this.bandeirasDeCredito = bandeirasDeCredito;
314
        }
315
 
316
        public List<Venda> getConsultarTodas() {
317
                return vendaService.consultarTodos(new Venda());
318
        }
319
 
320
        public ParcelaDataModel getParcelas() {
321
                atualizarParcelas(getParametrosVenda().getVenda());
322
                return parcelas;
323
    }
324
    public void setParcelas(ParcelaDataModel parcelas) {
325
        this.parcelas = parcelas;
326
    }
327
    public void atualizarParcelas(Venda venda) {
328
        if (VerificadorUtil.naoEstaNulo(venda)) {
329
                        setParcelas(new ParcelaDataModel(parcelaService.consultarParcelasDaVenda(getParametrosVenda().getVenda().getSequencial())));
330
                }
331
    }
332
 
333
    public Boolean getEmitirCupom() {
334
                return emitirCupom;
335
        }
336
        public void setEmitirCupom(Boolean emitirCupom) {
337
                this.emitirCupom = emitirCupom;
338
        }
339
 
340
        public String getEmailParaEnvio() {
341
                return emailParaEnvio;
342
        }
343
        public void setEmailParaEnvio(String emailParaEnvio) {
344
                this.emailParaEnvio = emailParaEnvio;
345
        }
346
 
347
        public List<Vendedor> getVendedoresColaboradores() {
348
                if (VerificadorUtil.estaNulo(vendedoresColaboradores)) {
349
                        setVendedoresColaboradores(vendedorService.consultarVendedoresColaboradores());
350
                }
351
                return vendedoresColaboradores;
352
        }
353
        public void setVendedoresColaboradores(List<Vendedor> vendedoresColaboradores) {
354
                this.vendedoresColaboradores = vendedoresColaboradores;
355
        }
356
 
357
        public List<Vendedor> getVendedoresColaboradoresAtivos() {
358
                if (VerificadorUtil.estaNulo(vendedoresColaboradoresAtivos)) {
359
                        setVendedoresColaboradoresAtivos(vendedorService.consultarVendedoresColaboradoresAtivos(null));
360
                }
361
                return vendedoresColaboradoresAtivos;
362
        }
363
        public void setVendedoresColaboradoresAtivos(List<Vendedor> vendedoresColaboradoresAtivos) {
364
                this.vendedoresColaboradoresAtivos = vendedoresColaboradoresAtivos;
365
        }
366
 
367
        public List<Vendedor> getVendedoresExternos() {
368
                if (VerificadorUtil.estaNulo(vendedoresExternos)) {
369
                        setVendedoresExternos(vendedorService.consultarVendedoresExternosAtivos());
370
                }
371
                return vendedoresExternos;
372
        }
373
        public void setVendedoresExternos(List<Vendedor> vendedoresExternos) {
374
                this.vendedoresExternos = vendedoresExternos;
375
        }
376
 
305 espaco 377
        public List<Estampa> getEstampas() {
378
                if (VerificadorUtil.estaNulo(estampas)) {
379
                        setEstampas(estampaService.consultarEstampas(null));
380
                }
381
                return estampas;
382
        }
383
        public void setEstampas(List<Estampa> estampas) {
384
                this.estampas = estampas;
385
        }
386
 
106 espaco 387
        public TipoFrete[] getTiposFrete() {
388
                return TipoFrete.values();
389
        }
305 espaco 390
 
391
        public TipoPersonalizacao[] getTiposPersonalizacao() {
392
                return TipoPersonalizacao.values();
393
        }
106 espaco 394
 
395
        /***************************************************************/
396
 
397
    public void selecionarCodigoProduto(String codigoProduto) {
398
        setCodigoProduto(codigoProduto);
399
    }
400
 
401
        public void prepararParaAlterarVenda(final Venda venda) {
402
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
403
                        public void execute() {
404
                                parametrosVenda = new ParametrosVendaDTO(venda);
405
                        }
406
                });
407
        }
408
 
409
        public void prepararParaAlterarVendaFinanceiro(final Venda venda) {
410
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
411
                        public void execute() {
412
                                parametrosVenda = new ParametrosVendaDTO(venda);
413
                                setParcelas(new ParcelaDataModel(parcelaService.consultarParcelasDaVenda(venda.getSequencial())));
414
                        }
415
                });
416
        }
417
 
418
        public void prepararParaExcluirVenda(final Venda venda) {
419
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
420
                        public void execute() {
421
                                setVendaSelecionada(venda);
422
                                List<NotaFiscal> notasFiscais = notaFiscalService.consultarNotasFiscais(venda);
423
                                if (!notasFiscais.isEmpty()) {
424
                                        String observacao = "";
425
                                        for (NotaFiscal notaFiscal : notasFiscais) {
426
                                                observacao = notaFiscal.getNumeroNotaFiscal() + "; ";
427
                                        }
428
                                        setObservacaoExclusao("OBS.: NOTAS FISCAIS VINCULADAS: " + observacao);
429
                                } else {
430
                                        setObservacaoExclusao("");
431
                                }
432
                        }
433
                });
434
        }
435
 
436
        public void consultarProduto() {
437
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
438
                        public void execute() {
439
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
440
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
441
                                        getLancamento().preencher(produtoSelecionado);
442
                                }
443
                                getLancamento().setVenda(getEntidade());
444
                                getLancamento().setAtivo(true);
445
                        }
446
                });
447
        }
448
 
449
        public void consultarProdutoPrecoPopular() {
450
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
451
                        public void execute() {
452
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
453
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
454
                                        getLancamento().preencherComPrecoPopular(produtoSelecionado);
455
                                }
456
                                getLancamento().setVenda(getEntidade());
457
                                getLancamento().setAtivo(true);
458
                        }
459
                });
460
        }
461
 
462
        public void consultarProdutoPrecoAtacado() {
463
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
464
                        public void execute() {
465
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
466
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
467
                                        getLancamento().preencherComPrecoAtacado(produtoSelecionado);
468
                                }
469
                                getLancamento().setVenda(getEntidade());
470
                                getLancamento().setAtivo(true);
471
                        }
472
                });
473
        }
474
 
475
        public void consultarProdutoFarma() {
476
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
477
                        public void execute() {
478
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoRapidoOuCodigoEAN(getCodigoProduto());
479
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
480
                                        getLancamento().preencher(produtoSelecionado);
481
                                }
482
                                getLancamento().setVenda(getEntidade());
483
                                getLancamento().setAtivo(true);
484
                        }
485
                });
486
        }
487
 
488
        public void adicionarLancamento() {
489
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
490
                        public void execute() {
491
                                if (VerificadorUtil.estaNulo(getLancamento().getValorVenda())) {
492
                                        getLancamento().setValorVenda(new Double(0.0));
493
                                }
494
                                for (int i = 1; i <= getLancamento().getQuantidadeLancamento(); i++) {
495
                                        try {
496
                                                getLancamento().setObservacaoNotaFiscal(getLancamento().getObservacaoIMEI1() + " " + getLancamento().getObservacaoIMEI2());
497
                                                getLancamento().getObservacaoNotaFiscal().trim();
498
                                                getParametrosVenda().getLancamentos().add((Lancamento)getLancamento().clone());
499
                                        } catch (CloneNotSupportedException e) {
500
                                                e.printStackTrace();
501
                                        }
502
                                }
503
//                              atualizarValorVendaSeForLojaFarmaciaEProdutoSemValorVenda(getLancamento());
504
                                limparLancamento();
505
                                LancadorMensagem.lancarSucesso("PRODUTO ADICIONADO COM SUCESSO");
506
                        }
507
                });
508
        }
509
 
510
        public void adicionarLancamentoRestaurante() {
511
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
512
                        public void execute() {
513
                                if (VerificadorUtil.estaNulo(getLancamento().getValorVenda())) {
514
                                        getLancamento().setValorVenda(new Double(0.0));
515
                                }
516
                                for (int i = 1; i <= getLancamento().getQuantidadeLancamento(); i++) {
517
                                        try {
518
                                                String opcoes = "";
519
                                                for (String opcao : getLancamento().getOpcoesRestaurante()) {
520
                                                        opcoes = opcoes + opcao + " - ";
521
                                                }
522
                                                String observacoes = "";
523
                                                if (VerificadorUtil.naoEstaNuloOuVazio(opcoes)) {
524
                                                        observacoes = observacoes + opcoes;
525
                                                }
526
                                                if (VerificadorUtil.naoEstaNuloOuVazio(getLancamento().getOpcaoRestaurante())) {
527
                                                        observacoes = observacoes + getLancamento().getOpcaoRestaurante();
528
                                                }
529
                                                if (VerificadorUtil.naoEstaNuloOuVazio(getLancamento().getObservacaoRestaurante())) {
530
                                                        observacoes = observacoes + " (" + getLancamento().getObservacaoRestaurante() + ")";
531
                                                }
532
                                                getLancamento().setObservacao(observacoes);
533
                                                getParametrosVenda().getLancamentos().add((Lancamento)getLancamento().clone());
534
                                        } catch (CloneNotSupportedException e) {
535
                                                e.printStackTrace();
536
                                        }
537
                                }
538
                                limparLancamento();
539
                                LancadorMensagem.lancarSucesso("PRODUTO ADICIONADO COM SUCESSO");
540
                        }
541
                });
542
        }
543
 
544
        /*
545
         * MÉTODO DA FARMÁCIA
546
         *//*
547
        protected void atualizarValorVendaSeForLojaFarmaciaEProdutoSemValorVenda(Lancamento lancamento) {
548
                if (getParametrosVenda().getLoja().getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)) {
549
                        if (lancamento.getProduto().tipoProdutoEhRemedioOuOutros()) {
550
                                Produto produto = produtoService.consultarProdutoPorCodigo(lancamento.getProduto().getCodigo());
551
                                if (VerificadorUtil.estaNuloOuVazio(produto.getValorVarejo())) {
552
                                        produto.setValorVarejo(lancamento.getValorVenda());
553
                                        produtoService.alterar(produto);
554
                                }
555
                        }
556
                }
557
        }*/
558
 
559
        public void removerLancamento(final Lancamento lancamento) {
560
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
561
                        public void execute() {
562
                                getParametrosVenda().getLancamentos().remove(lancamento);
563
                                LancadorMensagem.lancarSucesso("PRODUTO REMOVIDO COM SUCESSO");
564
                        }
565
                });
566
        }
567
 
568
        public void limparLancamento() {
569
                setLancamento(new Lancamento());
570
                setCodigoProduto("");
571
        }
572
 
573
        public void limparPagamento() {
574
                setBandeiraCartao(null);
575
                setValorPagamento(null);
576
        }
577
 
578
        public void prepararPagamento() {
579
                limparPagamento();
580
                Double subtotal = getParametrosVenda().valorTotalLancamentos() /*+ getParametrosVenda().getValorFrete() */ - getParametrosVenda().valorTotalPago();
581
                if (subtotal > 0) {
582
                        setValorPagamento(subtotal);
583
                }
584
        }
585
 
586
        public void prepararPagamentoComCupom() {
587
                prepararPagamento();
588
                setCupomSelecionado(new Cupom());
589
        }
590
 
591
        public void adicionarPagamentoEmDinheiro() {
592
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
593
                        public void execute() {
594
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_DINHEIRO));
595
                        }
596
                });
597
        }
598
 
599
        public void adicionarPagamentoEmPix() {
600
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
601
                        public void execute() {
602
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_PIX));
603
                        }
604
                });
605
        }
606
 
344 espaco 607
        public void adicionarPagamentoEmTransferencia() {
608
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
609
                        public void execute() {
610
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_TRANSFERENCIA));
611
                        }
612
                });
613
        }
614
 
106 espaco 615
        public void adicionarPagamentoComOutros() {
616
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
617
                        public void execute() {
618
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_OUTROS));
619
                        }
620
                });
621
        }
622
 
623
        private void adicionarPagamento(FormaPagamento formaPagamento) {
624
                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamentoService.consultarPorId(formaPagamento));
625
                vendaFormaPagamento.setValorPagamento(getValorPagamento());
626
                adicionarPagamento(vendaFormaPagamento);
627
        }
628
 
629
        public void adicionarPagamentoEmDebito() {
630
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
631
                        public void execute() {
632
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_DEBITO));
633
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento, getBandeiraCartao());
634
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
635
                                verificarPagamentoNoCartao(formaPagamento);
636
                                adicionarPagamento(vendaFormaPagamento);
637
                        }
638
                });
639
        }
640
 
641
        public void adicionarPagamentoEmCredito() {
642
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
643
                        public void execute() {
644
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), getFormaPagamento(), getBandeiraCartao());
645
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
646
                                verificarPagamentoNoCartao(getFormaPagamento());
647
                                adicionarPagamento(vendaFormaPagamento);
648
                        }
649
                });
650
        }
651
 
652
        public void adicionarPagamentoComCupom() {
653
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
654
                        public void execute() {
655
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CUPOM));
656
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento);
657
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
658
                                vendaFormaPagamento.setCupom(getCupomSelecionado());
659
                                adicionarPagamento(vendaFormaPagamento);
660
                        }
661
                });
662
        }
663
 
686 blopes 664
        public void adicionarPagamentoComCashback() {
665
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
666
                        public void execute() {
667
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CASHBACK_28));
668
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento);
669
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
670
                                retirarCashbackCliente(getEntidade().getCliente(), getValorPagamento());
671
                                adicionarPagamento(vendaFormaPagamento);
672
                        }
673
 
674
                        private void retirarCashbackCliente(Cliente cliente, Double valor) {
675
//                              cashbackService.utilizarCashback(cliente, valor);
676
                        }
677
                });
678
        }
679
 
106 espaco 680
        public void adicionarPagamento(final VendaFormaPagamento vendaFormaPagamento) {
681
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
682
                        public void execute() {
683
                                verificarPagamento(vendaFormaPagamento);
280 espaco 684
//                              seParcelaAcima12xAlterarMaquineta(getFormaPagamento());
106 espaco 685
                                getParametrosVenda().getLancamentosPagamentos().add(vendaFormaPagamento);
686
                                setFormaPagamento(null);
687
                                setValorPagamento(null);
688
                                setCupomSelecionado(null);
689
                                LancadorMensagem.lancarSucesso("PAGAMENTO ADICIONADO COM SUCESSO");
690
                        }
691
 
692
                        private void verificarPagamento(VendaFormaPagamento vendaFormaPagamento) {
693
                                if (VerificadorUtil.estaNulo(getValorPagamento())) {
694
                                        throw new NegocioException("VALOR DE PAGAMENTO INCORRETO");
695
                                }
696
                                if (getValorPagamento().equals(new Double(0))) {
697
                                        throw new NegocioException("VALOR DE PAGAMENTO INCORRETO");
698
                                }
699
                                /*
700
                                for (VendaFormaPagamento pagamento : getParametrosVenda().getLancamentosPagamentos()) {
701
                                        if (pagamento.getCodigoDaFormaPagamento().equals(vendaFormaPagamento.getCodigoDaFormaPagamento())) {
702
                                                throw new NegocioException("FORMA DE PAGAMENTO JÁ EXISTE");
703
                                        }
704
                                }
705
                                */
706
                        }
277 espaco 707
 
708
                        private void seParcelaAcima12xAlterarMaquineta(FormaPagamento formaPagamento) {
709
                                if (formaPagamento.formaPagamentoEhCreditoAcima12x()) {
710
                                        getParametrosVenda().setMaquineta(null);
711
                                }
712
                        }
106 espaco 713
                });
714
        }
715
 
716
        protected void verificarPagamentoNoCartao(FormaPagamento formaPagamento) {
717
                if (VerificadorUtil.estaNulo(getBandeiraCartao())) {
718
                        throw new RuntimeException("É OBRIGATÓRIO INFORMAR A BANDEIRA");
719
                }
720
                if (VerificadorUtil.estaNulo(formaPagamento)) {
721
                        throw new RuntimeException("É OBRIGATÓRIO INFORMAR A BANDEIRA");
722
                }
723
        }
724
 
725
        public void removerPagamento(final VendaFormaPagamento pagamento) {
726
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
727
                        public void execute() {
728
                                getParametrosVenda().getLancamentosPagamentos().remove(pagamento);
729
                                LancadorMensagem.lancarSucesso("PRODUTO REMOVIDO COM SUCESSO");
730
                        }
731
                });
732
        }
733
 
734
        public void selecionarCliente(final Cliente cliente) {
735
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
736
                        public void execute() {
737
                                cliente.setAtivo(true);
738
                                clienteService.alterar(cliente);
739
                                getParametrosVenda().setCliente(clienteService.consultarClientePorCpfCnpj(cliente.getCpfCnpj()));
740
                                setCpfCnpjCliente(null);
741
                                adicionandoParametroArgsConfirmandoAcao(true);
742
                        }
743
                });
744
        }
745
 
746
        public void retirarCliente() {
747
                getParametrosVenda().setCliente(null);
748
        }
749
 
750
        public List<Vendedor> consultarVendedoresColaboradores() {
751
                return vendedorService.consultarVendedoresColaboradores();
752
        }
753
 
754
        public List<Vendedor> consultarVendedoresColaboradoresAtivos() {
755
                return vendedorService.consultarVendedoresColaboradoresAtivos(null);
756
        }
757
 
758
        public List<Vendedor> consultarVendedoresExternos() {
759
                return vendedorService.consultarVendedoresExternosAtivos();
760
        }
761
 
762
        public void iniciarNovaVenda() {
763
                Loja lojaSelecionada = getParametrosVenda().getLoja();
764
                setParametrosVenda(new ParametrosVendaDTO());
765
                getParametrosVenda().setLoja(lojaSelecionada);
766
                getParametrosVenda().setMaquineta(lojaSelecionada.getMaquineta());
767
                getParametrosVenda().setUsuario(contextoSeguranca.obterUsuario());
768
        }
769
 
770
        public void iniciarVenda() {
771
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
772
                        public void execute() {
773
                                LancadorMensagem.lancarSucessoRedirecionandoTela("VENDA REALIZADA COM SUCESSO!", "/sistema/pdv.xhtml?sequencialLoja=" + getParametrosVenda().getLoja().getSequencial());
774
                        }
775
                });
776
        }
777
 
778
        public void cadastrarVendaSemCupom() {
779
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
780
                        public void execute() {
305 espaco 781
                                Venda vendaCadastrada = vendaService.cadastrarVendaPeloPDV(getParametrosVenda());
782
                                Long sequencialNovoPedido = pedidoService.cadastrarPedidoVendaPersonalizada(vendaCadastrada, getParametrosVenda());
783
                                if (VerificadorUtil.naoEstaNulo(sequencialNovoPedido)) {
784
                                        LancadorMensagem.lancarSucesso("Nº PERSONALIZAÇÃO: " + sequencialNovoPedido);
785
                                }
106 espaco 786
                                iniciarNovaVenda();
311 espaco 787
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
106 espaco 788
                        }
789
                });
790
        }
791
 
792
        public void cadastrarVendaComCupom() {
793
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
794
                        public void execute() {
795
                                setVendaSelecionada(vendaService.cadastrarVendaPeloPDV(getParametrosVenda()));
305 espaco 796
                                Long sequencialNovoPedido = pedidoService.cadastrarPedidoVendaPersonalizada(getVendaSelecionada(), getParametrosVenda());
797
                                if (VerificadorUtil.naoEstaNulo(sequencialNovoPedido)) {
798
                                        LancadorMensagem.lancarSucesso("Nº PERSONALIZAÇÃO: " + sequencialNovoPedido);
799
                                }
106 espaco 800
                                preCarregamento();
801
                                getParametrosVenda().setLoja(getVendaSelecionada().getLoja());
280 espaco 802
                                getParametrosVenda().setMaquineta(getVendaSelecionada().getLoja().getMaquineta());
106 espaco 803
                                setEmitirCupom(true);
311 espaco 804
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
106 espaco 805
                        }
806
                });
807
        }
808
 
809
        public void cadastrarVendaFarma() {
810
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
811
                        public void execute() {
812
                                vendaService.cadastrarVendaPeloPDV(getParametrosVenda());
813
                                LancadorMensagem.lancarSucessoRedirecionandoTela("VENDA REALIZADA COM SUCESSO!", "/sistema/pdv.xhtml?sequencialLoja=" + getParametrosVenda().getLoja().getSequencial());
814
                        }
815
                });
816
        }
817
 
818
        public void cadastrarVendaRestaurante() {
819
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
820
                        public void execute() {
821
                                setVendaSelecionada(vendaService.cadastrarVendaPeloPDV(getParametrosVenda()));
822
                                preCarregamento();
823
                                getParametrosVenda().setLoja(getVendaSelecionada().getLoja());
280 espaco 824
                                getParametrosVenda().setMaquineta(getVendaSelecionada().getLoja().getMaquineta());
106 espaco 825
                                getVendaSelecionada().setEmitirComanda(true);
826
                                setEmitirCupom(true);
827
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
828
                        }
829
                });
830
        }
831
 
832
        public void alterarVenda(final Boolean verificarJustificativa) {
833
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
834
                        public void execute() {
835
                                if (verificarJustificativa) {
836
                                        if (VerificadorUtil.estaNuloOuVazio(getParametrosVenda().getVenda().getJustificativaParaExcluir())) {
837
                                                throw new NegocioException("JUSTIFICATIVA OBRIGATÓRIA");
838
                                        }
839
                                }
840
                                vendaService.alterarVenda(getParametrosVenda(), contextoSeguranca.obterUsuario(), verificarJustificativa);
841
                                adicionandoParametroArgsConfirmandoAcao(true);
842
                                LancadorMensagem.lancarSucesso("VENDA ALTERADA COM SUCESSO");
843
                        }
844
                });
845
        }
846
 
847
        public void excluirVendaSelecionada() {
848
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
849
                        public void execute() {
850
                                if (VerificadorUtil.estaNuloOuVazio(getVendaSelecionada().getJustificativaParaExcluir())) {
851
                                        throw new RuntimeException("É OBRIGATÓRIO JUSTIFICAR");
852
                                }
853
                                vendaService.excluirVenda(getVendaSelecionada(), contextoSeguranca.obterUsuario());
854
                                adicionandoParametroArgsConfirmandoAcao(true);
855
                                LancadorMensagem.lancarSucesso("VENDA EXCLUÍDA COM SUCESSO");
856
                        }
857
                });
858
        }
859
 
860
        public void excluirVenda(final Venda venda) {
861
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
862
                        public void execute() {
863
                                vendaService.excluirVenda(venda, contextoSeguranca.obterUsuario());
864
                                adicionandoParametroArgsConfirmandoAcao(true);
865
                                LancadorMensagem.lancarSucesso("VENDA EXCLUÍDA COM SUCESSO");
866
                        }
867
                });
868
        }
869
 
870
        public String verificarFinanceiro(Venda venda) {
871
                Conta contaAReceber = new Conta();
872
                contaAReceber.setVenda(venda);
873
                contaAReceber.setIndicadorAtivo(true);
874
                if (contaAReceberService.obterQuantidadeDeRegistrosPassandoEntidade(contaAReceber) == 0) {
875
                        return "NENHUMA";
876
                }
877
        return parcelaService.verificarPossuiParcelaAberta(venda) ? "PENDENTE" : "QUITADO";
878
        }
879
 
880
        public void prepararEnvioCupomEmail() {
881
                setEmailParaEnvio(getVendaSelecionada().getEmailDoCliente());
882
        }
883
 
884
        public void enviarCupomPorEmail() {
885
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
886
                        public void execute() {
887
                                lancarExcecaoCasoEmailNaoInformado();
888
                                try {
889
                                        JasperPrint relatorio = notaFiscalService.retornarRelatorio(getVendaSelecionada());
890
                                        byte[] arquivo = JasperExportManager.exportReportToPdf(relatorio);
891
                                        new GerenciadorEmailImpl()
892
                                                .comEmailsDestino(getEmailParaEnvio())
893
                                                .comAssunto("CUPOM EMITIDO POR ESPAÇO CASE")
894
                                                .comConteudoHtml("OBRIGADO PELA PREFERÊNCIA!")
895
                                                .adicionarAnexo("CUPOM.pdf", arquivo, "pdf")
896
                                                .enviar();
897
                                        LancadorMensagem.lancarSucesso("Cupom enviado por email.");
898
                                } catch (Exception e) {
899
                                        e.printStackTrace();
900
                                }
901
                        }
902
 
903
                        private void lancarExcecaoCasoEmailNaoInformado() {
904
                                if (VerificadorUtil.estaNuloOuVazio(getEmailParaEnvio())) {
905
                                        throw new NegocioException("Obrigatório informar o email de destino");
906
                                }
907
                        }
908
                });
909
        }
910
 
911
        /*************************************************/
912
 
913
        public void informarEtico() {
914
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
915
                        public void execute() {
916
                                alterarCategoria(new Long(343), "ÉTICO");
917
                        }
918
                });
919
        }
920
 
921
        public void informarGenerico() {
922
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
923
                        public void execute() {
924
                                alterarCategoria(new Long(340), "GENÉRICO");
925
                        }
926
                });
927
        }
928
 
929
        public void informarSimilar() {
930
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
931
                        public void execute() {
932
                                alterarCategoria(new Long(338), "SIMILAR");
933
                        }
934
                });
935
        }
936
 
937
        public void informarOutros() {
938
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
939
                        public void execute() {
940
                                alterarCategoria(new Long(339), "OUTROS");
941
                        }
942
                });
943
        }
944
 
945
        public void alterarCategoria(final Long sequencialModelo, final String modelo) {
946
                Modelo modeloNovo = new Modelo();
947
                modeloNovo.setSequencial(sequencialModelo);
948
                modeloService.consultarPorId(modeloNovo);
949
                getLancamento().getProduto().setModelo(modeloNovo);
950
                produtoService.alterar(getLancamento().getProduto());
951
                setCodigoProduto("");
952
                LancadorMensagem.lancarSucesso("CATEGORIA ALTERADA PARA " + modelo);
953
        }
954
 
955
        public void informarLocalizacao() {
956
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
957
                        public void execute() {
958
                                produtoLojaService.alterarLocalizacao(getLocalizacaoNova(), getLancamento().getProduto(), getParametrosVenda().getLoja());
959
                                LancadorMensagem.lancarSucesso("LOCALIZAÇÃO ALTERADA PARA " + getLocalizacaoNova());
960
                                setCodigoProduto("");
961
                                setLocalizacaoNova("");
962
                        }
963
                });
964
        }
965
 
966
        public void prepararAdicionarCupom(Lancamento lancamento) {
967
                setLancamentoSelecionado(lancamento);
968
                setCupomSelecionado(new Cupom());
969
        }
970
 
971
        public void consultarCupom(final String tipoCupom) {
972
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
973
                        public void execute() {
974
                                setCupomSelecionado(cupomService.consultarCupomPorCodigo(getCupomSelecionado().getCodigo()));
975
                                verificarCupomValido();
976
                                verificarInclusaoDoCupom(getCupomSelecionado(), tipoCupom);
977
                                getCupomSelecionado().setLancamento(getLancamentoSelecionado());
978
 
979
                                if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getValor())) {
980
                                        setValorPagamento(getCupomSelecionado().getValor());
981
                                } else if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getPercentual())) {
982
                                        setValorPagamento(getCupomSelecionado().getLancamento().getValorVenda() * getCupomSelecionado().getPercentual() / 100);
983
                                }
984
                        }
985
 
986
                        private void verificarCupomValido() {
987
                                if (VerificadorUtil.estaNulo(getCupomSelecionado())) {
988
                                        setCupomSelecionado(new Cupom());
989
                                        throw new NegocioException("CUPOM NÃO LOCALIZADO");
990
                                } else {
991
                                        if (!getCupomSelecionado().valido() || !getCupomSelecionado().getAtivo()) {
992
                                                setCupomSelecionado(new Cupom());
993
                                                throw new NegocioException("CUPOM INVÁLIDO");
994
                                        }
995
                                        if (getCupomSelecionado().getLimiteUtilizacao()) {
996
                                                Integer vendasComCupom = lancamentoService.obterQuantidadeVendasComCupom(getCupomSelecionado());
997
                                                vendasComCupom += vendaFormaPagamentoService.obterQuantidadePagamentosComCupom(getCupomSelecionado());
998
                                                if (vendasComCupom > 0) {
999
                                                        setCupomSelecionado(new Cupom());
1000
                                                        throw new NegocioException("CUPOM JÁ UTILIZADO ANTERIORMENTE");
1001
                                                }
1002
                                        }
1003
                                }
1004
                        }
1005
 
1006
                        private void verificarInclusaoDoCupom(Cupom cupom, String tipoCupom) {
1007
                                if (TipoCupom.PROMOCIONAL.getValor().equals(tipoCupom)) {
1008
                                        if (!cupom.getTipoCupom().equals(TipoCupom.PROMOCIONAL.getValor())) {
1009
                                                setCupomSelecionado(new Cupom());
1010
                                                throw new NegocioException("PERMITIDO APENAS PARA CUPONS PROMOCIONAIS");
1011
                                        }
1012
                                        if (getLancamentoSelecionado().getProduto().getProdutoEmPromocao()) {
1013
                                                setCupomSelecionado(new Cupom());
1014
                                                throw new NegocioException("AÇÃO NÃO PERMITIDA: PRODUTO JÁ EM PROMOÇÃO");
1015
                                        }
1016
                                } else if (TipoCupom.REEMBOLSO.getValor().equals(tipoCupom)) {
1017
                                        if (!cupom.getTipoCupom().equals(TipoCupom.REEMBOLSO.getValor())) {
1018
                                                setCupomSelecionado(new Cupom());
1019
                                                throw new NegocioException("PERMITIDO APENAS PARA CUPONS DE REEMBOLSO");
1020
                                        }
1021
                                }
1022
                        }
1023
                });
1024
        }
1025
 
1026
        public void adicionarCupom() {
1027
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
1028
                        public void execute() {
1029
                                verificarSeValorMaiorDesconto(getValorPagamento());
1030
                                verificarSeCupomJaFoiAdicionado(getCupomSelecionado(), getParametrosVenda().getLancamentos());
1031
                                for (Lancamento lancamento : getParametrosVenda().getLancamentos()) {
1032
                                        if (lancamento.equals(getCupomSelecionado().getLancamento())) {
1033
                                                lancamento.setCupom(getCupomSelecionado());
1034
                                                lancamento.setValorVarejo(lancamento.getValorVarejo() - getValorPagamento());
1035
                                                lancamento.setValorVenda(lancamento.getValorVenda() - getValorPagamento());
1036
                                                break;
1037
                                        }
1038
                                }
1039
                                LancadorMensagem.lancarSucesso("CUPOM ADICIONADO COM SUCESSO");
1040
                        }
1041
 
1042
                        private void verificarSeCupomJaFoiAdicionado(Cupom cupomSelecionado, List<Lancamento> lancamentos) {
1043
                                if (cupomSelecionado.getLimiteUtilizacao()) {
1044
                                        for (Lancamento lancamento : getParametrosVenda().getLancamentos()) {
1045
                                                if (VerificadorUtil.naoEstaNulo(lancamento.getCupom())) {
1046
                                                        if (lancamento.getCupom().equals(cupomSelecionado)) {
1047
                                                                throw new RuntimeException("CUPOM JÁ FOI UTILIZADO");
1048
                                                        }
1049
                                                }
1050
                                        }
1051
                                }
1052
                        }
1053
 
1054
                        private void verificarSeValorMaiorDesconto(Double valorPagamento) {
1055
                                if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getValor())) {
1056
                                        if (valorPagamento > getCupomSelecionado().getValor()) {
1057
                                                throw new RuntimeException("VALOR DO DESCONTO ACIMA DO PERMITIDO");
1058
                                        }
1059
                                } else if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getPercentual())) {
1060
                                        if (valorPagamento > getCupomSelecionado().getLancamento().getValorVenda() * getCupomSelecionado().getPercentual() / 100) {
1061
                                                throw new RuntimeException("VALOR DO DESCONTO ACIMA DO PERMITIDO");
1062
                                        }
1063
                                }
1064
                        }
1065
                });
1066
        }
1067
 
1068
        public void removerCupom(Lancamento lancamento) {
1069
                for (Lancamento lancamentoVendas : getParametrosVenda().getLancamentos()) {
1070
                        if (lancamentoVendas.equals(lancamento)) {
1071
                                lancamentoVendas.setCupom(null);
1072
                                lancamentoVendas.setValorVarejo(lancamento.getValorVarejo() + getValorPagamento());
1073
                                lancamentoVendas.setValorVenda(lancamento.getValorVenda() + getValorPagamento());
1074
                                break;
1075
                        }
1076
                }
1077
                LancadorMensagem.lancarSucesso("CUPOM REMOVIDO COM SUCESSO");
1078
        }
1079
 
1080
        public void vincularPedido() {
1081
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
1082
                        public void execute() {
1083
                                Pedido pedido = new Pedido();
1084
                                pedido.setSequencial(new Long(getCodigoPedido()));
1085
                                getParametrosVenda().setPedidoVinculado(pedidoService.consultarPedidoCompleto(pedido));
1086
                                if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getPedidoVinculado())) {
330 espaco 1087
                                        verificarSePedidoEhValido(getParametrosVenda().getPedidoVinculado());
106 espaco 1088
                                        getParametrosVenda().setObservacao("PEDIDO VINCULADO: " + getParametrosVenda().getPedidoVinculado().getSequencial() + ". " + getParametrosVenda().getObservacao());
1089
                                        Vendedor vendedorPedido = vendedorService.consultarVendedorPorPessoa(getParametrosVenda().getPedidoVinculado().getUsuarioPedido().getPessoa());
1090
                                        if (VerificadorUtil.naoEstaNulo(vendedorPedido)) {
1091
                                                getParametrosVenda().setVendedor(vendedorPedido);
1092
                                        }
1093
 
1094
                                        for (PedidoProduto pedidoProduto : getParametrosVenda().getPedidoVinculado().getProdutos()) {
1095
                                                Integer quantidadeProduto = 1;
1096
                                                while (quantidadeProduto <= pedidoProduto.getQuantidade()) {
1097
                                                        Lancamento lancamento = new Lancamento();
1098
                                                        lancamento.preencher(pedidoProduto.getProduto());
1099
                                                        lancamento.setValorVenda(pedidoProduto.getValor());
1100
                                                        lancamento.setObservacao(pedidoProduto.getObservacao());
1101
                                                        getParametrosVenda().getLancamentos().add(lancamento);
1102
                                                        quantidadeProduto++;
1103
                                                }
1104
                                        }
1105
 
1106
                                        if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getPedidoVinculado().getCliente())) {
1107
                                                getParametrosVenda().setCliente(getParametrosVenda().getPedidoVinculado().getCliente());
1108
                                        }
1109
                                        setCodigoPedido("");
1110
                                        LancadorMensagem.lancarSucesso("PEDIDO " + getParametrosVenda().getPedidoVinculado().getSequencial() + " VINCULADO");
1111
                                } else {
1112
                                        LancadorMensagem.lancarErro("PEDIDO NÃO ENCONTRADO");
1113
                                }
1114
                        }
330 espaco 1115
 
1116
                        private void verificarSePedidoEhValido(Pedido pedidoVinculado) {
1117
                                if (getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.FINALIZADO.getValor()) ||
1118
                                                getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor())) {
1119
                                        throw new NegocioException("VÍNCULO NÃO REALIZADO: PEDIDO JÁ FINALIZADO");
1120
                                }
1121
                                if (getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.INVALIDO.getValor())) {
1122
                                        throw new NegocioException("VÍNCULO NÃO REALIZADO: PEDIDO INVÁLIDO");
1123
                                }
1124
                        }
106 espaco 1125
                });
1126
        }
1127
 
1128
}