public BatimentoEComplementacaoCnh(
     ICampoRepositorio campoRepositorio,
     IIndexacaoRepositorio indexacaoRepositorio,
     IGravaLogDoDocumentoServico gravaLogDocumentoServico,
     BatimentoFullText batimentoFullText,
     IMapeamentoCampoRepositorio mapeamentoCampoRepositorio)
 {
     this.campoRepositorio           = campoRepositorio;
     this.indexacaoRepositorio       = indexacaoRepositorio;
     this.gravaLogDocumentoServico   = gravaLogDocumentoServico;
     this.batimentoFullText          = batimentoFullText;
     this.mapeamentoCampoRepositorio = mapeamentoCampoRepositorio;
 }
        //// customização para "batimento" direto do OCR, sem informação para comparar, confiando no que o OCR leu.
        public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidos)
        {
            if (imagemReconhecida == null)
            {
                return;
            }

            var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;

            if (valoresReconhecidos == null)
            {
                return;
            }

            var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);

            foreach (var campoAtual in camposDoDocumento)
            {
                //// verifica se ja foi preenchido via batimento normal (evitar inserir linha duplicada)
                if (camposBatidos != null && camposBatidos.Any(x => x == campoAtual.Id))
                {
                    continue;
                }

                if (!campoAtual.PodeInserirPeloOcr)
                {
                    continue;
                }

                //// Há casos em que o Fluxo retorna para batimento depois da Identificação, e o documento já tem campos preenchidos
                //// se for um desses casos, não deve acrescentar batimento duplicado
                var indexacaoCampoAtual = this.indexacaoRepositorio.ObterPorTipoCampoDeUmDocumento(documento.Id, campoAtual.TipoCampo).FirstOrDefault();
                if (this.VerificaSeJaBateuCampoAtual(indexacaoCampoAtual))
                {
                    continue;
                }

                Indexacao indexacao          = null;
                var       encontrouIndexacao = false;
                foreach (var valorReconhecido in valoresReconhecidos)
                {
                    if (string.IsNullOrEmpty(valorReconhecido.Value))
                    {
                        continue;
                    }

                    if (campoAtual.EstaMapeadoPara(valorReconhecido.CampoTemplate, valorReconhecido.TemplateName) == false)
                    {
                        continue;
                    }

                    if (this.ConteudoEncontradoValido(ref indexacao, campoAtual, valorReconhecido))
                    {
                        encontrouIndexacao = true;
                        Log.Application.InfoFormat("Bateu TdCampo_code[{0}] do mdoc[{1}]. Conteudo:[{2}]", campoAtual.Id, documento.Id, indexacao.PrimeiroValor);
                        //// Se for uma data de nascimento, continuar buscando por data mais antiga
                        if (!this.DeveContinuarProcurando(campoAtual))
                        {
                            break;
                        }
                    }
                }

                if (encontrouIndexacao)
                {
                    if (indexacaoCampoAtual != null)
                    {
                        indexacaoCampoAtual.PrimeiroValor = indexacao.PrimeiroValor;
                        indexacao = indexacaoCampoAtual;
                    }
                    else
                    {
                        indexacao.Documento = documento;
                        documento.Indexacao.Add(indexacao);
                    }

                    indexacao.DataPrimeiraDigitacao = DateTime.Now;
                    this.gravaLogDocumentoServico.Executar(
                        LogDocumento.AcaoDocumentoOcr,
                        documento.Id,
                        string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", indexacao.Campo.Description, BatimentoFullText.LimitaString(indexacao.PrimeiroValor.Trim(), 99)));
                    this.indexacaoRepositorio.Salvar(indexacao);
                }
            }
        }
        public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
        {
            if (imagemReconhecida == null)
            {
                return;
            }

            var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;

            if (valoresReconhecidos == null)
            {
                return;
            }

            var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);

            foreach (var valorReconhecido in valoresReconhecidos)
            {
                if (camposDoDocumento == null)
                {
                    break;
                }

                if (camposDoDocumento.Count == 0)
                {
                    break;
                }

                if (string.IsNullOrEmpty(valorReconhecido.Value))
                {
                    continue;
                }

                var encontrouMapeamento = false;
                foreach (var campoDoDocumento in camposDoDocumento)
                {
                    if (campoDoDocumento
                        .EstaMapeadoPara(valorReconhecido.CampoTemplate, valorReconhecido.TemplateName) == false)
                    {
                        continue;
                    }

                    encontrouMapeamento = true;
                    Log.Application.DebugFormat("Campo {0} mapeado para campo {1} do template {2}",
                                                campoDoDocumento.Description,
                                                valorReconhecido.CampoTemplate,
                                                valorReconhecido.TemplateName);

                    var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);

                    if (string.IsNullOrEmpty(indexacao.ValorFinal) == false || string.IsNullOrWhiteSpace(indexacao.ValorFinal) == false)
                    {
                        continue;
                    }

                    var campoReconhecido = valorReconhecido.Value;

                    if (indexacao.Campo.TipoDado == TipoDado.DateTime)
                    {
                        campoReconhecido = campoReconhecido.FormatarData();

                        if (string.IsNullOrEmpty(campoReconhecido))
                        {
                            continue;
                        }
                    }

                    if (indexacao.BateCom(campoReconhecido))
                    {
                        indexacao.PrimeiroValor = indexacao.SegundoValor;
                        indexacao.ValorFinal    = indexacao.SegundoValor;
                        indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.SegundoValor;
                        indexacao.OcrComplementou       = true;
                        indexacao.DataPrimeiraDigitacao = DateTime.Now;

                        this.gravaLogDocumentoServico.Executar(
                            LogDocumento.AcaoDocumentoOcr,
                            documento.Id,
                            string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", campoDoDocumento.Description, BatimentoFullText.LimitaString(indexacao.SegundoValor.Trim(), 99)));
                    }
                    else
                    {
                        indexacao.PrimeiroValor         = string.Empty;
                        indexacao.ValorFinal            = string.Empty;
                        indexacao.DataPrimeiraDigitacao = DateTime.Now;
                    }

                    this.indexacaoRepositorio.Salvar(indexacao);
                }
            }
        }
