Subversion Repositories Integrator Subversion

Rev

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

Rev Author Line No. Line
1 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;
12
import br.com.ec.domain.dto.ParametrosVendaDTO;
13
import br.com.ec.domain.model.BandeiraCartao;
14
import br.com.ec.domain.model.Cliente;
15
import br.com.ec.domain.model.Conta;
16
import br.com.ec.domain.model.Cupom;
17
import br.com.ec.domain.model.FormaPagamento;
18
import br.com.ec.domain.model.Lancamento;
19
import br.com.ec.domain.model.Loja;
20
import br.com.ec.domain.model.Modelo;
21
import br.com.ec.domain.model.NotaFiscal;
22
import br.com.ec.domain.model.Pedido;
23
import br.com.ec.domain.model.PedidoProduto;
24
import br.com.ec.domain.model.Produto;
25
import br.com.ec.domain.model.Venda;
26
import br.com.ec.domain.model.VendaFormaPagamento;
27
import br.com.ec.domain.model.Vendedor;
28
import br.com.ec.domain.model.tipos.TipoCupom;
29
import br.com.ec.domain.model.tipos.TipoFrete;
30
import br.com.ec.domain.model.tipos.TipoSituacaoPedido;
31
import br.com.ec.domain.service.bandeiracartao.BandeiraCartaoService;
32
import br.com.ec.domain.service.cliente.ClienteService;
33
import br.com.ec.domain.service.conta.ContaService;
34
import br.com.ec.domain.service.cupom.CupomService;
35
import br.com.ec.domain.service.email.impl.GerenciadorEmailImpl;
36
import br.com.ec.domain.service.formapagamento.FormaPagamentoService;
37
import br.com.ec.domain.service.lancamento.LancamentoService;
38
import br.com.ec.domain.service.loja.LojaService;
39
import br.com.ec.domain.service.modelo.ModeloService;
40
import br.com.ec.domain.service.notafiscal.NotaFiscalService;
41
import br.com.ec.domain.service.parcela.ParcelaService;
42
import br.com.ec.domain.service.pedido.PedidoService;
43
import br.com.ec.domain.service.produto.ProdutoService;
44
import br.com.ec.domain.service.produtodaloja.ProdutoLojaService;
45
import br.com.ec.domain.service.seguranca.ContextoSeguranca;
46
import br.com.ec.domain.service.venda.VendaService;
47
import br.com.ec.domain.service.vendaformapagamento.VendaFormaPagamentoService;
48
import br.com.ec.domain.service.vendedor.VendedorService;
49
import br.com.ec.domain.shared.ConstantesSEC;
50
import br.edu.cesmac.core.consulta.ParametrosConsulta;
51
import br.edu.cesmac.core.exception.NegocioException;
52
import br.edu.cesmac.core.generic.GenericService;
53
import br.edu.cesmac.core.util.VerificadorUtil;
54
import br.edu.cesmac.web.exception.VerificadorLancamentoException;
55
import br.edu.cesmac.web.exception.VerificadorLancamentoException.CommandBean;
56
import br.edu.cesmac.web.generic.AbstractBean;
57
import br.edu.cesmac.web.message.LancadorMensagem;
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 consultarProdutoFarma() {
426
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
427
                        public void execute() {
428
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoRapidoOuCodigoEAN(getCodigoProduto());
429
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
430
                                        getLancamento().preencher(produtoSelecionado);
431
                                }
432
                                getLancamento().setVenda(getEntidade());
433
                                getLancamento().setAtivo(true);
434
                        }
435
                });
436
        }
437
 
