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.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.Tributacao;

import br.com.ec.domain.model.tipos.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.pedido.PedidoService;

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.edu.cesmac.core.consulta.ParametrosConsulta;

import br.edu.cesmac.core.exception.NegocioException;

import br.edu.cesmac.core.generic.GenericService;

import br.edu.cesmac.core.util.VerificadorUtil;

import br.edu.cesmac.web.exception.VerificadorLancamentoException;

import br.edu.cesmac.web.exception.VerificadorLancamentoException.CommandBean;

import br.edu.cesmac.web.generic.AbstractBean;

import br.edu.cesmac.web.message.LancadorMensagem;

import br.edu.cesmac.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 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 PedidoService pedidoService;

        private List<CompraProduto> listaCompraProdutos;

        private CompraConsultaPorDemanda lazy;

        private CompraProduto compraProdutoParaLocalizacao;

        private Boolean cadastrarParcelasImportadas;

        @Inject

        public CompraBean(CompraService compraService, CompraProdutoService compraProdutoService, ProdutoLojaService produtoLojaService,

                        ProdutoService produtoService, FornecedorService fornecedorService, NotaFiscalService notaFiscalService, FornecedorProdutoService fornecedorProdutoService,

                        ProdutoPedidoCompraService produtoPedidoCompraService, PedidoService pedidoService, 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.pedidoService = pedidoService;

                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 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;

        }

        @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_RECEBIDA.getValor());

                                if (VerificadorUtil.naoEstaNulo(notaFiscalImportado)) {

                                        getEntidade().setNotaFiscal(notaFiscalImportado);

                                } else {

                                        notaFiscalService.alterar(getNotaFiscalImportada());

                                        getEntidade().setNotaFiscal(notaFiscalService.consultarPelaChaveEeTipo(getNotaFiscalImportada().getChave(), TipoNotaFiscal.NFE_RECEBIDA.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);

        }

}