Exemple #4
0
        public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
        {
            if (imagemReconhecida == null)
            {
                return;
            }

            var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;

            if (valoresReconhecidos == null)
            {
                return;
            }

            var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);

            foreach (var valorReconhecido in valoresReconhecidos)
            {
                if (camposDoDocumento == null)
                {
                    break;
                }

                if (camposDoDocumento.Count == 0)
                {
                    break;
                }

                if (string.IsNullOrEmpty(valorReconhecido.Value))
                {
                    continue;
                }

                var encontrouMapeamento = false;
                foreach (var campoDoDocumento in camposDoDocumento)
                {
                    if (campoDoDocumento
                        .EstaMapeadoPara(valorReconhecido.CampoTemplate, valorReconhecido.TemplateName) == false)
                    {
                        continue;
                    }

                    encontrouMapeamento = true;
                    Log.Application.DebugFormat("Campo {0} mapeado para campo {1} do template {2}",
                                                campoDoDocumento.Description,
                                                valorReconhecido.CampoTemplate,
                                                valorReconhecido.TemplateName);

                    var indexacao   = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);
                    var deveInserir = false;

                    if (indexacao == null)
                    {
                        if (campoDoDocumento.PodeInserirPeloOcr && string.IsNullOrEmpty(valorReconhecido.Value) == false)
                        {
                            deveInserir = true;
                        }
                        else
                        {
                            continue;
                        }
                    }

                    if (deveInserir)
                    {
                        //// TODO: revisar -2
                        indexacao = new Indexacao()
                        {
                            Campo                 = campoDoDocumento,
                            Documento             = documento,
                            PrimeiroValor         = valorReconhecido.Value,
                            OcrComplementou       = true,
                            DataPrimeiraDigitacao = DateTime.Now,
                            UsuarioPrimeiroValor  = -2
                        };

                        documento.Indexacao.Add(indexacao);
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(indexacao.ValorFinal) == false || string.IsNullOrWhiteSpace(indexacao.ValorFinal) == false)
                        {
                            continue;
                        }

                        if (indexacao.BateCom(valorReconhecido.Value))
                        {
                            indexacao.PrimeiroValor = indexacao.SegundoValor;
                            indexacao.ValorFinal    = indexacao.SegundoValor;
                            indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.SegundoValor;
                            indexacao.OcrComplementou       = true;
                            indexacao.DataPrimeiraDigitacao = DateTime.Now;

                            this.gravaLogDocumentoServico.Executar(
                                LogDocumento.AcaoDocumentoOcr,
                                documento.Id,
                                string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", campoDoDocumento.Description, BatimentoFullText.LimitaString(indexacao.SegundoValor.Trim(), 99)));
                        }
                        else
                        {
                            indexacao.PrimeiroValor         = string.Empty;
                            indexacao.ValorFinal            = string.Empty;
                            indexacao.DataPrimeiraDigitacao = DateTime.Now;
                        }
                    }

                    this.indexacaoRepositorio.Salvar(indexacao);
                }

                if (encontrouMapeamento == false)
                {
                    Log.Application.DebugFormat("ALERTA: campo {0} do template {1} não está mapeado para nenhum campo",
                                                valorReconhecido.CampoTemplate,
                                                valorReconhecido.TemplateName);
                }
            }

            ////batimento especial para campos de data (validade e emissao)
            try
            {
                this.BatimentoDatasDoAtestado(documento, valoresReconhecidos, camposDoDocumento);
            }
            catch (Exception exception)
            {
                Log.Application.Error(string.Format("Erro ao processar batimento de data do Atestado de Matricula- Documento #{0} ", documento.Id), exception);
            }

            ////batimento com fullTExt
            try
            {
                this.BaterUsandoFullText(documento, imagemReconhecida.Palavras);
            }
            catch (Exception exception)
            {
                Log.Application.Error(string.Format("Erro ao processar batimento full text de Atestado de Matricula - Documento #{0} ", documento.Id), exception);
            }
        }