438
        public void adicionarLancamento() {
439
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
440
                        public void execute() {
441
                                if (VerificadorUtil.estaNulo(getLancamento().getValorVenda())) {
442
                                        getLancamento().setValorVenda(new Double(0.0));
443
                                }
444
                                for (int i = 1; i <= getLancamento().getQuantidadeLancamento(); i++) {
445
                                        try {
446
                                                getLancamento().setObservacaoNotaFiscal(getLancamento().getObservacaoIMEI1() + " " + getLancamento().getObservacaoIMEI2());
447
                                                getLancamento().getObservacaoNotaFiscal().trim();
448
                                                getParametrosVenda().getLancamentos().add((Lancamento)getLancamento().clone());
449
                                        } catch (CloneNotSupportedException e) {
450
                                                e.printStackTrace();
451
                                        }
452
                                }
453
//                              atualizarValorVendaSeForLojaFarmaciaEProdutoSemValorVenda(getLancamento());
454
                                limparLancamento();
455
                                LancadorMensagem.lancarSucesso("PRODUTO ADICIONADO COM SUCESSO");
456
                        }
457
                });
458
        }
459
 
460
        public void adicionarLancamentoRestaurante() {
461
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
462
                        public void execute() {
463
                                if (VerificadorUtil.estaNulo(getLancamento().getValorVenda())) {
464
                                        getLancamento().setValorVenda(new Double(0.0));
465
                                }
466
                                for (int i = 1; i <= getLancamento().getQuantidadeLancamento(); i++) {
467
                                        try {
468
                                                String opcoes = "";
469
                                                for (String opcao : getLancamento().getOpcoesRestaurante()) {
470
                                                        opcoes = opcoes + opcao + " - ";
471
                                                }
472
                                                String observacoes = "";
473
                                                if (VerificadorUtil.naoEstaNuloOuVazio(opcoes)) {
474
                                                        observacoes = observacoes + opcoes;
475
                                                }
476
                                                if (VerificadorUtil.naoEstaNuloOuVazio(getLancamento().getOpcaoRestaurante())) {
477
                                                        observacoes = observacoes + getLancamento().getOpcaoRestaurante();
478
                                                }
479
                                                if (VerificadorUtil.naoEstaNuloOuVazio(getLancamento().getObservacaoRestaurante())) {
480
                                                        observacoes = observacoes + " (" + getLancamento().getObservacaoRestaurante() + ")";
481
                                                }
482
                                                getLancamento().setObservacao(observacoes);
483
                                                getParametrosVenda().getLancamentos().add((Lancamento)getLancamento().clone());
484
                                        } catch (CloneNotSupportedException e) {
485
                                                e.printStackTrace();
486
                                        }
487
                                }
488
                                limparLancamento();
489
                                LancadorMensagem.lancarSucesso("PRODUTO ADICIONADO COM SUCESSO");
490
                        }
491
                });
492
        }
493
 
494
        /*
495
         * MÉTODO DA FARMÁCIA
496
         *//*
497
        protected void atualizarValorVendaSeForLojaFarmaciaEProdutoSemValorVenda(Lancamento lancamento) {
498
                if (getParametrosVenda().getLoja().getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)) {
499
                        if (lancamento.getProduto().tipoProdutoEhRemedioOuOutros()) {
500
                                Produto produto = produtoService.consultarProdutoPorCodigo(lancamento.getProduto().getCodigo());
501
                                if (VerificadorUtil.estaNuloOuVazio(produto.getValorVarejo())) {
502
                                        produto.setValorVarejo(lancamento.getValorVenda());
503
                                        produtoService.alterar(produto);
504
                                }
505
                        }
506
                }
507
        }*/
508
 
509
        public void removerLancamento(final Lancamento lancamento) {
510
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
511
                        public void execute() {
512
                                getParametrosVenda().getLancamentos().remove(lancamento);
513
                                LancadorMensagem.lancarSucesso("PRODUTO REMOVIDO COM SUCESSO");
514
                        }
515
                });
516
        }
517
 
518
        public void limparLancamento() {
519
                setLancamento(new Lancamento());
520
                setCodigoProduto("");
521
        }
522
 
523
        public void limparPagamento() {
524
                setBandeiraCartao(null);
525
                setValorPagamento(null);
526
        }
