Subversion Repositories Integrator Subversion

package br.com.ec.controller.managedbean;

import java.io.Serializable;
import java.util.List;

import javax.inject.Inject;
import javax.inject.Named;

import org.springframework.context.annotation.Scope;

import br.com.ec.controller.managedbean.datamodel.ParcelaDataModel;
import br.com.ec.core.consulta.ParametrosConsulta;
import br.com.ec.core.exception.NegocioException;
import br.com.ec.core.generic.GenericService;
import br.com.ec.core.util.VerificadorUtil;
import br.com.ec.domain.dto.ParametrosVendaDTO;
import br.com.ec.domain.model.BandeiraCartao;
import br.com.ec.domain.model.Cliente;
import br.com.ec.domain.model.Conta;
import br.com.ec.domain.model.Cupom;
import br.com.ec.domain.model.Estampa;
import br.com.ec.domain.model.FormaPagamento;
import br.com.ec.domain.model.Lancamento;
import br.com.ec.domain.model.Loja;
import br.com.ec.domain.model.Modelo;
import br.com.ec.domain.model.NotaFiscal;
import br.com.ec.domain.model.Pedido;
import br.com.ec.domain.model.PedidoProduto;
import br.com.ec.domain.model.Produto;
import br.com.ec.domain.model.Venda;
import br.com.ec.domain.model.VendaFormaPagamento;
import br.com.ec.domain.model.Vendedor;
import br.com.ec.domain.model.tipos.TipoCupom;
import br.com.ec.domain.model.tipos.TipoFrete;
import br.com.ec.domain.model.tipos.TipoPersonalizacao;
import br.com.ec.domain.model.tipos.TipoSituacaoPedido;
import br.com.ec.domain.service.bandeiracartao.BandeiraCartaoService;
import br.com.ec.domain.service.cashback.CashbackService;
import br.com.ec.domain.service.cliente.ClienteService;
import br.com.ec.domain.service.conta.ContaService;
import br.com.ec.domain.service.cupom.CupomService;
import br.com.ec.domain.service.email.impl.GerenciadorEmailImpl;
import br.com.ec.domain.service.estampa.EstampaService;
import br.com.ec.domain.service.formapagamento.FormaPagamentoService;
import br.com.ec.domain.service.lancamento.LancamentoService;
import br.com.ec.domain.service.loja.LojaService;
import br.com.ec.domain.service.modelo.ModeloService;
import br.com.ec.domain.service.notafiscal.NotaFiscalService;
import br.com.ec.domain.service.parcela.ParcelaService;
import br.com.ec.domain.service.pedido.PedidoService;
import br.com.ec.domain.service.produto.ProdutoService;
import br.com.ec.domain.service.produtodaloja.ProdutoLojaService;
import br.com.ec.domain.service.seguranca.ContextoSeguranca;
import br.com.ec.domain.service.venda.VendaService;
import br.com.ec.domain.service.vendaformapagamento.VendaFormaPagamentoService;
import br.com.ec.domain.service.vendedor.VendedorService;
import br.com.ec.domain.shared.ConstantesSEC;
import br.com.ec.web.exception.VerificadorLancamentoException;
import br.com.ec.web.exception.VerificadorLancamentoException.CommandBean;
import br.com.ec.web.generic.AbstractBean;
import br.com.ec.web.message.LancadorMensagem;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperPrint;

@Named
@Scope("view")
public class VendaBean extends AbstractBean<Venda> implements Serializable {

        private static final long serialVersionUID = 1L;
       
        private LojaService lojaService;
        private VendaService vendaService;
        private ProdutoService produtoService;
        private ProdutoLojaService produtoLojaService;
        private VendedorService vendedorService;
        private FormaPagamentoService formaPagamentoService;
        private VendaFormaPagamentoService vendaFormaPagamentoService;
        private BandeiraCartaoService bandeiraCartaoService;
        private ParcelaService parcelaService;
        private ContaService contaAReceberService;
        private ClienteService clienteService;
        private ModeloService modeloService;
        private NotaFiscalService notaFiscalService;
        private CupomService cupomService;
        private LancamentoService lancamentoService;
        private PedidoService pedidoService;
        private EstampaService estampaService;
        private CashbackService cashbackService;
        private ContextoSeguranca contextoSeguranca;
       
        private String codigoProduto;
        private String codigoPedido;
        private Lancamento lancamento;
        private String localizacaoNova;
        private String cpfCnpjCliente;
        private ParametrosVendaDTO parametrosVenda;
        private Venda vendaSelecionada;
        private String observacaoExclusao;
        private Cupom cupomSelecionado;
        private Lancamento lancamentoSelecionado;
       
        private FormaPagamento formaPagamento;
        private BandeiraCartao bandeiraCartao;
        private Double valorPagamento;
       
        private List<FormaPagamento> formasDePagamentoDeCredito;
        private List<BandeiraCartao> bandeirasDeDebito;
        private List<BandeiraCartao> bandeirasDeCredito;
       
        private ParcelaDataModel parcelas;
        private Boolean emitirCupom = false;
        private String emailParaEnvio;
       
        private List<Vendedor> vendedoresColaboradores;
        private List<Vendedor> vendedoresColaboradoresAtivos;
        private List<Vendedor> vendedoresExternos;
       
        private List<Estampa> estampas;
       