Exemple #5
0
        public void BaterUsandoFullText(Documento documento, IList <PalavraReconhecida> palavras)
        {
            if (palavras == null)
            {
                return;
            }

            if (palavras.Count == 0)
            {
                return;
            }

            var listaLimpa = new List <dynamic>();

            foreach (var regiao in palavras)
            {
                var palavraAtual = Equivalencia.LimpaConteudoNome(regiao.Texto);
                if (string.IsNullOrEmpty(palavraAtual) == false)
                {
                    ////listaLimpa.Add(new dynamic()
                    ////{
                    ////    Texto = palavraAtual,
                    ////    Localizacao = regiao.Localizacao
                    ////});
                }
            }

            Log.Application.DebugFormat("Documento {0} - Palavras: {1} ", documento.Id, BatimentoFullText.ImprimirLista(listaLimpa));

            if (listaLimpa.Count == 0)
            {
                return;
            }

            var camposSemValor1 = this.indexacaoRepositorio.ObterComMapeamentoPorDocumento(documento);

            if (camposSemValor1 == null)
            {
                return;
            }

            if (camposSemValor1.Count == 0)
            {
                return;
            }

            var ultimoCampo = new Campo();

            foreach (var indexacao in camposSemValor1)
            {
                if (ultimoCampo.Id == indexacao.Campo.Id || indexacao.PrimeiroValor != null)
                {
                    continue;
                }

                ultimoCampo = indexacao.Campo;
                var deveSalvar = false;
                switch (indexacao.Campo.Id)
                {
                default:
                    if (indexacao.BateComFullText(listaLimpa))
                    {
                        deveSalvar = true;
                    }

                    break;
                }

                if (deveSalvar)
                {
                    indexacao.PrimeiroValor = indexacao.SegundoValor;
                    indexacao.ValorFinal    = indexacao.SegundoValor;
                    indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.SegundoValor;
                    indexacao.OcrComplementou       = true;
                    indexacao.DataPrimeiraDigitacao = DateTime.Now;

                    this.gravaLogDocumentoServico.Executar(
                        LogDocumento.AcaoDocumentoOcr,
                        documento.Id,
                        string.Format("Campo [{0}] complementado pelo ocr-FT. Valor:[{1}]", indexacao.Campo.Description, BatimentoFullText.LimitaString(indexacao.SegundoValor.Trim(), 99)));

                    this.indexacaoRepositorio.Salvar(indexacao);
                }
            }
        }
        public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
        {
            if (imagemReconhecida == null)
            {
                return;
            }

            var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;

            if (valoresReconhecidos == null)
            {
                return;
            }

            var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);

            foreach (var campoDoDocumento in camposDoDocumento)
            {
                if (this.mapeamentoCampoRepositorio.ExisteMapeamentoParaCampo(campoDoDocumento.Id) == false)
                {
                    Log.Application.DebugFormat("ALERTA: campo {0} não está mapeado para nenhum template", campoDoDocumento.Description);
                    continue;
                }

                var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);

                //// tenta bater com ancoragem ABBYY
                if (this.BatimentoAncoragemDeCnh(indexacao, campoDoDocumento, valoresReconhecidos, documento))
                {
                    this.gravaLogDocumentoServico.Executar(
                        LogDocumento.AcaoDocumentoOcr,
                        documento.Id,
                        string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", indexacao.Campo.Description, BatimentoFullText.LimitaString(indexacao.SegundoValor.Trim(), 99)));
                    this.indexacaoRepositorio.Salvar(indexacao);
                }
            }
        }