527
 
528
        public void prepararPagamento() {
529
                limparPagamento();
530
                Double subtotal = getParametrosVenda().valorTotalLancamentos() /*+ getParametrosVenda().getValorFrete() */ - getParametrosVenda().valorTotalPago();
531
                if (subtotal > 0) {
532
                        setValorPagamento(subtotal);
533
                }
534
        }
535
 
536
        public void prepararPagamentoComCupom() {
537
                prepararPagamento();
538
                setCupomSelecionado(new Cupom());
539
        }
540
 
541
        public void adicionarPagamentoEmDinheiro() {
542
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
543
                        public void execute() {
544
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_DINHEIRO));
545
                        }
546
                });
547
        }
548
 
549
        public void adicionarPagamentoEmPagseguro() {
550
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
551
                        public void execute() {
552
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_PAGSEGURO));
553
                        }
554
                });
555
        }
556
 
557
        public void adicionarPagamentoEmPix() {
558
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
559
                        public void execute() {
560
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_PIX));
561
                        }
562
                });
563
        }
564
 
565
        public void adicionarPagamentoComOutros() {
566
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
567
                        public void execute() {
568
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_OUTROS));
569
                        }
570
                });
571
        }
572
 
573
        private void adicionarPagamento(FormaPagamento formaPagamento) {
574
                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamentoService.consultarPorId(formaPagamento));
575
                vendaFormaPagamento.setValorPagamento(getValorPagamento());
576
                adicionarPagamento(vendaFormaPagamento);
577
        }
578
 
579
        public void adicionarPagamentoEmDebito() {
580
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
581
                        public void execute() {
582
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_DEBITO));
583
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento, getBandeiraCartao());
584
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
585
                                verificarPagamentoNoCartao(formaPagamento);
586
                                adicionarPagamento(vendaFormaPagamento);
587
                        }
588
                });
589
        }
590
 
591
        public void adicionarPagamentoEmCredito() {
592
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
593
                        public void execute() {
594
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), getFormaPagamento(), getBandeiraCartao());
595
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
596
                                verificarPagamentoNoCartao(getFormaPagamento());
597
                                adicionarPagamento(vendaFormaPagamento);
598
                        }
599
                });
600
        }
601
 
602
        public void adicionarPagamentoComCupom() {
603
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
604
                        public void execute() {
605
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CUPOM));
606
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento);
607
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
608
                                vendaFormaPagamento.setCupom(getCupomSelecionado());
609
                                adicionarPagamento(vendaFormaPagamento);
610
                        }
611
                });
612
        }
613
 
614
        public void adicionarPagamento(final VendaFormaPagamento vendaFormaPagamento) {
615
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
616
                        public void execute() {
617
                                verificarPagamento(vendaFormaPagamento);
618
                                getParametrosVenda().getLancamentosPagamentos().add(vendaFormaPagamento);
619
                                setFormaPagamento(null);
620
                                setValorPagamento(null);
621
                                setCupomSelecionado(null);
622
                                LancadorMensagem.lancarSucesso("PAGAMENTO ADICIONADO COM SUCESSO");
623
                        }
624
 
625
                        private void verificarPagamento(VendaFormaPagamento vendaFormaPagamento) {
626
                                if (VerificadorUtil.estaNulo(getValorPagamento())) {
627
                                        throw new NegocioException("VALOR DE PAGAMENTO INCORRETO");
628
                                }
629
                                if (getValorPagamento().equals(new Double(0))) {
630
                                        throw new NegocioException("VALOR DE PAGAMENTO INCORRETO");
631
                                }
632
                                /*
633
                                for (VendaFormaPagamento pagamento : getParametrosVenda().getLancamentosPagamentos()) {
634
                                        if (pagamento.getCodigoDaFormaPagamento().equals(vendaFormaPagamento.getCodigoDaFormaPagamento())) {
635
                                                throw new NegocioException("FORMA DE PAGAMENTO JÁ EXISTE");
636
                                        }
637
                                }
638
                                */
639
                        }
640
                });