        @Inject
        public VendaBean(LojaService lojaService, VendaService vendaService, ProdutoService produtoService, ProdutoLojaService produtoLojaService,
                        VendedorService vendedorService, FormaPagamentoService formaPagamentoService, VendaFormaPagamentoService vendaFormaPagamentoService,
                        BandeiraCartaoService bandeiraCartaoService, ParcelaService parcelaService,
                        ContaService contaAReceberService, ClienteService clienteService, ModeloService modeloService,
                        NotaFiscalService notaFiscalService, CupomService cupomService, LancamentoService lancamentoService, PedidoService pedidoService,
                        EstampaService estampaService, CashbackService cashbackService, ContextoSeguranca contextoSeguranca) {
                this.lojaService = lojaService;
                this.vendaService = vendaService;
                this.produtoService = produtoService;
                this.produtoLojaService = produtoLojaService;
                this.vendedorService = vendedorService;
                this.formaPagamentoService = formaPagamentoService;
                this.vendaFormaPagamentoService = vendaFormaPagamentoService;
                this.bandeiraCartaoService = bandeiraCartaoService;
                this.parcelaService = parcelaService;
                this.contaAReceberService = contaAReceberService;
                this.clienteService = clienteService;
                this.modeloService = modeloService;
                this.notaFiscalService = notaFiscalService;
                this.cupomService = cupomService;
                this.lancamentoService = lancamentoService;
                this.pedidoService = pedidoService;
                this.estampaService = estampaService;
                this.cashbackService = cashbackService;
                this.contextoSeguranca = contextoSeguranca;
        }
       
        @Override
        public void preCarregamento() {
                limparEntidade();
        }

        private void setarParametrosDaLoja() {
                parametrosVenda = new ParametrosVendaDTO();
                if (VerificadorUtil.naoEstaNulo(getParametro("sequencialLoja"))) {
                        Loja loja = new Loja();
                        loja.setSequencial(new Long(getParametro("sequencialLoja").toString()));
                        parametrosVenda.setLoja(lojaService.consultarPorId(loja));
                        parametrosVenda.setMaquineta(parametrosVenda.getLoja().getMaquineta());
                }
                parametrosVenda.setUsuario(contextoSeguranca.obterUsuario());
        }
       
        @Override
        public void preDetalhar(Venda venda) {
                setEntidade(vendaService.detalharVendaCompleta(venda));
        }
       
        @Override
        public void limparEntidade() {
                entidade = new Venda();
                parametrosConsulta = new ParametrosConsulta<Venda>();
                parametrosConsulta.setEntidade(entidade);
               
                setLancamento(new Lancamento());
                setarParametrosDaLoja();
                setParcelas(new ParcelaDataModel());
        }

        @Override
        public GenericService<Venda> getService() {
                return vendaService;
        }
       
        @Override
        public Venda getEntidade() {
                return entidade;
        }

        @Override
        public Venda getId() {
                return getEntidade();
        }
       
        public String getCodigoProduto() {
                return codigoProduto;
        }
        public void setCodigoProduto(String codigoProduto) {
                this.codigoProduto = codigoProduto;
        }
       
        public String getCodigoPedido() {
                return codigoPedido;
        }
        public void setCodigoPedido(String codigoPedido) {
                this.codigoPedido = codigoPedido;
        }
       
        public Lancamento getLancamento() {
                return lancamento;
        }
        public void setLancamento(Lancamento lancamento) {
                this.lancamento = lancamento;
        }
       
        public String getLocalizacaoNova() {
                return localizacaoNova;
        }
        public void setLocalizacaoNova(String localizacaoNova) {
                this.localizacaoNova = localizacaoNova;
        }
       
        public String getCpfCnpjCliente() {
                return VerificadorUtil.naoEstaNulo(cpfCnpjCliente)? cpfCnpjCliente.replace(".", "").replace("-", "") : cpfCnpjCliente;
        }
        public void setCpfCnpjCliente(String cpfCnpjCliente) {
                this.cpfCnpjCliente = cpfCnpjCliente;
        }
       
        public ParametrosVendaDTO getParametrosVenda() {
                return parametrosVenda;
        }
        public void setParametrosVenda(ParametrosVendaDTO parametrosVenda) {
                this.parametrosVenda = parametrosVenda;
        }
       
        public Venda getVendaSelecionada() {
                return vendaSelecionada;
        }
        public void setVendaSelecionada(Venda vendaSelecionada) {
                this.vendaSelecionada = vendaSelecionada;
        }
       
        public String getObservacaoExclusao() {
                return observacaoExclusao;
        }
        public void setObservacaoExclusao(String observacaoExclusao) {
                this.observacaoExclusao = observacaoExclusao;
        }
       
        public Cupom getCupomSelecionado() {
                return cupomSelecionado;
        }
        public void setCupomSelecionado(Cupom cupomSelecionado) {
                this.cupomSelecionado = cupomSelecionado;
        }
       
        public Lancamento getLancamentoSelecionado() {
                return lancamentoSelecionado;
        }
        public void setLancamentoSelecionado(Lancamento lancamentoSelecionado) {
                this.lancamentoSelecionado = lancamentoSelecionado;
        }
       
        public FormaPagamento getFormaPagamento() {
                return formaPagamento;
        }
        public void setFormaPagamento(FormaPagamento formaPagamento) {
                this.formaPagamento = formaPagamento;
        }
       
        public BandeiraCartao getBandeiraCartao() {
                return bandeiraCartao;
        }
        public void setBandeiraCartao(BandeiraCartao bandeiraCartao) {
                this.bandeiraCartao = bandeiraCartao;
        }
       
        public Double getValorPagamento() {
                return valorPagamento;
        }
        public void setValorPagamento(Double valorPagamento) {
                this.valorPagamento = valorPagamento;
        }
       
        public List<FormaPagamento> getFormasDePagamentoDeCredito() {
                if (VerificadorUtil.estaNulo(formasDePagamentoDeCredito)) {
                        setFormasDePagamentoDeCredito(formaPagamentoService.consultarFormasDePagamentoDeCredito());
                }
                return formasDePagamentoDeCredito;
        }
        public void setFormasDePagamentoDeCredito(List<FormaPagamento> formasDePagamentoDeCredito) {
                this.formasDePagamentoDeCredito = formasDePagamentoDeCredito;
        }
       
