Subversion Repositories Integrator Subversion

Rev

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