641
        }
642
 
643
        protected void verificarPagamentoNoCartao(FormaPagamento formaPagamento) {
644
                if (VerificadorUtil.estaNulo(getBandeiraCartao())) {
645
                        throw new RuntimeException("É OBRIGATÓRIO INFORMAR A BANDEIRA");
646
                }
647
                if (VerificadorUtil.estaNulo(formaPagamento)) {
648
                        throw new RuntimeException("É OBRIGATÓRIO INFORMAR A BANDEIRA");
649
                }
650
        }
651
 
652
        public void removerPagamento(final VendaFormaPagamento pagamento) {
653
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
654
                        public void execute() {
655
                                getParametrosVenda().getLancamentosPagamentos().remove(pagamento);
656
                                LancadorMensagem.lancarSucesso("PRODUTO REMOVIDO COM SUCESSO");
657
                        }
658
                });
659
        }
660
 
661
        public void selecionarCliente(final Cliente cliente) {
662
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
663
                        public void execute() {
664
                                cliente.setAtivo(true);
665
                                clienteService.alterar(cliente);
666
                                getParametrosVenda().setCliente(clienteService.consultarClientePorCpfCnpj(cliente.getCpfCnpj()));
667
                                setCpfCnpjCliente(null);
668
                                adicionandoParametroArgsConfirmandoAcao(true);
669
                        }
670
                });
671
        }
672
 
673
        public void retirarCliente() {
674
                getParametrosVenda().setCliente(null);
675
        }
676
 
677
        public List<Vendedor> consultarVendedoresColaboradores() {
678
                return vendedorService.consultarVendedoresColaboradores();
679
        }
680
 
681
        public List<Vendedor> consultarVendedoresColaboradoresAtivos() {
682
                return vendedorService.consultarVendedoresColaboradoresAtivos(null);
683
        }
684
 
685
        public List<Vendedor> consultarVendedoresExternos() {
686
                return vendedorService.consultarVendedoresExternosAtivos();
687
        }
688
 
689
        public void iniciarNovaVenda() {
690
                Loja lojaSelecionada = getParametrosVenda().getLoja();
691
                setParametrosVenda(new ParametrosVendaDTO());
692
                getParametrosVenda().setLoja(lojaSelecionada);
693
                getParametrosVenda().setMaquineta(lojaSelecionada.getMaquineta());
694
                getParametrosVenda().setUsuario(contextoSeguranca.obterUsuario());
695
        }
696
 
697
        public void iniciarVenda() {
698
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
699
                        public void execute() {
700
                                LancadorMensagem.lancarSucessoRedirecionandoTela("VENDA REALIZADA COM SUCESSO!", "/sistema/pdv.xhtml?sequencialLoja=" + getParametrosVenda().getLoja().getSequencial());
701
                        }
702
                });
703
        }
704
 
705
        public void cadastrarVendaSemCupom() {
706
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
707
                        public void execute() {
708
                                vendaService.cadastrarVendaPeloPDV(getParametrosVenda());
709
                                iniciarNovaVenda();
710
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO!");
711
                        }
712
                });
713
        }
714
 
715
        public void cadastrarVendaComCupom() {
716
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
717
                        public void execute() {
718
                                setVendaSelecionada(vendaService.cadastrarVendaPeloPDV(getParametrosVenda()));
719
                                preCarregamento();
720
                                getParametrosVenda().setLoja(getVendaSelecionada().getLoja());
721
                                getParametrosVenda().setMaquineta(getParametrosVenda().getLoja().getMaquineta());
722
                                setEmitirCupom(true);
723
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
724
                        }
725
                });
726
        }
727
 
