Subversion Repositories Integrator Subversion

Rev

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