        public List<BandeiraCartao> getBandeirasDeDebito() {
                if (VerificadorUtil.estaNulo(bandeirasDeDebito)) {
                        setBandeirasDeDebito(bandeiraCartaoService.consultarBandeiraCartoesDeDebito());
                }
                return bandeirasDeDebito;
        }
        public void setBandeirasDeDebito(List<BandeiraCartao> bandeirasDeDebito) {
                this.bandeirasDeDebito = bandeirasDeDebito;
        }
       
        public List<BandeiraCartao> getBandeirasDeCredito() {
                if (VerificadorUtil.estaNulo(bandeirasDeCredito)) {
                        setBandeirasDeCredito(bandeiraCartaoService.consultarBandeiraCartoesDeCredito());
                }
                return bandeirasDeCredito;
        }
        public void setBandeirasDeCredito(List<BandeiraCartao> bandeirasDeCredito) {
                this.bandeirasDeCredito = bandeirasDeCredito;
        }
       
        public List<Venda> getConsultarTodas() {
                return vendaService.consultarTodos(new Venda());
        }
       
        public ParcelaDataModel getParcelas() {
                atualizarParcelas(getParametrosVenda().getVenda());
                return parcelas;
    }
    public void setParcelas(ParcelaDataModel parcelas) {
        this.parcelas = parcelas;
    }
    public void atualizarParcelas(Venda venda) {
        if (VerificadorUtil.naoEstaNulo(venda)) {
                        setParcelas(new ParcelaDataModel(parcelaService.consultarParcelasDaVenda(getParametrosVenda().getVenda().getSequencial())));
                }
    }
   
    public Boolean getEmitirCupom() {
                return emitirCupom;
        }
        public void setEmitirCupom(Boolean emitirCupom) {
                this.emitirCupom = emitirCupom;
        }
       
        public String getEmailParaEnvio() {
                return emailParaEnvio;
        }
        public void setEmailParaEnvio(String emailParaEnvio) {
                this.emailParaEnvio = emailParaEnvio;
        }
       
        public List<Vendedor> getVendedoresColaboradores() {
                if (VerificadorUtil.estaNulo(vendedoresColaboradores)) {
                        setVendedoresColaboradores(vendedorService.consultarVendedoresColaboradores());
                }
                return vendedoresColaboradores;
        }
        public void setVendedoresColaboradores(List<Vendedor> vendedoresColaboradores) {
                this.vendedoresColaboradores = vendedoresColaboradores;
        }
       
        public List<Vendedor> getVendedoresColaboradoresAtivos() {
                if (VerificadorUtil.estaNulo(vendedoresColaboradoresAtivos)) {
                        setVendedoresColaboradoresAtivos(vendedorService.consultarVendedoresColaboradoresAtivos(null));
                }
                return vendedoresColaboradoresAtivos;
        }
        public void setVendedoresColaboradoresAtivos(List<Vendedor> vendedoresColaboradoresAtivos) {
                this.vendedoresColaboradoresAtivos = vendedoresColaboradoresAtivos;
        }
       
        public List<Vendedor> getVendedoresExternos() {
                if (VerificadorUtil.estaNulo(vendedoresExternos)) {
                        setVendedoresExternos(vendedorService.consultarVendedoresExternosAtivos());
                }
                return vendedoresExternos;
        }
        public void setVendedoresExternos(List<Vendedor> vendedoresExternos) {
                this.vendedoresExternos = vendedoresExternos;
        }
       
        public List<Estampa> getEstampas() {
                if (VerificadorUtil.estaNulo(estampas)) {
                        setEstampas(estampaService.consultarEstampas(null));
                }
                return estampas;
        }
        public void setEstampas(List<Estampa> estampas) {
                this.estampas = estampas;
        }
       
        public TipoFrete[] getTiposFrete() {
                return TipoFrete.values();
        }
       
        public TipoPersonalizacao[] getTiposPersonalizacao() {
                return TipoPersonalizacao.values();
        }
   
        /***************************************************************/
       
    public void selecionarCodigoProduto(String codigoProduto) {
        setCodigoProduto(codigoProduto);
    }
       
        public void prepararParaAlterarVenda(final Venda venda) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                parametrosVenda = new ParametrosVendaDTO(venda);
                        }
                });
        }
       
        public void prepararParaAlterarVendaFinanceiro(final Venda venda) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                parametrosVenda = new ParametrosVendaDTO(venda);
                                setParcelas(new ParcelaDataModel(parcelaService.consultarParcelasDaVenda(venda.getSequencial())));
                        }
                });
        }
       
        public void prepararParaExcluirVenda(final Venda venda) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setVendaSelecionada(venda);
                                List<NotaFiscal> notasFiscais = notaFiscalService.consultarNotasFiscais(venda);
                                if (!notasFiscais.isEmpty()) {
                                        String observacao = "";
                                        for (NotaFiscal notaFiscal : notasFiscais) {
                                                observacao = notaFiscal.getNumeroNotaFiscal() + "; ";
                                        }
                                        setObservacaoExclusao("OBS.: NOTAS FISCAIS VINCULADAS: " + observacao);
                                } else {
                                        setObservacaoExclusao("");
                                }
                        }
                });
        }
       
        public void consultarProduto() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
                                        getLancamento().preencher(produtoSelecionado);
                                }
                                getLancamento().setVenda(getEntidade());
                                getLancamento().setAtivo(true);
                        }
                });
        }
       
        public void consultarProdutoPrecoPopular() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
                                        getLancamento().preencherComPrecoPopular(produtoSelecionado);
                                }
                                getLancamento().setVenda(getEntidade());
                                getLancamento().setAtivo(true);
                        }
                });
        }
       
        public void consultarProdutoPrecoAtacado() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
                                        getLancamento().preencherComPrecoAtacado(produtoSelecionado);
                                }
                                getLancamento().setVenda(getEntidade());
                                getLancamento().setAtivo(true);
                        }
                });
        }
       
        public void consultarProdutoFarma() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoRapidoOuCodigoEAN(getCodigoProduto());
                                if (VerificadorUtil.naoEstaNulo(produtoSelecionado)) {
                                        getLancamento().preencher(produtoSelecionado);
                                }
                                getLancamento().setVenda(getEntidade());
                                getLancamento().setAtivo(true);
                        }
                });
        }
       
        public void adicionarLancamento() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                if (VerificadorUtil.estaNulo(getLancamento().getValorVenda())) {
                                        getLancamento().setValorVenda(new Double(0.0));
                                }
                                for (int i = 1; i <= getLancamento().getQuantidadeLancamento(); i++) {
                                        try {
                                                getLancamento().setObservacaoNotaFiscal(getLancamento().getObservacaoIMEI1() + " " + getLancamento().getObservacaoIMEI2());
                                                getLancamento().getObservacaoNotaFiscal().trim();
                                                getParametrosVenda().getLancamentos().add((Lancamento)getLancamento().clone());
                                        } catch (CloneNotSupportedException e) {
                                                e.printStackTrace();
                                        }
                                }