728
        public void cadastrarVendaFarma() {
729
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
730
                        public void execute() {
731
                                vendaService.cadastrarVendaPeloPDV(getParametrosVenda());
732
                                LancadorMensagem.lancarSucessoRedirecionandoTela("VENDA REALIZADA COM SUCESSO!", "/sistema/pdv.xhtml?sequencialLoja=" + getParametrosVenda().getLoja().getSequencial());
733
                        }
734
                });
735
        }
736
 
737
        public void cadastrarVendaRestaurante() {
738
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
739
                        public void execute() {
740
                                setVendaSelecionada(vendaService.cadastrarVendaPeloPDV(getParametrosVenda()));
741
                                preCarregamento();
742
                                getParametrosVenda().setLoja(getVendaSelecionada().getLoja());
743
                                getParametrosVenda().setMaquineta(getParametrosVenda().getLoja().getMaquineta());
744
                                getVendaSelecionada().setEmitirComanda(true);
745
                                setEmitirCupom(true);
746
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
747
                        }
748
                });
749
        }
750
 
751
        public void alterarVenda(final Boolean verificarJustificativa) {
752
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
753
                        public void execute() {
754
                                if (verificarJustificativa) {
755
                                        if (VerificadorUtil.estaNuloOuVazio(getParametrosVenda().getVenda().getJustificativaParaExcluir())) {
756
                                                throw new NegocioException("JUSTIFICATIVA OBRIGATÓRIA");
757
                                        }
758
                                }
759
                                vendaService.alterarVenda(getParametrosVenda(), contextoSeguranca.obterUsuario(), verificarJustificativa);
760
                                adicionandoParametroArgsConfirmandoAcao(true);
761
                                LancadorMensagem.lancarSucesso("VENDA ALTERADA COM SUCESSO");
762
                        }
763
                });
764
        }
765
 
766
        public void excluirVendaSelecionada() {
767
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
768
                        public void execute() {
769
                                if (VerificadorUtil.estaNuloOuVazio(getVendaSelecionada().getJustificativaParaExcluir())) {
770
                                        throw new RuntimeException("É OBRIGATÓRIO JUSTIFICAR");
771
                                }
772
                                vendaService.excluirVenda(getVendaSelecionada(), contextoSeguranca.obterUsuario());
773
                                adicionandoParametroArgsConfirmandoAcao(true);
774
                                LancadorMensagem.lancarSucesso("VENDA EXCLUÍDA COM SUCESSO");
775
                        }
776
                });
777
        }
778
 
779
        public void excluirVenda(final Venda venda) {
780
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
781
                        public void execute() {
782
                                vendaService.excluirVenda(venda, contextoSeguranca.obterUsuario());
783
                                adicionandoParametroArgsConfirmandoAcao(true);
784
                                LancadorMensagem.lancarSucesso("VENDA EXCLUÍDA COM SUCESSO");
785
                        }
786
                });
787
        }
788
 
789
        public String verificarFinanceiro(Venda venda) {
790
                Conta contaAReceber = new Conta();
791
                contaAReceber.setVenda(venda);
792
                contaAReceber.setIndicadorAtivo(true);
793
                if (contaAReceberService.obterQuantidadeDeRegistrosPassandoEntidade(contaAReceber) == 0) {
794
                        return "NENHUMA";
795
                }
796
        return parcelaService.verificarPossuiParcelaAberta(venda) ? "PENDENTE" : "QUITADO";
797
        }
798
 
799
        public void prepararEnvioCupomEmail() {
800
                setEmailParaEnvio(getVendaSelecionada().getEmailDoCliente());
801
        }
802
 