Exemple #7
0
        public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
        {
            if (imagemReconhecida == null)
            {
                return;
            }

            var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;

            if (valoresReconhecidos == null)
            {
                return;
            }

            var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);

            foreach (var valorReconhecido in valoresReconhecidos)
            {
                if (camposDoDocumento == null)
                {
                    break;
                }

                if (camposDoDocumento.Count == 0)
                {
                    break;
                }

                if (string.IsNullOrEmpty(valorReconhecido.Value))
                {
                    continue;
                }

                var encontrouMapeamento = false;
                foreach (var campoDoDocumento in camposDoDocumento)
                {
                    if (campoDoDocumento
                        .EstaMapeadoPara(valorReconhecido.CampoTemplate, valorReconhecido.TemplateName) == false)
                    {
                        continue;
                    }

                    encontrouMapeamento = true;
                    Log.Application.DebugFormat("Campo {0} mapeado para campo {1} do template {2}",
                                                campoDoDocumento.Description,
                                                valorReconhecido.CampoTemplate,
                                                valorReconhecido.TemplateName);

                    var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);

                    if (indexacao == null)
                    {
                        continue;
                    }

                    if (string.IsNullOrEmpty(indexacao.ValorFinal) == false || string.IsNullOrWhiteSpace(indexacao.ValorFinal) == false)
                    {
                        continue;
                    }

                    var listaDeCamposDataEmissaoDosBoletos = new List <int>()
                    {
                        Campo.CampoBoletoComAutenticDataEmissao,
                        Campo.CampoBoletoSemAutenticDataEmissao
                    };

                    ////tratamento especial para datas de emissao dos boletos
                    if (listaDeCamposDataEmissaoDosBoletos.Contains(campoDoDocumento.Id) && campoDoDocumento.PodeInserirPeloOcr && string.IsNullOrEmpty(valorReconhecido.Value) == false)
                    {
                        string dataEmissao;
                        if (this.ValidarDataEmissao(valorReconhecido.Value, out dataEmissao))
                        {
                            indexacao.PrimeiroValor = dataEmissao;
                            indexacao.ValorFinal    = dataEmissao;
                            indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.PrimeiroValor;
                            indexacao.OcrComplementou       = true;
                            indexacao.DataPrimeiraDigitacao = DateTime.Now;

                            this.gravaLogDocumentoServico.Executar(
                                LogDocumento.AcaoDocumentoOcr,
                                documento.Id,
                                string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", campoDoDocumento.Description, BatimentoFullText.LimitaString(dataEmissao.Trim(), 99)));
                            this.indexacaoRepositorio.Salvar(indexacao);

                            continue;
                        }
                    }

                    ////tratamento especial para campo de codigo de barras
                    if (indexacao.Campo.Id == Campo.CampoBoletoComAutenticCodBarras || indexacao.Campo.Id == Campo.CampoBoletoSemAutenticCodBarras)
                    {
                        string linhaDigitavelLimpa;
                        if (this.ExtrairNumerosDoCodigoDeBarras(valorReconhecido.Value, out linhaDigitavelLimpa))
                        {
                            indexacao.PrimeiroValor = linhaDigitavelLimpa;
                            indexacao.ValorFinal    = linhaDigitavelLimpa;
                            indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.PrimeiroValor;
                            indexacao.OcrComplementou       = true;
                            indexacao.DataPrimeiraDigitacao = DateTime.Now;

                            this.gravaLogDocumentoServico.Executar(
                                LogDocumento.AcaoDocumentoOcr,
                                documento.Id,
                                string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", campoDoDocumento.Description, BatimentoFullText.LimitaString(linhaDigitavelLimpa.Trim(), 99)));
                        }
                    }
                    else
                    {
                        if (indexacao.BateCom(valorReconhecido.Value))
                        {
                            indexacao.PrimeiroValor = indexacao.SegundoValor;
                            indexacao.ValorFinal    = indexacao.SegundoValor;
                            indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.SegundoValor;
                            indexacao.OcrComplementou       = true;
                            indexacao.DataPrimeiraDigitacao = DateTime.Now;

                            this.gravaLogDocumentoServico.Executar(
                                LogDocumento.AcaoDocumentoOcr,
                                documento.Id,
                                string.Format("Campo [{0}] complementado pelo ocr. Valor:[{1}]", campoDoDocumento.Description, BatimentoFullText.LimitaString(indexacao.SegundoValor.Trim(), 99)));
                        }
                        else
                        {
                            indexacao.PrimeiroValor         = string.Empty;
                            indexacao.ValorFinal            = string.Empty;
                            indexacao.DataPrimeiraDigitacao = DateTime.Now;
                        }
                    }

                    this.indexacaoRepositorio.Salvar(indexacao);
                }

                if (encontrouMapeamento == false)
                {
                    Log.Application.DebugFormat("ALERTA: campo {0} do template {1} não está mapeado para nenhum campo",
                                                valorReconhecido.CampoTemplate,
                                                valorReconhecido.TemplateName);
                }
            }

            ////batimento com fullTExt
            try
            {
                this.BaterUsandoFullText(documento, imagemReconhecida.Palavras);
            }
            catch (Exception exception)
            {
                Log.Application.Error(string.Format("Erro ao processar batimento full text de Atestado de Matricula - Documento #{0} ", documento.Id), exception);
            }
        }