Subversion Repositories Integrator Subversion

package br.com.ec.controller.managedbean;

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

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

import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.UploadedFile;
import org.springframework.context.annotation.Scope;

import br.com.ec.controller.managedbean.consultademanda.CompraConsultaPorDemanda;
import br.com.ec.controller.util.PdfUtil;
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.model.Compra;
import br.com.ec.domain.model.CompraProduto;
import br.com.ec.domain.model.Fornecedor;
import br.com.ec.domain.model.FornecedorProduto;
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.Produto;
import br.com.ec.domain.model.SubtipoProduto;
import br.com.ec.domain.model.Tributacao;
import br.com.ec.domain.model.tipos.nfe.TipoNotaFiscal;
import br.com.ec.domain.service.compra.CompraService;
import br.com.ec.domain.service.compraproduto.CompraProdutoService;
import br.com.ec.domain.service.fornecedor.FornecedorService;
import br.com.ec.domain.service.fornecedorproduto.FornecedorProdutoService;
import br.com.ec.domain.service.notafiscal.NotaFiscalService;
import br.com.ec.domain.service.produto.ProdutoService;
import br.com.ec.domain.service.produtodaloja.ProdutoLojaService;
import br.com.ec.domain.service.produtopedidocompra.ProdutoPedidoCompraService;
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 br.com.ec.web.util.TipoOperacao;

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

        private static final long serialVersionUID = 1L;
       
        private CompraProduto compraProdutoSelecionado;
        private Produto produtoSelecionado;
        private Integer quantidadeProdutoSelecionado;
        private String codigoProduto;
       
        private UploadedFile arquivoXml;
        private NotaFiscal notaFiscalImportada;
        private String tipoProdutoImportacao;
        private SubtipoProduto subtipoProdutoImportacao;
        private Tributacao tributacaoImportacao;
        private Modelo modeloProdutoImportacao;
        private String tipoProdutoEstilo;
       
        private CompraService compraService;
        private CompraProdutoService compraProdutoService;
        private ProdutoLojaService produtoLojaService;
        private ProdutoService produtoService;
        private FornecedorService fornecedorService;
        private FornecedorProdutoService fornecedorProdutoService;
        private NotaFiscalService notaFiscalService;
        private ProdutoPedidoCompraService produtoPedidoCompraService;

        private List<CompraProduto> listaCompraProdutos;
        private CompraConsultaPorDemanda lazy;
       
        private CompraProduto compraProdutoParaLocalizacao;
        private Boolean cadastrarParcelasImportadas;
        private Produto produtoSimuladorPreco;

        @Inject
        public CompraBean(CompraService compraService, CompraProdutoService compraProdutoService, ProdutoLojaService produtoLojaService,
                        ProdutoService produtoService, FornecedorService fornecedorService, NotaFiscalService notaFiscalService, FornecedorProdutoService fornecedorProdutoService,
                        ProdutoPedidoCompraService produtoPedidoCompraService, CompraConsultaPorDemanda lazy) {
                this.compraService = compraService;
                this.compraProdutoService = compraProdutoService;
                this.produtoLojaService = produtoLojaService;
                this.produtoService = produtoService;
                this.fornecedorService = fornecedorService;
                this.fornecedorProdutoService = fornecedorProdutoService;
                this.notaFiscalService = notaFiscalService;
                this.produtoPedidoCompraService = produtoPedidoCompraService;
                this.lazy = lazy;
        }
       
        @Override
        public void preCarregamento() {
                entidade = new Compra();
                parametrosConsulta = new ParametrosConsulta<Compra>();
                parametrosConsulta.setEntidade(entidade);
        }
       
        @Override
        public void limparEntidade() {
                setArquivoXml(null);
                setNotaFiscalImportada(null);
                setCadastrarParcelasImportadas(false);
        }

        @Override
        public GenericService<Compra> getService() {
                return compraService;
        }
       
        @Override
        public Compra getEntidade() {
                return entidade;
        }

        @Override
        public Compra getId() {
                return getEntidade();
        }
       
        public List<CompraProduto> getListaCompraProdutos() {
                return listaCompraProdutos;
        }
        public void setListaCompraProdutos(List<CompraProduto> listaCompraProdutos) {
                this.listaCompraProdutos = listaCompraProdutos;
        }
       
        public CompraConsultaPorDemanda getLazy() {
                prepararConsultaDemanda();
                return lazy;
        }
        public void setLazy(CompraConsultaPorDemanda lazy) {
                this.lazy = lazy;
        }
        public void prepararConsultaDemanda() {
                lazy.setarParametrosConsulta(getParametrosConsulta());
        }
       
        public CompraProduto getCompraProdutoSelecionado() {
                return compraProdutoSelecionado;
        }
        public void setCompraProdutoSelecionado(CompraProduto compraProdutoSelecionado) {
                this.compraProdutoSelecionado = compraProdutoSelecionado;
        }
       
        public Produto getProdutoSelecionado() {
                return produtoSelecionado;
        }
        public void setProdutoSelecionado(Produto produtoSelecionado) {
                this.produtoSelecionado = produtoSelecionado;
        }
       
        public Integer getQuantidadeProdutoSelecionado() {
                return quantidadeProdutoSelecionado;
        }
        public void setQuantidadeProdutoSelecionado(Integer quantidadeProdutoSelecionado) {
                this.quantidadeProdutoSelecionado = quantidadeProdutoSelecionado;
        }
       
        public String getCodigoProduto() {
                return codigoProduto;
        }
        public void setCodigoProduto(String codigoProduto) {
                this.codigoProduto = codigoProduto;
        }
       
        public UploadedFile getArquivoXml() {
                return arquivoXml;
        }
        public void setArquivoXml(UploadedFile arquivoXml) {
                this.arquivoXml = arquivoXml;
        }
       
        public NotaFiscal getNotaFiscalImportada() {
                return notaFiscalImportada;
        }
        public void setNotaFiscalImportada(NotaFiscal notaFiscalImportada) {
                this.notaFiscalImportada = notaFiscalImportada;
        }
       
        public String getTipoProdutoImportacao() {
                return tipoProdutoImportacao;
        }
        public void setTipoProdutoImportacao(String tipoProdutoImportacao) {
                this.tipoProdutoImportacao = tipoProdutoImportacao;
        }
       
        public SubtipoProduto getSubtipoProdutoImportacao() {
                return subtipoProdutoImportacao;
        }
        public void setSubtipoProdutoImportacao(SubtipoProduto subtipoProdutoImportacao) {
                this.subtipoProdutoImportacao = subtipoProdutoImportacao;
        }
       
        public Tributacao getTributacaoImportacao() {
                return tributacaoImportacao;
        }
        public void setTributacaoImportacao(Tributacao tributacaoImportacao) {
                this.tributacaoImportacao = tributacaoImportacao;
        }
       
        public Modelo getModeloProdutoImportacao() {
                return modeloProdutoImportacao;
        }
        public void setModeloProdutoImportacao(Modelo modeloProdutoImportacao) {
                this.modeloProdutoImportacao = modeloProdutoImportacao;
        }
       
        public String getTipoProdutoEstilo() {
                return tipoProdutoEstilo;
        }
        public void setTipoProdutoEstilo(String tipoProdutoEstilo) {
                this.tipoProdutoEstilo = tipoProdutoEstilo;
        }
       
        public CompraProduto getCompraProdutoParaLocalizacao() {
                return compraProdutoParaLocalizacao;
        }
        public void setCompraProdutoParaLocalizacao(CompraProduto compraProdutoParaLocalizacao) {
                this.compraProdutoParaLocalizacao = compraProdutoParaLocalizacao;
        }
       
        public Boolean getCadastrarParcelasImportadas() {
                return cadastrarParcelasImportadas;
        }
        public void setCadastrarParcelasImportadas(Boolean cadastrarParcelasImportadas) {
                this.cadastrarParcelasImportadas = cadastrarParcelasImportadas;
        }
       
        public Produto getProdutoSimuladorPreco() {
                return produtoSimuladorPreco;
        }
        public void setProdutoSimuladorPreco(Produto produtoSimuladorPreco) {
                this.produtoSimuladorPreco = produtoSimuladorPreco;
        }
       
        @Override
        public void preConsultar() {
                setTipoOperacao(TipoOperacao.CONSULTAR);
                limparEntidade();
        }
       
        @Override
        public void preDetalhar(Compra compra) {
                super.preDetalhar(compra);
                prepararProdutosDaCompra(compra);
                setNotaFiscalImportada(null);
        }
       
        @Override
        public void preCadastrar() {
                super.preCadastrar();
                Compra compra = new Compra();
                compra.setIndicadorVerificada(false);
                compra.setIndicadorAtivo(true);
                compra.setLoja(new Loja(ConstantesSEC.SEQUENCIAL_MATRIZ_ESTOQUE_9));
                setEntidade(compra);
        }
       
        @Override
        public void cadastrar() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                modificarEntidadeAntesDaOperacao();
                                getService().cadastrar(entidade);
                                limparEntidade();
                                modificarEntidadeDepoisDaOperacao();
                                LancadorMensagem.lancarSucesso(getMensagens().get(IDENTIFICADOR_MENSAGEM_CADASTRADO_COM_SUCESSO));
                                preDetalhar(getEntidade());
                        }
                });
        }
       
        public void alterarDetalharCompra() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                modificarEntidadeAntesDaOperacao();
                                getService().alterar(entidade);
                                limparEntidade();
                                modificarEntidadeDepoisDaOperacao();
                                LancadorMensagem.lancarSucesso(getMensagens().get(IDENTIFICADOR_MENSAGEM_ALTERADO_COM_SUCESSO));
                                preDetalhar(getEntidade());
                        }
                });
        }
       
        /***************************************************************/
       
        public Boolean verificarSeCompraTemProdutos(Compra compra) {
                CompraProduto compraProduto = new CompraProduto();
                compraProduto.setCompra(compra);
                Integer quantidadeProdutos = compraProdutoService.obterQuantidadeDeRegistrosPassandoEntidade(compraProduto);
                return quantidadeProdutos > 0? true : false;
        }
       
        public Double getValorTotalProdutos() {
                Double total = new Double(0);
                if (VerificadorUtil.naoEstaNulo(getListaCompraProdutos())) {
                        for (CompraProduto compraProduto : getListaCompraProdutos()) {
                                if (VerificadorUtil.naoEstaNulo(compraProduto.getValorCompra()) && VerificadorUtil.naoEstaNulo(compraProduto.getQuantidade())) {
                                        total = total + compraProduto.getValorCompra() * compraProduto.getQuantidade();
                                }
                        }
                }
                return total;
        }
       
        public Double getValorTotalProdutosComIPI() {
                Double total = new Double(0);
                if (VerificadorUtil.naoEstaNulo(getListaCompraProdutos())) {
                        for (CompraProduto compraProduto : getListaCompraProdutos()) {
                                if (VerificadorUtil.naoEstaNulo(compraProduto.getValorCompra()) && VerificadorUtil.naoEstaNulo(compraProduto.getQuantidade())) {
                                        total = total + ((compraProduto.getValorCompra() + compraProduto.getProduto().calculoIPI()) * compraProduto.getQuantidade());
                                }
                        }
                }
                return total;
        }
       
        public Integer getQuantidadeTotalProdutos() {
                Integer total = 0;
                if (VerificadorUtil.naoEstaNulo(listaCompraProdutos)) {
                        for (CompraProduto compraProduto : getListaCompraProdutos()) {
                                total = total + compraProduto.getQuantidade();
                        }
                }
                return total;
        }
       
        public void prepararProdutosDaCompra(Compra compra) {
                setListaCompraProdutos(compraProdutoService.consultarProdutosDaCompra(compra));
                setProdutoSelecionado(null);
                setCodigoProduto("");
        }
       
        public void escolherProduto(Produto produto) {
                setProdutoSelecionado(produto);
                setQuantidadeProdutoSelecionado(0);
        }
       
        public void consultarProduto() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Produto produtoSelecionado = produtoService.consultarProdutoPorCodigoOuCodigoEAN(getCodigoProduto());
                                if (produtoSelecionado != null) {
                                        setProdutoSelecionado(produtoSelecionado);
                                        setQuantidadeProdutoSelecionado(0);
                                        adicionandoParametroArgsConfirmandoAcao(true);
                                } else {
                                        LancadorMensagem.lancarErro("Produto não encontrado");
                                }
                        }
                });
        }
       
        public void confirmarProdutoImportado(final CompraProduto compraProduto) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                verificarParametros(compraProduto.getQuantidade());
                                verificarTributacao(compraProduto);
                                compraProduto.setValorCompra(compraProduto.getValorUnidadeComercial());
                                List<CompraProduto> listaCompraProduto = new ArrayList<CompraProduto>();
                                listaCompraProduto.add(compraProduto);
                                compraProdutoService.adicionarProdutosImportados(getEntidade(), listaCompraProduto,
                                                getTipoProdutoImportacao(), getTributacaoImportacao(), getModeloProdutoImportacao(), getTipoProdutoEstilo());
                                compraService.alterar(getEntidade());
                                getNotaFiscalImportada().getListaCompraProduto().remove(compraProduto);
                                prepararProdutosDaCompra(getEntidade());
                                LancadorMensagem.lancarSucesso("Produto importado com sucesso!");
                        }
                });
        }
       
        private void verificarTributacao(CompraProduto compraProduto) {
                if (compraProduto.getProduto().tipoProdutoTributado()) { // TODO: VERIFICANDO APENAS PRODUTOS DA ESPACO CASE
                        if (VerificadorUtil.estaNulo(compraProduto.getTributacaoDoProduto())) {
                                throw new NegocioException("Obrigatório informar: Tributação do produto.");
                        }
                }
        }
       
        public void adicionarProduto() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                verificarParametros(getQuantidadeProdutoSelecionado());
                                verificarProdutoSelecionado();
                                CompraProduto compraProduto = new CompraProduto();
                                compraProduto.setCompra(compraService.consultarPorId(getEntidade()));
                                compraProduto.setProduto(getProdutoSelecionado());
                                compraProduto.setValorCompra(getProdutoSelecionado().getValorCompra());
                                compraProduto.setQuantidade(getQuantidadeProdutoSelecionado());
                                produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(getQuantidadeProdutoSelecionado(), getProdutoSelecionado(), compraProduto.getLojaDaCompra());
                                compraProdutoService.cadastrar(compraProduto);
                                atualizarDadosDoProduto(compraProduto);
                                prepararProdutosDaCompra(getEntidade());
                                produtoPedidoCompraService.retirarPedido(compraProduto);
                                produtoService.verificarPedidosProdutoParaEntrarEmContato(compraProduto.getProduto(), compraProduto.getCompra().getSequencial());
                                adicionandoParametroArgsConfirmandoAcao(true);
                                LancadorMensagem.lancarSucesso("Produto adicionado com sucesso!");
                        }
                });
        }
       
        public void alterarCompraProduto() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Integer estoqueAntigo = getCompraProdutoSelecionado().getQuantidade();
                                verificarParametros(getQuantidadeProdutoSelecionado());
                                getCompraProdutoSelecionado().setQuantidade(getQuantidadeProdutoSelecionado());
                                produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(estoqueAntigo * -1, getCompraProdutoSelecionado().getProduto(), getCompraProdutoSelecionado().getCompra().getLoja());
                                produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(getCompraProdutoSelecionado().getQuantidade(), getCompraProdutoSelecionado().getProduto(), getCompraProdutoSelecionado().getCompra().getLoja());
                                compraProdutoService.alterar(getCompraProdutoSelecionado());
                                atualizarDadosDoProduto(getCompraProdutoSelecionado());
                                prepararProdutosDaCompra(getEntidade());
                                adicionandoParametroArgsConfirmandoAcao(true);
                                LancadorMensagem.lancarSucesso("Produto alterado com sucesso!");
                        }
                });
        }
       
        private void verificarParametros(Integer quantidade) {
                if (VerificadorUtil.estaNulo(quantidade) || quantidade <= 0) {
                        throw new NegocioException("Obrigatório informar: Quantidade comprada.");
                }
        }
       
        private void verificarProdutoSelecionado() {
                if (getProdutoSelecionado().getCodigo().equals("000000")) {
                        throw new NegocioException("PRODUTO NÃO PODE SER ADICIONADO");
                }
        }
       
        protected void atualizarDadosDoProduto(CompraProduto compraProduto) {
                Produto produto = compraProduto.getProduto();
                produto.setValorCompra(compraProduto.getValorCompra());
                produtoService.alterar(produto);
                fornecedorProdutoService.sincronizandoFornecedor(new FornecedorProduto(compraProduto.getCompra().getFornecedor(), compraProduto.getProduto(), compraProduto.getValorCompra(), compraProduto.getCodigoProdutoNotaFiscal()));
        }
       
        public void removerProduto(final CompraProduto compraProduto) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(compraProduto.getQuantidade() * (-1), compraProduto.getProduto(), compraProduto.getCompra().getLoja());
                                compraProdutoService.excluir(compraProduto);
                                prepararProdutosDaCompra(getEntidade());
                                LancadorMensagem.lancarSucesso("Produto removido com sucesso!");
                        }
                });
        }
       
        public void cancelar(final Compra compra) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                compra.setIndicadorAtivo(false);
                                compraService.alterar(compra);
                                LancadorMensagem.lancarSucesso("Compra cancelada com sucesso!");
                        }
                });
        }
       
        public void excluir(final Compra compra) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                List<CompraProduto> produtosDacompra = compraProdutoService.consultarProdutosDaCompra(compra);
                                for (CompraProduto compraProduto : produtosDacompra) {
                                        produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(compraProduto.getQuantidade() * (-1), compraProduto.getProduto(), compraProduto.getCompra().getLoja());
                                        compraProdutoService.excluir(compraProduto);
                                }
                                compraService.excluir(compra);
                                LancadorMensagem.lancarSucesso("Compra excluída com sucesso!");
                        }
                });
        }

        public void ativar(final Compra compra) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                compra.setIndicadorAtivo(true);
                                compraService.alterar(compra);
                                LancadorMensagem.lancarSucesso("Compra ativada com sucesso!");
                        }
                });
        }
       
        public void uploadArquivoXml(final FileUploadEvent e) {
        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                NotaFiscal notaFiscal = notaFiscalService.importarXml(e.getFile(), getEntidade().getFornecedor());
                                preencherNotaFiscalImportada(notaFiscal);
                        }
                });
    }
       
        public void importarArquivoXmlImportado() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                NotaFiscal notaFiscal = notaFiscalService.importarXml(getEntidade().getNotaFiscal().getTextoXml(), getEntidade().getFornecedor());
                                preencherNotaFiscalImportada(notaFiscal);
                        }
                });
        }
       
        private void preencherNotaFiscalImportada(final NotaFiscal notaFiscal) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setNotaFiscalImportada(notaFiscal);
                                if (VerificadorUtil.estaNulo(getEntidade().getConta())) {
                                        setCadastrarParcelasImportadas(true);
                                } else {
                                        setCadastrarParcelasImportadas(false);
                                }
                                adicionandoParametroArgsConfirmandoAcao(true);
                        }
                });
        }
       
        public void confirmarImportacaoXml() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                NotaFiscal notaFiscalImportado = notaFiscalService.consultarPelaChaveEeTipo(getNotaFiscalImportada().getChave(), TipoNotaFiscal.NFE_ENTRADA.getValor());
                                if (VerificadorUtil.naoEstaNulo(notaFiscalImportado)) {
                                        getEntidade().setNotaFiscal(notaFiscalImportado);
                                } else {
                                        notaFiscalService.alterar(getNotaFiscalImportada());
                                        getEntidade().setNotaFiscal(notaFiscalService.consultarPelaChaveEeTipo(getNotaFiscalImportada().getChave(), TipoNotaFiscal.NFE_ENTRADA.getValor()));
                                }
                                if (getCadastrarParcelasImportadas()) {
                                        compraService.adicionarParcelasNaCompra(getEntidade(), getNotaFiscalImportada().getListaParcelas());
                                }
                                compraProdutoService.adicionarProdutosImportados(getEntidade(), getNotaFiscalImportada().getListaCompraProduto(),
                                                getTipoProdutoImportacao(), getTributacaoImportacao(), getModeloProdutoImportacao(), getTipoProdutoEstilo());
                                compraService.alterar(getEntidade());
                                prepararProdutosDaCompra(getEntidade());
                                setNotaFiscalImportada(null);
                                LancadorMensagem.lancarSucesso("Nota fiscal importada com sucesso.");
                        }
                });
        }
       
        public void cancelarImportacaoXml() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setNotaFiscalImportada(null);
                                LancadorMensagem.lancarSucesso("Importação da nota fiscal cancelada com sucesso.");
                        }
                });
        }
       
        public void zerarQuantidade() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                for (CompraProduto compraProdutoNotaFiscal : getNotaFiscalImportada().getListaCompraProduto()) {
                                        compraProdutoNotaFiscal.setQuantidade(0);
                                }
                                LancadorMensagem.lancarSucesso("Itens zerados com sucesso.");
                        }
                });
        }
       
        public void alterarParaSolicitarContagem() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                for (CompraProduto compraProdutoNotaFiscal : getNotaFiscalImportada().getListaCompraProduto()) {
                                        compraProdutoNotaFiscal.setIndicadorSolicitarContagem(true);
                                }
                                LancadorMensagem.lancarSucesso("Itens com solicitação de contagem ativada.");
                        }
                });
        }
       
        public void removerProdutosJaExistentes() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                List<CompraProduto> listaProdutosNovos = new ArrayList<CompraProduto>();
                                for (CompraProduto compraProdutoNotaFiscal : getNotaFiscalImportada().getListaCompraProduto()) {
                                        if (VerificadorUtil.estaNulo(compraProdutoNotaFiscal.getProduto().getSequencial())) {
                                                listaProdutosNovos.add(compraProdutoNotaFiscal);
                                        }
                                }
                                getNotaFiscalImportada().setListaCompraProduto(listaProdutosNovos);
                                LancadorMensagem.lancarSucesso("Produtos já cadastrados retirados com sucesso.");
                        }
                });
        }
       
        public void removerProdutosJaIncluidosNaCompra() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                List<CompraProduto> listaProdutosNaoIncluidos = new ArrayList<CompraProduto>();
                                for (CompraProduto compraProdutoNotaFiscal : getNotaFiscalImportada().getListaCompraProduto()) {
                                        Boolean produtoIncluido = false;
                                        for (CompraProduto compraProdutoIncluido : getListaCompraProdutos()) {
                                                if (VerificadorUtil.estaNulo(compraProdutoNotaFiscal.getProduto().getCodigo())) {
                                                        break;
                                                }
                                                if (compraProdutoNotaFiscal.getProduto().getCodigo().equals(compraProdutoIncluido.getProduto().getCodigo())) {
                                                        produtoIncluido = true;
                                                        break;
                                                }
                                        }
                                        if (!produtoIncluido) {
                                                listaProdutosNaoIncluidos.add(compraProdutoNotaFiscal);
                                        }
                                }
                               
                                getNotaFiscalImportada().setListaCompraProduto(listaProdutosNaoIncluidos);
                                LancadorMensagem.lancarSucesso("Produtos já incluídos retirados com sucesso.");
                        }
                });
        }
       
        public void removerTodos() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getNotaFiscalImportada().getListaCompraProduto().clear();
                                LancadorMensagem.lancarSucesso("Itens removidos com sucesso.");
                        }
                });
        }
       
        public void removerProdutoImportado(final CompraProduto compraProduto) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getNotaFiscalImportada().getListaCompraProduto().remove(compraProduto);
                                LancadorMensagem.lancarSucesso("Produto removido com sucesso!");
                        }
                });
        }
       
        public void localizarProduto(final Produto produtoLocalizado) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getNotaFiscalImportada().getListaCompraProduto().remove(getCompraProdutoParaLocalizacao());
                               
                                if (VerificadorUtil.naoEstaNuloOuVazio(getCompraProdutoParaLocalizacao().getProduto().getCodigoEAN())) {
                                        produtoLocalizado.setCodigoEAN(getCompraProdutoParaLocalizacao().getProduto().getCodigoEAN());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(getCompraProdutoParaLocalizacao().getProduto().getCodigoEANTributado())) {
                                        produtoLocalizado.setCodigoEANTributado(getCompraProdutoParaLocalizacao().getProduto().getCodigoEANTributado());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(getCompraProdutoParaLocalizacao().getProduto().getCodigoNCM())) {
                                        produtoLocalizado.setCodigoNCM(getCompraProdutoParaLocalizacao().getProduto().getCodigoNCM());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(getCompraProdutoParaLocalizacao().getProduto().getCodigoEST())) {
                                        produtoLocalizado.setCodigoEST(getCompraProdutoParaLocalizacao().getProduto().getCodigoEST());
                                }
                                getCompraProdutoParaLocalizacao().setProduto(produtoLocalizado);
                                getCompraProdutoParaLocalizacao().setValorCompra(produtoLocalizado.getValorCompra());
                                getNotaFiscalImportada().getListaCompraProduto().add(getCompraProdutoParaLocalizacao());
                                LancadorMensagem.lancarSucesso("Produto localizado com sucesso!");
                        }
                });
        }
       
        private String recuperarTexto(String contemLinha, byte[] arquivo) {
                try {
                        String[] linhas = PdfUtil.extrairPDFEmLinhas(arquivo);
                        boolean capturar = false;
                        for (String linha : linhas) {
                                if (capturar) {
                                        return linha.trim();
                                }
                                if (linha.contains(contemLinha)) {
                                        capturar = true;
                                }
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return "";
        }
       
        public List<Fornecedor> consultarFornecedorPorNomeOuCnpj(String campo) {
                return fornecedorService.consultarFornecedorPorNomeOuCnpj(campo);
        }
       
        public void iniciarSimuladorPreco() {
                setProdutoSimuladorPreco(new Produto());
        }
       
}