803
        public void enviarCupomPorEmail() {
804
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
805
                        public void execute() {
806
                                lancarExcecaoCasoEmailNaoInformado();
807
                                try {
808
                                        JasperPrint relatorio = notaFiscalService.retornarRelatorio(getVendaSelecionada());
809
                                        byte[] arquivo = JasperExportManager.exportReportToPdf(relatorio);
810
                                        new GerenciadorEmailImpl()
811
                                                .comEmailsDestino(getEmailParaEnvio())
812
                                                .comAssunto("CUPOM EMITIDO POR ESPAÇO CASE")
813
                                                .comConteudoHtml("OBRIGADO PELA PREFERÊNCIA!")
814
                                                .adicionarAnexo("CUPOM.pdf", arquivo, "pdf")
815
                                                .enviar();
816
                                        LancadorMensagem.lancarSucesso("Cupom enviado por email.");
817
                                } catch (Exception e) {
818
                                        e.printStackTrace();
819
                                }
820
                        }
821
 
822
                        private void lancarExcecaoCasoEmailNaoInformado() {
823
                                if (VerificadorUtil.estaNuloOuVazio(getEmailParaEnvio())) {
824
                                        throw new NegocioException("Obrigatório informar o email de destino");
825
                                }
826
                        }
827
                });
828
        }
829
 
830
        /*************************************************/
831
 
832
        public void informarEtico() {
833
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
834
                        public void execute() {
835
                                alterarCategoria(new Long(343), "ÉTICO");
836
                        }
837
                });
838
        }
839
 
840
        public void informarGenerico() {
841
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
842
                        public void execute() {
843
                                alterarCategoria(new Long(340), "GENÉRICO");
844
                        }
845
                });
846
        }
847
 
848
        public void informarSimilar() {
849
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
850
                        public void execute() {
851
                                alterarCategoria(new Long(338), "SIMILAR");
852
                        }
853
                });
854
        }
855
 
856
        public void informarOutros() {
857
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
858
                        public void execute() {
859
                                alterarCategoria(new Long(339), "OUTROS");
860
                        }
861
                });
862
        }
863
 
864
        public void alterarCategoria(final Long sequencialModelo, final String modelo) {
865
                Modelo modeloNovo = new Modelo();
866
                modeloNovo.setSequencial(sequencialModelo);
867
                modeloService.consultarPorId(modeloNovo);
868
                getLancamento().getProduto().setModelo(modeloNovo);
869
                produtoService.alterar(getLancamento().getProduto());
870
                setCodigoProduto("");
871
                LancadorMensagem.lancarSucesso("CATEGORIA ALTERADA PARA " + modelo);
872
        }
873
 
874
        public void informarLocalizacao() {
875
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
876
                        public void execute() {
877
                                produtoLojaService.alterarLocalizacao(getLocalizacaoNova(), getLancamento().getProduto(), getParametrosVenda().getLoja());
878
                                LancadorMensagem.lancarSucesso("LOCALIZAÇÃO ALTERADA PARA " + getLocalizacaoNova());
879
                                setCodigoProduto("");
880
                                setLocalizacaoNova("");
881
                        }
882
                });
883
        }
884
 
885
        public void prepararAdicionarCupom(Lancamento lancamento) {
886
                setLancamentoSelecionado(lancamento);
887
                setCupomSelecionado(new Cupom());
888
        }
889
 
890
        public void consultarCupom(final String tipoCupom) {
891
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
892
                        public void execute() {
893
                                setCupomSelecionado(cupomService.consultarCupomPorCodigo(getCupomSelecionado().getCodigo()));
894
                                verificarCupomValido();
895
                                verificarInclusaoDoCupom(getCupomSelecionado(), tipoCupom);
896
                                getCupomSelecionado().setLancamento(getLancamentoSelecionado());
897
 
898
                                if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getValor())) {
899
                                        setValorPagamento(getCupomSelecionado().getValor());
900
                                } else if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getPercentual())) {
901
                                        setValorPagamento(getCupomSelecionado().getLancamento().getValorVenda() * getCupomSelecionado().getPercentual() / 100);
902
                                }
903
                        }
904
 