//                              atualizarValorVendaSeForLojaFarmaciaEProdutoSemValorVenda(getLancamento());
                                limparLancamento();
                                LancadorMensagem.lancarSucesso("PRODUTO ADICIONADO COM SUCESSO");
                        }
                });
        }
       
        public void adicionarLancamentoRestaurante() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                if (VerificadorUtil.estaNulo(getLancamento().getValorVenda())) {
                                        getLancamento().setValorVenda(new Double(0.0));
                                }
                                for (int i = 1; i <= getLancamento().getQuantidadeLancamento(); i++) {
                                        try {
                                                String opcoes = "";
                                                for (String opcao : getLancamento().getOpcoesRestaurante()) {
                                                        opcoes = opcoes + opcao + " - ";
                                                }
                                                String observacoes = "";
                                                if (VerificadorUtil.naoEstaNuloOuVazio(opcoes)) {
                                                        observacoes = observacoes + opcoes;
                                                }
                                                if (VerificadorUtil.naoEstaNuloOuVazio(getLancamento().getOpcaoRestaurante())) {
                                                        observacoes = observacoes + getLancamento().getOpcaoRestaurante();
                                                }
                                                if (VerificadorUtil.naoEstaNuloOuVazio(getLancamento().getObservacaoRestaurante())) {
                                                        observacoes = observacoes + " (" + getLancamento().getObservacaoRestaurante() + ")";
                                                }
                                                getLancamento().setObservacao(observacoes);
                                                getParametrosVenda().getLancamentos().add((Lancamento)getLancamento().clone());
                                        } catch (CloneNotSupportedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                limparLancamento();
                                LancadorMensagem.lancarSucesso("PRODUTO ADICIONADO COM SUCESSO");
                        }
                });
        }
       
        /*
         * MÉTODO DA FARMÁCIA
         *//*
        protected void atualizarValorVendaSeForLojaFarmaciaEProdutoSemValorVenda(Lancamento lancamento) {
                if (getParametrosVenda().getLoja().getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)) {
                        if (lancamento.getProduto().tipoProdutoEhRemedioOuOutros()) {
                                Produto produto = produtoService.consultarProdutoPorCodigo(lancamento.getProduto().getCodigo());
                                if (VerificadorUtil.estaNuloOuVazio(produto.getValorVarejo())) {
                                        produto.setValorVarejo(lancamento.getValorVenda());
                                        produtoService.alterar(produto);
                                }
                        }
                }
        }*/
       
        public void removerLancamento(final Lancamento lancamento) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getParametrosVenda().getLancamentos().remove(lancamento);
                                LancadorMensagem.lancarSucesso("PRODUTO REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void limparLancamento() {
                setLancamento(new Lancamento());
                setCodigoProduto("");
        }
       
        public void limparPagamento() {
                setBandeiraCartao(null);
                setValorPagamento(null);
        }
       
        public void prepararPagamento() {
                limparPagamento();
                Double subtotal = getParametrosVenda().valorTotalLancamentos() /*+ getParametrosVenda().getValorFrete() */ - getParametrosVenda().valorTotalPago();
                if (subtotal > 0) {
                        setValorPagamento(subtotal);
                }
        }
       
        public void prepararPagamentoComCupom() {
                prepararPagamento();
                setCupomSelecionado(new Cupom());
        }
       
        public void prepararPagamentoComCashback() {
                limparPagamento();
                Double subtotalPago = getParametrosVenda().valorTotalLancamentos() - getParametrosVenda().valorTotalPago();
                Double subtotal = getParametrosVenda().getCliente().getValorCashbackDisponivel();
                if (subtotal > 0) {
                        if (subtotal > subtotalPago) {
                                setValorPagamento(subtotalPago);
                        } else {
                                setValorPagamento(subtotal);
                        }
                }
        }
       
        public void adicionarPagamentoEmDinheiro() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_DINHEIRO));
                        }
                });
        }
       
        public void adicionarPagamentoEmPix() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_PIX));
                        }
                });
        }
       
        public void adicionarPagamentoEmTransferencia() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_TRANSFERENCIA));
                        }
                });
        }
       
        public void adicionarPagamentoComOutros() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarPagamento(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_OUTROS));
                        }
                });
        }
       
        private void adicionarPagamento(FormaPagamento formaPagamento) {
                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamentoService.consultarPorId(formaPagamento));
                vendaFormaPagamento.setValorPagamento(getValorPagamento());
                adicionarPagamento(vendaFormaPagamento);
        }
       
        public void adicionarPagamentoEmDebito() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_DEBITO));
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento, getBandeiraCartao());
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
                                verificarPagamentoNoCartao(formaPagamento);
                                adicionarPagamento(vendaFormaPagamento);
                        }
                });
        }

        public void adicionarPagamentoEmCredito() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), getFormaPagamento(), getBandeiraCartao());
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
                                verificarPagamentoNoCartao(getFormaPagamento());
                                adicionarPagamento(vendaFormaPagamento);
                        }
                });
        }
       
        public void adicionarPagamentoComCupom() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CUPOM));
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento);
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
                                vendaFormaPagamento.setCupom(getCupomSelecionado());
                                adicionarPagamento(vendaFormaPagamento);
                        }
                });
        }
       
        public void adicionarPagamentoComCashback() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                for (VendaFormaPagamento pagamento : getParametrosVenda().getLancamentosPagamentos()) {
                                        if (pagamento.getFormaPagamento().formaPagamentoEhCashback()) {
                                                throw new NegocioException("SÓ É PERMITIDO APENAS UM CASHBACK NA VENDA");
                                        }
                                }
                               
                                Double valorCashback = new Double(getValorPagamento());
                                Double valorCashbackDisponivel = new Double(getParametrosVenda().getCliente().getValorCashbackDisponivel());
                                if (VerificadorUtil.naoEstaNuloOuVazio(valorCashback)) {
                                        if (VerificadorUtil.naoEstaNuloOuVazio(valorCashbackDisponivel)) {
                                                if (valorCashbackDisponivel < valorCashback) {
                                                        throw new NegocioException("VALOR DE CASHBACK MAIOR QUE O PERMITIDO");
                                                }
                                        }
                                }
                               
                                FormaPagamento formaPagamento = formaPagamentoService.consultarPorId(new FormaPagamento(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CASHBACK_28));
                                VendaFormaPagamento vendaFormaPagamento = new VendaFormaPagamento(getEntidade(), formaPagamento);
                                vendaFormaPagamento.setValorPagamento(getValorPagamento());
                                adicionarPagamento(vendaFormaPagamento);
                                retirarCashbackCliente(valorCashback);
                        }

                        private void retirarCashbackCliente(Double valor) {
                                getParametrosVenda().getCliente().setValorCashbackDisponivel(getParametrosVenda().getCliente().getValorCashbackDisponivel() - valor);
                        }
                });
        }
        public void retirarPagamentosCashback() {
                for (VendaFormaPagamento pagamento : getParametrosVenda().getLancamentosPagamentos()) {
                        if (pagamento.getFormaPagamento().formaPagamentoEhCashback()) {
                                throw new NegocioException("RETIRE O CASHBACK DA VENDA PARA PROSSEGUIR");
                        }
                }
        }
       
        public void retirarPagamentoComCashback(final VendaFormaPagamento pagamento) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                if (pagamento.getFormaPagamento().formaPagamentoEhCashback()) {
                                        if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getCliente().getValorCashbackDisponivel())) {
                                                getParametrosVenda().getCliente().setValorCashbackDisponivel(getParametrosVenda().getCliente().getValorCashbackDisponivel() + pagamento.getValorPagamento());
                                        }
                                }
                        }
                });
        }
       
        public void adicionarPagamento(final VendaFormaPagamento vendaFormaPagamento) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                verificarPagamento(vendaFormaPagamento);
