public void Execute(Documento documento, ImagemReconhecida imagemReconhecida)
{
if (!this.PodeFazerClassificacao(documento.TipoDocumento))
{
return;
}
//// verifica se o OCR reconheceu o tipo do documento.
var valorReconhecidoTipo = imagemReconhecida.ValoresReconhecidos.FirstOrDefault(x => x.CampoTemplate.ToLower() == "tipo");
if (valorReconhecidoTipo == null || string.IsNullOrEmpty(valorReconhecidoTipo.Value))
{
return;
}
Log.Application.InfoFormat("Tentativa de classificação do documento {0}", documento.Id);
//// carregar tags e montar listas para cada tipo
int tipoDocumentoId = this.DefinirTipoPorTags(valorReconhecidoTipo.Value);
if (tipoDocumentoId != TipoDocumento.CodigoNaoIdentificado)
{
documento.TipoDocumento = this.tipoDocumentoRepositorio.ObterPorCodigo(tipoDocumentoId);
this.documentoRepositorio.Salvar(documento);
this.gravaLogDocumentoServico.Executar(
LogDocumento.AcaoDocumentoOcr,
documento.Id,
string.Format("Documento reclassificado para [{0}] pelo OCR.", tipoDocumentoId));
Log.Application.InfoFormat("Documento [{0}] reclassificado para [{1}] pelo OCR.", documento.Id, tipoDocumentoId);
}
}
public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, ResultadoBatimentoDocumento resultadoBatimento)
{
Log.Application.InfoFormat("Inicio do batimento do documento {0}", documento.Id);
if (this.TipoPodeFazerBatimento(documento.TipoDocumento))
{
return;
}
switch (documento.TipoDocumento.Id)
{
////Por enquanto, no projeto Banco Original, não há necessidade de analisar por tipo de doc.
////case TipoDocumento.CodigoComprovanteDeResidencia:
//// this.batimentoEComplementacaoDocumentoServico =
//// IoC.Current.Resolve<BatimentoEComplementacaoComprovanteResidenciaServico>();
//// break;
default:
this.batimentoEComplementacaoDocumentoServico =
IoC.Current.Resolve <BatimentoEComplementacaoDocumentoServico>();
break;
}
var camposJaBatidosId = (from x in resultadoBatimento.Campos where x.Batido select x.Indexacao.Campo.Id).ToList();
this.batimentoEComplementacaoDocumentoServico.Execute(documento, imagemReconhecida, camposJaBatidosId);
this.documentoRepositorio.Salvar(documento);
}
protected virtual bool PodeComplementarIndexacao(Documento documento, ImagemReconhecida imagemReconhecida)
{
if (imagemReconhecida == null)
{
return(false);
}
var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;
if (valoresReconhecidos == null)
{
return(false);
}
var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);
if (camposDoDocumento == null)
{
return(false);
}
if (camposDoDocumento.Count == 0)
{
return(false);
}
return(true);
}
public ResultadoBatimentoDocumento Iniciar(
Documento documento,
ImagemReconhecida imagemReconhecida)
{
IBatimentoDocumento batimentoDocumento = IoC
.Current
.Resolve <BatimentoDocumento <QualquerDocumentoBatimento> >();
//// batimento por campos (RECVALUE)
var resultadoBatimento = batimentoDocumento.Entre(documento, imagemReconhecida);
var camposNaoBatidos = resultadoBatimento
.Campos
.Where(x => x.Batido == false)
.ToList();
//// batimento por fulltext (PALAVRARECONHECIDA ou REDIS)
resultadoBatimento = this.RealizarBatimentoPorCampoNaoBatido(
imagemReconhecida,
resultadoBatimento,
camposNaoBatidos);
var resultadoBatimentoValidade = this.validarResultadoBatimento
.ValidarNumeroDocumentoIdentificacao(resultadoBatimento, documento);
return(resultadoBatimentoValidade);
}
public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
{
if (imagemReconhecida == null)
{
return;
}
var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;
if (valoresReconhecidos == null || valoresReconhecidos.Count == 0)
{
return;
}
var camposDoDocumento = this.campoRepositorio
.ObterPorTipoDocumento(documento.TipoDocumento);
foreach (var campoDoDocumento in camposDoDocumento)
{
var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);
if (!campoDoDocumento.PodeInserirPeloOcr)
{
continue;
}
if (indexacao == null)
{
indexacao = new Indexacao
{
Campo = campoDoDocumento,
Documento = documento,
};
documento.Indexacao.Add(indexacao);
}
else
{
//// ja possui indexacao cadastrada, verificar se ja tem conteudo
if (!string.IsNullOrEmpty(indexacao.PrimeiroValor))
{
continue;
}
}
this.SalvarIndexacaoSemComparacao(indexacao, valoresReconhecidos);
}
}
private ResultadoBatimentoDocumento RealizarBatimentoPorCampoNaoBatido(
ImagemReconhecida imagemReconhecida,
ResultadoBatimentoDocumento resultadoBatimento,
List <CampoBatido> camposNaoBatidos)
{
foreach (var campoNaoBatido in camposNaoBatidos)
{
var batimentoCampo = this.batimentoCampoFactory.Criar(campoNaoBatido.Indexacao);
var resultadoDoCampo = batimentoCampo.Entre(campoNaoBatido.Indexacao, imagemReconhecida.Palavras);
resultadoBatimento.AdicionarOuEditar(resultadoDoCampo);
}
return(resultadoBatimento);
}
public bool Verificar(string palavra, ImagemReconhecida imagemReconhecida)
{
var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;
palavra = palavra.ToUpper() + " ";
foreach (var valorReconhecido in valoresReconhecidos.Where(x => string.IsNullOrEmpty(x.Value) == false))
{
var textoReconhecido = valorReconhecido.Value.ToUpper() + " ";
if (textoReconhecido.IndexOf(palavra, System.StringComparison.Ordinal) > 0)
{
return(true);
}
}
return(this.batimentoFullText.Batido(palavra, imagemReconhecida.Palavras));
}
protected override bool PodeComplementarIndexacao(
Documento documento,
ImagemReconhecida imagemReconhecida)
{
var camposDoDocumento = this.campoRepositorio
.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);
if (camposDoDocumento == null)
{
return(false);
}
if (camposDoDocumento.Count == 0)
{
return(false);
}
return(true);
}
public ImagemReconhecida Obter(Documento documento)
{
var imagemReconhecida = new ImagemReconhecida
{
ValoresReconhecidos = this.valorReconhecidoRepositorio.ObtemPorDocumento(documento.Id)
};
if ((documento.TipoDocumento.Id == TipoDocumento.CodigoDocumentoGeral || documento.EhPac) == false)
{
if (Contexto.UsarBatimentoAntigo)
{
imagemReconhecida.Palavras = this.palavraReconhecidaRepositorio
.ObterPorDocumentoId(documento.Id);
}
else
{
imagemReconhecida.Palavras = this.palavraReconhecidaStorage.Obter(documento.Id);
}
}
return(imagemReconhecida);
}
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);
}
}
}
public ResultadoBatimentoDocumento Entre(Documento documento, ImagemReconhecida imagemReconhecida)
{
var indexacoesMapeadas = this.indexacaoMapeada.ComValoresReconhecidos(
documento.Indexacao.ToList(),
imagemReconhecida.ValoresReconhecidos);
var resultadoBatimento = new ResultadoBatimentoDocumento();
var batimento = IoC.Current.Resolve(typeof(TBatimentoIndexacaoMapeada));
var batimentoResidencia = ((IBatimentoIndexacaoMapeada)batimento)
.ProximaTentativa(IoC.Current.Resolve <ComprovanteResidenciaConsultaCepBatimento>());
////Caso haja a necessidade de incluir mais classes de batimento pode-se hierarquizar como abaixo:
//// var batimentoRg = ((IBatimentoIndexacaoMapeada)batimento)
//// .ProximaTentativa(IoC.Current.Resolve<RgBatimento>());
////
//// var batimentoRgReceita = ((IBatimentoIndexacaoMapeada)batimento)
//// .ProximaTentativa(IoC.Current.Resolve<RgConsultaReceitaBatimento>());
foreach (var mapeada in indexacoesMapeadas)
{
var batido = ((IBatimentoIndexacaoMapeada)batimento).EstaBatido(mapeada);
var campoBatido = new CampoBatido
{
Indexacao = mapeada.Indexacao,
Batido = batido,
TipoBatimento = TipoBatimento.Template
};
resultadoBatimento.AdicionarOuEditar(campoBatido);
}
return(resultadoBatimento);
}
//// 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 virtual void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
{
if (this.PodeComplementarIndexacao(documento, imagemReconhecida) == false)
{
return;
}
var camposDoDocumento = this.campoRepositorio
.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id)
.OrderBy(campo => campo.PodeInserirPeloOcr);
foreach (var campoDoDocumento in camposDoDocumento)
{
var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);
var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;
if (this.ExistemValoresReconhecidos(valoresReconhecidos) == false)
{
if (this.CampoPodeSerInseridoMesmoQuandoNaoHaReconhecimento(indexacao, campoDoDocumento))
{
indexacao = this.AdicionaNovaIndexacaoParaCampoReconhecido(
documento,
null,
campoDoDocumento);
this.gravaLogDocumentoServico.Executar(
LogDocumento.AcaoDocumentoOcr,
documento.Id,
string.Format("Campo [{0}] inserido pelo ocr.", campoDoDocumento.Description));
this.indexacaoRepositorio.Salvar(indexacao);
}
continue;
}
foreach (var valorReconhecido in valoresReconhecidos)
{
if (string.IsNullOrEmpty(valorReconhecido.Value))
{
continue;
}
if (campoDoDocumento.EstaMapeadoPara(valorReconhecido.CampoTemplate, valorReconhecido.TemplateName) == false)
{
continue;
}
indexacao = this.AlterarIndexacao(
documento,
valorReconhecido,
campoDoDocumento,
indexacao,
imagemReconhecida.Palavras);
if (indexacao != null)
{
Log.Application.DebugFormat(
"BatimentoEComplementacaoDocumentoBase::Salvou indexacao?? Documento {0} Indexacao {1}",
indexacao.Documento.Id,
indexacao.Id);
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);
}
}
}
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);
}
}
public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
{
if (imagemReconhecida == null)
{
return;
}
var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;
if (valoresReconhecidos == null)
{
return;
}
var codigoDoTipoDoDocumento = this.ObterCodigoTipoDocumentoApartirValoresReconhecidos(valoresReconhecidos);
if (this.CodigoEhValido(codigoDoTipoDoDocumento) == false)
{
this.gravaLogDocumentoServico.Executar(
LogDocumento.AcaoDocumentoOcr,
documento.Id,
"Não foi possivel reclassificar documento 'Não Identificado' no OCR.");
Log.Application.InfoFormat("Tentiva de reclassificação do Documento #{0} falhou.", documento.Id);
return;
}
TipoDocumento novoTipoDocumento;
var cpfDocumento = documento
.Indexacao
.Where(x => x.Campo.ReferenciaArquivo == Campo.ReferenciaDeArquivoCpf);
var documentosDoParticipante = this.documentoRepositorio
.ObterDocumentosDoProcessoComCpf(
documento.Processo.Id,
cpfDocumento.ElementAt(0).ObterValor());
////if (codigoDoTipoDoDocumento == TipoDocumento.CodigoCn)
////{
//// if (this.JaPossuiDocumentoIdentificacao(documentosDoParticipante))
//// {
//// novoTipoDocumento = this.tipoDocumentoRepositorio.ObterPorCodigo(TipoDocumento.CodigoDocumentoGeral);
//// documento.TipoDocumento = novoTipoDocumento;
//// this.alteraIndexacaoServico.Alterar(documento, novoTipoDocumento);
//// this.gravaLogDocumentoServico.Executar(
//// LogDocumento.AcaoDocumentoOcr,
//// documento.Id,
//// "Documento classificado como [Documento Geral]. Documento foi reconhecido como Certidão de nascimento e já existe um documento de identificação na conta");
//// return;
//// }
////}
if (this.JaPossuiDocumentoIdentificacao(documentosDoParticipante) == false)
{
this.gravaLogDocumentoServico.Executar(
LogDocumento.AcaoDocumentoOcr,
documento.Id,
"Documento não foi reclassificado. Não existe documento de identificação para este participamente");
return;
}
novoTipoDocumento = this.tipoDocumentoRepositorio.ObterPorCodigo(codigoDoTipoDoDocumento);
documento.TipoDocumento = novoTipoDocumento;
this.alteraIndexacaoServico.Alterar(documento, novoTipoDocumento);
this.gravaLogDocumentoServico.Executar(
LogDocumento.AcaoDocumentoOcr,
documento.Id,
string.Format("Documento reclassificado para [{0}] pelo OCR.", novoTipoDocumento.Description));
Log.Application.InfoFormat("Documento #{0} reclassificado pelo OCR para tipo #{1}", documento.Id, codigoDoTipoDoDocumento);
}
public void Execute(Documento documento, ImagemReconhecida imagemReconhecida, List <int> camposBatidosId = null)
{
if (imagemReconhecida == null)
{
return;
}
var valoresReconhecidos = imagemReconhecida.ValoresReconhecidos;
var camposDoDocumento = this.campoRepositorio.ObterPorTipoDocumentoComMapeamentoOcr(documento.TipoDocumento.Id);
foreach (var campoDoDocumento in camposDoDocumento)
{
var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == campoDoDocumento);
var deveInserir = false;
if (indexacao == null)
{
if (campoDoDocumento.PodeInserirPeloOcr)
{
deveInserir = true;
}
else
{
continue;
}
}
if (deveInserir)
{
indexacao = new Indexacao()
{
Campo = campoDoDocumento,
Documento = documento,
OcrComplementou = true,
DataPrimeiraDigitacao = DateTime.Now,
UsuarioPrimeiroValor = -2
};
documento.Indexacao.Add(indexacao);
this.SalvarIndexacaoSemComparacao(indexacao, valoresReconhecidos);
}
else
{
//// tratamento para validação de código de barras: se campo estiver mapeado e for um codigo válido, pode inserir o que o OCR achou!
foreach (var valorReconhecido in valoresReconhecidos)
{
if (campoDoDocumento.EstaMapeadoPara(valorReconhecido.CampoTemplate, valorReconhecido.TemplateName) == false)
{
continue;
}
try
{
string linhaDigitavelLimpa;
if (this.ExtrairNumerosDoCodigoDeBarras(valorReconhecido.Value, out linhaDigitavelLimpa))
{
indexacao.Campo = campoDoDocumento;
indexacao.Documento = documento;
indexacao.OcrComplementou = true;
indexacao.DataPrimeiraDigitacao = DateTime.Now;
indexacao.UsuarioPrimeiroValor = -2;
this.SalvarIndexacao(indexacao, linhaDigitavelLimpa);
break;
}
}
catch (Exception exception)
{
Log.Application.Error(string.Format("Erro ao processar batimento de Código de Barras de Comprovante Pagto - Documento #{0} ", documento.Id), exception);
}
}
}
}
}
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);
}
}