905
                        private void verificarCupomValido() {
906
                                if (VerificadorUtil.estaNulo(getCupomSelecionado())) {
907
                                        setCupomSelecionado(new Cupom());
908
                                        throw new NegocioException("CUPOM NÃO LOCALIZADO");
909
                                } else {
910
                                        if (!getCupomSelecionado().valido() || !getCupomSelecionado().getAtivo()) {
911
                                                setCupomSelecionado(new Cupom());
912
                                                throw new NegocioException("CUPOM INVÁLIDO");
913
                                        }
914
                                        if (getCupomSelecionado().getLimiteUtilizacao()) {
915
                                                Integer vendasComCupom = lancamentoService.obterQuantidadeVendasComCupom(getCupomSelecionado());
916
                                                vendasComCupom += vendaFormaPagamentoService.obterQuantidadePagamentosComCupom(getCupomSelecionado());
917
                                                if (vendasComCupom > 0) {
918
                                                        setCupomSelecionado(new Cupom());
919
                                                        throw new NegocioException("CUPOM JÁ UTILIZADO ANTERIORMENTE");
920
                                                }
921
                                        }
922
                                }
923
                        }
924
 
925
                        private void verificarInclusaoDoCupom(Cupom cupom, String tipoCupom) {
926
                                if (TipoCupom.PROMOCIONAL.getValor().equals(tipoCupom)) {
927
                                        if (!cupom.getTipoCupom().equals(TipoCupom.PROMOCIONAL.getValor())) {
928
                                                setCupomSelecionado(new Cupom());
929
                                                throw new NegocioException("PERMITIDO APENAS PARA CUPONS PROMOCIONAIS");
930
                                        }
931
                                        if (getLancamentoSelecionado().getProduto().getProdutoEmPromocao()) {
932
                                                setCupomSelecionado(new Cupom());
933
                                                throw new NegocioException("AÇÃO NÃO PERMITIDA: PRODUTO JÁ EM PROMOÇÃO");
934
                                        }
935
                                } else if (TipoCupom.REEMBOLSO.getValor().equals(tipoCupom)) {
936
                                        if (!cupom.getTipoCupom().equals(TipoCupom.REEMBOLSO.getValor())) {
937
                                                setCupomSelecionado(new Cupom());
938
                                                throw new NegocioException("PERMITIDO APENAS PARA CUPONS DE REEMBOLSO");
939
                                        }
940
                                }
941
                        }
942
                });
943
        }
944
 
945
        public void adicionarCupom() {
946
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
947
                        public void execute() {
948
                                verificarSeValorMaiorDesconto(getValorPagamento());
949
                                verificarSeCupomJaFoiAdicionado(getCupomSelecionado(), getParametrosVenda().getLancamentos());
950
                                for (Lancamento lancamento : getParametrosVenda().getLancamentos()) {
951
                                        if (lancamento.equals(getCupomSelecionado().getLancamento())) {
952
                                                lancamento.setCupom(getCupomSelecionado());
953
                                                lancamento.setValorVarejo(lancamento.getValorVarejo() - getValorPagamento());
954
                                                lancamento.setValorVenda(lancamento.getValorVenda() - getValorPagamento());
955
                                                break;
956
                                        }
957
                                }
958
                                LancadorMensagem.lancarSucesso("CUPOM ADICIONADO COM SUCESSO");
959
                        }
960
 
961
                        private void verificarSeCupomJaFoiAdicionado(Cupom cupomSelecionado, List<Lancamento> lancamentos) {
962
                                if (cupomSelecionado.getLimiteUtilizacao()) {
963
                                        for (Lancamento lancamento : getParametrosVenda().getLancamentos()) {
964
                                                if (VerificadorUtil.naoEstaNulo(lancamento.getCupom())) {
965
                                                        if (lancamento.getCupom().equals(cupomSelecionado)) {
966
                                                                throw new RuntimeException("CUPOM JÁ FOI UTILIZADO");
967
                                                        }
968
                                                }
969
                                        }
970
                                }
971
                        }
972
 
973
                        private void verificarSeValorMaiorDesconto(Double valorPagamento) {
974
                                if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getValor())) {
975
                                        if (valorPagamento > getCupomSelecionado().getValor()) {
976
                                                throw new RuntimeException("VALOR DO DESCONTO ACIMA DO PERMITIDO");
977
                                        }
978
                                } else if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getPercentual())) {
979
                                        if (valorPagamento > getCupomSelecionado().getLancamento().getValorVenda() * getCupomSelecionado().getPercentual() / 100) {
980
                                                throw new RuntimeException("VALOR DO DESCONTO ACIMA DO PERMITIDO");
981
                                        }
982
                                }