//                              seParcelaAcima12xAlterarMaquineta(getFormaPagamento());
                                getParametrosVenda().getLancamentosPagamentos().add(vendaFormaPagamento);
                                setFormaPagamento(null);
                                setValorPagamento(null);
                                setCupomSelecionado(null);
                                LancadorMensagem.lancarSucesso("PAGAMENTO ADICIONADO COM SUCESSO");
                        }

                        private void verificarPagamento(VendaFormaPagamento vendaFormaPagamento) {
                                if (VerificadorUtil.estaNulo(getValorPagamento())) {
                                        throw new NegocioException("VALOR DE PAGAMENTO INCORRETO");
                                }
                                if (getValorPagamento().equals(new Double(0))) {
                                        throw new NegocioException("VALOR DE PAGAMENTO INCORRETO");
                                }
                                /*
                                for (VendaFormaPagamento pagamento : getParametrosVenda().getLancamentosPagamentos()) {
                                        if (pagamento.getCodigoDaFormaPagamento().equals(vendaFormaPagamento.getCodigoDaFormaPagamento())) {
                                                throw new NegocioException("FORMA DE PAGAMENTO JÁ EXISTE");
                                        }
                                }
                                */
                        }
                       
                        private void seParcelaAcima12xAlterarMaquineta(FormaPagamento formaPagamento) {
                                if (formaPagamento.formaPagamentoEhCreditoAcima12x()) {
                                        getParametrosVenda().setMaquineta(null);
                                }
                        }
                });
        }
       
        protected void verificarPagamentoNoCartao(FormaPagamento formaPagamento) {
                if (VerificadorUtil.estaNulo(getBandeiraCartao())) {
                        throw new RuntimeException("É OBRIGATÓRIO INFORMAR A BANDEIRA");
                }
                if (VerificadorUtil.estaNulo(formaPagamento)) {
                        throw new RuntimeException("É OBRIGATÓRIO INFORMAR A BANDEIRA");
                }
        }
       
        public void removerPagamento(final VendaFormaPagamento pagamento) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getParametrosVenda().getLancamentosPagamentos().remove(pagamento);
                                retirarPagamentoComCashback(pagamento);
                                LancadorMensagem.lancarSucesso("PRODUTO REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void selecionarCliente(final Cliente cliente) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                cliente.setAtivo(true);
                                clienteService.alterar(cliente);
                                getParametrosVenda().setCliente(clienteService.consultarClientePorCpfCnpj(cliente.getCpfCnpj()));
                                setCpfCnpjCliente(null);
                                adicionandoParametroArgsConfirmandoAcao(true);
                        }
                });
        }
       
        public void retirarCliente() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                retirarPagamentosCashback();
                                getParametrosVenda().setCliente(null);
                        }
                });
        }
       
        public List<Vendedor> consultarVendedoresColaboradores() {
                return vendedorService.consultarVendedoresColaboradores();
        }
       
        public List<Vendedor> consultarVendedoresColaboradoresAtivos() {
                return vendedorService.consultarVendedoresColaboradoresAtivos(null);
        }
       
        public List<Vendedor> consultarVendedoresExternos() {
                return vendedorService.consultarVendedoresExternosAtivos();
        }
       
        public void iniciarNovaVenda() {
                Loja lojaSelecionada = getParametrosVenda().getLoja();
                setParametrosVenda(new ParametrosVendaDTO());
                getParametrosVenda().setLoja(lojaSelecionada);
                getParametrosVenda().setMaquineta(lojaSelecionada.getMaquineta());
                getParametrosVenda().setUsuario(contextoSeguranca.obterUsuario());
        }
       
        public void iniciarVenda() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                LancadorMensagem.lancarSucessoRedirecionandoTela("VENDA REALIZADA COM SUCESSO!", "/sistema/pdv.xhtml?sequencialLoja=" + getParametrosVenda().getLoja().getSequencial());
                        }
                });
        }
       
        public void cadastrarVendaSemCupom() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Venda vendaCadastrada = vendaService.cadastrarVendaPeloPDV(getParametrosVenda());
                                Long sequencialNovoPedido = pedidoService.cadastrarPedidoVendaPersonalizada(vendaCadastrada, getParametrosVenda());
                                if (VerificadorUtil.naoEstaNulo(sequencialNovoPedido)) {
                                        LancadorMensagem.lancarSucesso("Nº PERSONALIZAÇÃO: " + sequencialNovoPedido);
                                }
                                iniciarNovaVenda();
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
                        }
                });
        }
       
        public void cadastrarVendaComCupom() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setVendaSelecionada(vendaService.cadastrarVendaPeloPDV(getParametrosVenda()));
                                Long sequencialNovoPedido = pedidoService.cadastrarPedidoVendaPersonalizada(getVendaSelecionada(), getParametrosVenda());
                                if (VerificadorUtil.naoEstaNulo(sequencialNovoPedido)) {
                                        LancadorMensagem.lancarSucesso("Nº PERSONALIZAÇÃO: " + sequencialNovoPedido);
                                }
                                preCarregamento();
                                getParametrosVenda().setLoja(getVendaSelecionada().getLoja());
                                getParametrosVenda().setMaquineta(getVendaSelecionada().getLoja().getMaquineta());
                                setEmitirCupom(true);
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
                        }
                });
        }
       
        public void cadastrarVendaFarma() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                vendaService.cadastrarVendaPeloPDV(getParametrosVenda());
                                LancadorMensagem.lancarSucessoRedirecionandoTela("VENDA REALIZADA COM SUCESSO!", "/sistema/pdv.xhtml?sequencialLoja=" + getParametrosVenda().getLoja().getSequencial());
                        }
                });
        }
       
        public void cadastrarVendaRestaurante() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setVendaSelecionada(vendaService.cadastrarVendaPeloPDV(getParametrosVenda()));
                                preCarregamento();
                                getParametrosVenda().setLoja(getVendaSelecionada().getLoja());
                                getParametrosVenda().setMaquineta(getVendaSelecionada().getLoja().getMaquineta());
                                getVendaSelecionada().setEmitirComanda(true);
                                setEmitirCupom(true);
                                LancadorMensagem.lancarSucesso("VENDA REALIZADA COM SUCESSO");
                        }
                });
        }
       
        public void alterarVenda(final Boolean verificarJustificativa) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                if (verificarJustificativa) {
                                        if (VerificadorUtil.estaNuloOuVazio(getParametrosVenda().getVenda().getJustificativaParaExcluir())) {
                                                throw new NegocioException("JUSTIFICATIVA OBRIGATÓRIA");
                                        }
                                }
                                vendaService.alterarVenda(getParametrosVenda(), contextoSeguranca.obterUsuario(), verificarJustificativa);
                                adicionandoParametroArgsConfirmandoAcao(true);
                                LancadorMensagem.lancarSucesso("VENDA ALTERADA COM SUCESSO");
                        }
                });
        }
       
        public void excluirVendaSelecionada() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                if (VerificadorUtil.estaNuloOuVazio(getVendaSelecionada().getJustificativaParaExcluir())) {
                                        throw new RuntimeException("É OBRIGATÓRIO JUSTIFICAR");
                                }
                                vendaService.excluirVenda(getVendaSelecionada(), contextoSeguranca.obterUsuario());
                                adicionandoParametroArgsConfirmandoAcao(true);
                                LancadorMensagem.lancarSucesso("VENDA EXCLUÍDA COM SUCESSO");
                        }
                });
        }
       
        public void excluirVenda(final Venda venda) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                vendaService.excluirVenda(venda, contextoSeguranca.obterUsuario());
                                adicionandoParametroArgsConfirmandoAcao(true);
                                LancadorMensagem.lancarSucesso("VENDA EXCLUÍDA COM SUCESSO");
                        }
                });
        }
       
        public String verificarFinanceiro(Venda venda) {
                Conta contaAReceber = new Conta();
                contaAReceber.setVenda(venda);
                contaAReceber.setIndicadorAtivo(true);
                if (contaAReceberService.obterQuantidadeDeRegistrosPassandoEntidade(contaAReceber) == 0) {
                        return "NENHUMA";
                }
        return parcelaService.verificarPossuiParcelaAberta(venda) ? "PENDENTE" : "QUITADO";
        }
       
        public void prepararEnvioCupomEmail() {
                setEmailParaEnvio(getVendaSelecionada().getEmailDoCliente());
        }
       
        public void enviarCupomPorEmail() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                lancarExcecaoCasoEmailNaoInformado();
                                try {
                                        JasperPrint relatorio = notaFiscalService.retornarRelatorio(getVendaSelecionada());
                                        byte[] arquivo = JasperExportManager.exportReportToPdf(relatorio);
                                        new GerenciadorEmailImpl()
                                                .comEmailsDestino(getEmailParaEnvio())
                                                .comAssunto("CUPOM EMITIDO POR ESPAÇO CASE")
                                                .comConteudoHtml("OBRIGADO PELA PREFERÊNCIA!")
                                                .adicionarAnexo("CUPOM.pdf", arquivo, "pdf")
                                                .enviar();
                                        LancadorMensagem.lancarSucesso("Cupom enviado por email.");
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                       
                        private void lancarExcecaoCasoEmailNaoInformado() {
                                if (VerificadorUtil.estaNuloOuVazio(getEmailParaEnvio())) {
                                        throw new NegocioException("Obrigatório informar o email de destino");
                                }
                        }
                });
        }
       
        /*************************************************/
       
        public void informarEtico() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                alterarCategoria(new Long(343), "ÉTICO");
                        }
                });
        }
       
        public void informarGenerico() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                alterarCategoria(new Long(340), "GENÉRICO");
                        }
                });
        }
       
        public void informarSimilar() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                alterarCategoria(new Long(338), "SIMILAR");
                        }
                });
        }
       
        public void informarOutros() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                alterarCategoria(new Long(339), "OUTROS");
                        }
                });
        }
       
        public void alterarCategoria(final Long sequencialModelo, final String modelo) {
                Modelo modeloNovo = new Modelo();
                modeloNovo.setSequencial(sequencialModelo);
                modeloService.consultarPorId(modeloNovo);
                getLancamento().getProduto().setModelo(modeloNovo);
                produtoService.alterar(getLancamento().getProduto());
                setCodigoProduto("");
                LancadorMensagem.lancarSucesso("CATEGORIA ALTERADA PARA " + modelo);
        }
       
        public void informarLocalizacao() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                produtoLojaService.alterarLocalizacao(getLocalizacaoNova(), getLancamento().getProduto(), getParametrosVenda().getLoja());
                                LancadorMensagem.lancarSucesso("LOCALIZAÇÃO ALTERADA PARA " + getLocalizacaoNova());
                                setCodigoProduto("");
                                setLocalizacaoNova("");
                        }
                });
        }
       
        public void prepararAdicionarCupom(Lancamento lancamento) {
                setLancamentoSelecionado(lancamento);
                setCupomSelecionado(new Cupom());
        }
       
        public void consultarCupom(final String tipoCupom) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setCupomSelecionado(cupomService.consultarCupomPorCodigo(getCupomSelecionado().getCodigo()));
                                verificarCupomValido();
                                verificarInclusaoDoCupom(getCupomSelecionado(), tipoCupom);
                                getCupomSelecionado().setLancamento(getLancamentoSelecionado());
                               
                                if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getValor())) {
                                        setValorPagamento(getCupomSelecionado().getValor());
                                } else if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getPercentual())) {
                                        setValorPagamento(getCupomSelecionado().getLancamento().getValorVenda() * getCupomSelecionado().getPercentual() / 100);
                                }
                        }

                        private void verificarCupomValido() {
                                if (VerificadorUtil.estaNulo(getCupomSelecionado())) {
                                        setCupomSelecionado(new Cupom());
                                        throw new NegocioException("CUPOM NÃO LOCALIZADO");
                                } else {
                                        if (!getCupomSelecionado().valido() || !getCupomSelecionado().getAtivo()) {
                                                setCupomSelecionado(new Cupom());
                                                throw new NegocioException("CUPOM INVÁLIDO");
                                        }
                                        if (getCupomSelecionado().getLimiteUtilizacao()) {
                                                Integer vendasComCupom = lancamentoService.obterQuantidadeVendasComCupom(getCupomSelecionado());
                                                vendasComCupom += vendaFormaPagamentoService.obterQuantidadePagamentosComCupom(getCupomSelecionado());
                                                if (vendasComCupom > 0) {
                                                        setCupomSelecionado(new Cupom());
                                                        throw new NegocioException("CUPOM JÁ UTILIZADO ANTERIORMENTE");
                                                }
                                        }
                                }
                        }
                       
                        private void verificarInclusaoDoCupom(Cupom cupom, String tipoCupom) {
                                if (TipoCupom.PROMOCIONAL.getValor().equals(tipoCupom)) {
                                        if (!cupom.getTipoCupom().equals(TipoCupom.PROMOCIONAL.getValor())) {
                                                setCupomSelecionado(new Cupom());
                                                throw new NegocioException("PERMITIDO APENAS PARA CUPONS PROMOCIONAIS");
                                        }
                                        if (getLancamentoSelecionado().getProduto().getProdutoEmPromocao()) {
                                                setCupomSelecionado(new Cupom());
                                                throw new NegocioException("AÇÃO NÃO PERMITIDA: PRODUTO JÁ EM PROMOÇÃO");
                                        }
                                } else if (TipoCupom.REEMBOLSO.getValor().equals(tipoCupom)) {
                                        if (!cupom.getTipoCupom().equals(TipoCupom.REEMBOLSO.getValor())) {
                                                setCupomSelecionado(new Cupom());
                                                throw new NegocioException("PERMITIDO APENAS PARA CUPONS DE REEMBOLSO");
                                        }
                                }
                        }
                });
        }
       
        public void adicionarCupom() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                validarRegraCupom(getParametrosVenda(), getCupomSelecionado());
                                verificarSeValorMaiorDesconto(getValorPagamento());
                                verificarSeCupomJaFoiAdicionado(getCupomSelecionado(), getParametrosVenda().getLancamentos());
                                for (Lancamento lancamento : getParametrosVenda().getLancamentos()) {
                                        if (lancamento.equals(getCupomSelecionado().getLancamento())) {
                                                lancamento.setCupom(getCupomSelecionado());
                                                lancamento.setValorVarejo(lancamento.getValorVarejo() - getValorPagamento());
                                                lancamento.setValorVenda(lancamento.getValorVenda() - getValorPagamento());
                                                break;
                                        }
                                }
                                LancadorMensagem.lancarSucesso("CUPOM ADICIONADO COM SUCESSO");
                        }

                        private void validarRegraCupom(ParametrosVendaDTO parametrosVenda, Cupom cupomSelecionado) {
                                cupomService.validarRegrasCupom(getParametrosVenda(), getCupomSelecionado());
                        }

                        private void verificarSeCupomJaFoiAdicionado(Cupom cupomSelecionado, List<Lancamento> lancamentos) {
                                if (cupomSelecionado.getLimiteUtilizacao()) {
                                        for (Lancamento lancamento : getParametrosVenda().getLancamentos()) {
                                                if (VerificadorUtil.naoEstaNulo(lancamento.getCupom())) {
                                                        if (lancamento.getCupom().equals(cupomSelecionado)) {
                                                                throw new RuntimeException("CUPOM JÁ FOI UTILIZADO");
                                                        }
                                                }
                                        }
                                }
                        }

                        private void verificarSeValorMaiorDesconto(Double valorPagamento) {
                                if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getValor())) {
                                        if (valorPagamento > getCupomSelecionado().getValor()) {
                                                throw new RuntimeException("VALOR DO DESCONTO ACIMA DO PERMITIDO");
                                        }
                                } else if (VerificadorUtil.naoEstaNulo(getCupomSelecionado().getPercentual())) {
                                        if (valorPagamento > getCupomSelecionado().getLancamento().getValorVenda() * getCupomSelecionado().getPercentual() / 100) {
                                                throw new RuntimeException("VALOR DO DESCONTO ACIMA DO PERMITIDO");
                                        }
                                }
                        }
                });
        }
       
        public void removerCupom(Lancamento lancamento) {
                for (Lancamento lancamentoVendas : getParametrosVenda().getLancamentos()) {
                        if (lancamentoVendas.equals(lancamento)) {
                                lancamentoVendas.setCupom(null);
                                lancamentoVendas.setValorVarejo(lancamento.getValorVarejo() + getValorPagamento());
                                lancamentoVendas.setValorVenda(lancamento.getValorVenda() + getValorPagamento());
                                break;
                        }
                }
                LancadorMensagem.lancarSucesso("CUPOM REMOVIDO COM SUCESSO");
        }
       
        public void vincularPedido() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Pedido pedido = new Pedido();
                                pedido.setSequencial(new Long(getCodigoPedido()));
                                getParametrosVenda().setPedidoVinculado(pedidoService.consultarPedidoCompleto(pedido));
                                if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getPedidoVinculado())) {
                                        verificarSePedidoEhValido(getParametrosVenda().getPedidoVinculado());
                                        getParametrosVenda().setObservacao("PEDIDO VINCULADO: " + getParametrosVenda().getPedidoVinculado().getSequencial() + ". " + getParametrosVenda().getObservacao());
                                        Vendedor vendedorPedido = vendedorService.consultarVendedorPorPessoa(getParametrosVenda().getPedidoVinculado().getUsuarioPedido().getPessoa());
                                        if (VerificadorUtil.naoEstaNulo(vendedorPedido)) {
                                                getParametrosVenda().setVendedor(vendedorPedido);
                                        }
                                       
                                        for (PedidoProduto pedidoProduto : getParametrosVenda().getPedidoVinculado().getProdutos()) {
                                                Integer quantidadeProduto = 1;
                                                while (quantidadeProduto <= pedidoProduto.getQuantidade()) {
                                                        Lancamento lancamento = new Lancamento();
                                                        lancamento.preencher(pedidoProduto.getProduto());
                                                        lancamento.setValorVenda(pedidoProduto.getValor());
                                                        lancamento.setObservacao(pedidoProduto.getObservacao());
                                                        getParametrosVenda().getLancamentos().add(lancamento);
                                                        quantidadeProduto++;
                                                }
                                        }
                                       
                                        if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getPedidoVinculado().getCliente())) {
                                                getParametrosVenda().setCliente(getParametrosVenda().getPedidoVinculado().getCliente());
                                        }
                                        setCodigoPedido("");
                                        LancadorMensagem.lancarSucesso("PEDIDO " + getParametrosVenda().getPedidoVinculado().getSequencial() + " VINCULADO");
                                } else {
                                        LancadorMensagem.lancarErro("PEDIDO NÃO ENCONTRADO");
                                }
                        }

                        private void verificarSePedidoEhValido(Pedido pedidoVinculado) {
                                if (getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.FINALIZADO.getValor()) ||
                                                getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor())) {
                                        throw new NegocioException("VÍNCULO NÃO REALIZADO: PEDIDO JÁ FINALIZADO");
                                }
                                if (getParametrosVenda().getPedidoVinculado().getTipoSituacao().equals(TipoSituacaoPedido.INVALIDO.getValor())) {
                                        throw new NegocioException("VÍNCULO NÃO REALIZADO: PEDIDO INVÁLIDO");
                                }
                        }
                });
        }
       
        public void verificarCashback() {
                if (VerificadorUtil.naoEstaNulo(getParametrosVenda().getCliente())) {
                        getParametrosVenda().getCliente().setValorCashbackDisponivel(cashbackService.consultarSaldoCliente(getParametrosVenda().getCliente().getSequencial()));
                }
        }
       
}