983
                        }
984
                });
985
        }
986
 
987
        public void removerCupom(Lancamento lancamento) {
988
                for (Lancamento lancamentoVendas : getParametrosVenda().getLancamentos()) {
989
                        if (lancamentoVendas.equals(lancamento)) {
990
                                lancamentoVendas.setCupom(null);
991
                                lancamentoVendas.setValorVarejo(lancamento.getValorVarejo() + getValorPagamento());
992
                                lancamentoVendas.setValorVenda(lancamento.getValorVenda() + getValorPagamento());
993
                                break;
994
                        }
995
                }
996
                LancadorMensagem.lancarSucesso("CUPOM REMOVIDO COM SUCESSO");
997
        }
998
 
999
        public void vincularPedido() {
1000
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
1001
                        public void execute() {
1002
                                Pedido pedido = new Pedido();
1003
                                pedido.setSequencial(new Long(getCodigoPedido()));
1004
                                getParametrosVenda().setPedidoVinculado(pedidoService.consultarPedidoCompleto(pedido));
1005
                                if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getPedidoVinculado())) {
1006
                                        if (getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.FINALIZADO.getValor()) ||
1007
                                                        getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor())) {
1008
                                                throw new NegocioException("VÍNCULO NÃO REALIZADO: PEDIDO JÁ FINALIZADO");
1009
                                        }
1010
                                        getParametrosVenda().setObservacao("PEDIDO VINCULADO: " + getParametrosVenda().getPedidoVinculado().getSequencial() + ". " + getParametrosVenda().getObservacao());
1011
                                        Vendedor vendedorPedido = vendedorService.consultarVendedorPorPessoa(getParametrosVenda().getPedidoVinculado().getUsuarioPedido().getPessoa());
1012
                                        if (VerificadorUtil.naoEstaNulo(vendedorPedido)) {
1013
                                                getParametrosVenda().setVendedor(vendedorPedido);
1014
                                        }
1015
 
1016
                                        for (PedidoProduto pedidoProduto : getParametrosVenda().getPedidoVinculado().getProdutos()) {
1017
                                                Integer quantidadeProduto = 1;
1018
                                                while (quantidadeProduto <= pedidoProduto.getQuantidade()) {
1019
                                                        Lancamento lancamento = new Lancamento();
1020
                                                        lancamento.preencher(pedidoProduto.getProduto());
1021
                                                        lancamento.setValorVenda(pedidoProduto.getValor());
1022
                                                        lancamento.setObservacao(pedidoProduto.getObservacao());
1023
                                                        getParametrosVenda().getLancamentos().add(lancamento);
1024
                                                        quantidadeProduto++;
1025
                                                }
1026
                                        }
1027
 
1028
                                        if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getPedidoVinculado().getCliente())) {
1029
                                                getParametrosVenda().setCliente(getParametrosVenda().getPedidoVinculado().getCliente());
1030
                                        }
1031
                                        setCodigoPedido("");
1032
                                        LancadorMensagem.lancarSucesso("PEDIDO " + getParametrosVenda().getPedidoVinculado().getSequencial() + " VINCULADO");
1033
                                } else {
1034
                                        LancadorMensagem.lancarErro("PEDIDO NÃO ENCONTRADO");
1035
                                }
1036
                        }
1037
                });
1038
        }
1039
 
1040
}