private void SalvarIndice(Indexacao indexacao, string valor)
{
if (indexacao != null)
{
this.indexacaoRepositorio.AlterarPrimeiroValor(indexacao.Id, valor);
}
}
public void Salvar([FromBody] IEnumerable <IndexacaoViewModel> indexacaoModel)
{
var tipodocumentoId = indexacaoModel.First().TipoDocumentoId;
var tipoDocumento = this.tipoDocumentoRepositorio.ObterPorId(tipodocumentoId);
var documento = new Documento
{
Assunto = tipoDocumento.Nome,
Bloqueado = false,
DataCriacao = DateTime.Now,
EhIndice = false,
EhPreIndexacao = true,
SearchStatus = SearchStatus.ToIndex,
TipoDocumento = tipoDocumento,
Usuario = this.sessaoDoUsuario.UsuarioAtual
};
this.documentoRepositorio.Salvar(documento);
foreach (var index in indexacaoModel)
{
var indexacao = new Indexacao();
indexacao.Chave = new Chave {
Id = index.CampoId
};
indexacao.Documento = documento;
indexacao.Valor = index.Valor;
this.indexacaoRepositorio.Salvar(indexacao);
}
this.logarAcaoSistema.Execute(
TipoTrilha.Criacao,
"Preindexacao de documento",
"Documento foi criado #" + documento.Id);
}
public override bool EstaBatido(
Indexacao indexacao,
IList <PalavraReconhecida> palavrasReconhecidas)
{
if (this.PodeRealizarBatimento(indexacao) == false)
{
return(false);
}
var palavrasParaAnaliseFullTextFiliacao = this.batimentoFullText
.MontarListaFiliacaoCnh(palavrasReconhecidas);
var nomeDaMae = this.batimentoFullText
.ExtrairNomeMaeCompleto(palavrasParaAnaliseFullTextFiliacao);
var batido = this.batimentoFullText
.ComparaFiliacaoCnhPrimeiroEUltimo(indexacao, nomeDaMae);
if (batido == false)
{
if (this.proximaTentativa.NaoTemConteudo() == false)
{
batido = this.proximaTentativa
.EstaBatido(indexacao, palavrasReconhecidas);
}
}
return(batido);
}
public void SalvarIndexacao(Indexacao indexacao)
{
indexacao.OcrComplementou = true;
indexacao.ValorFinal = string.Empty;
this.indexacaoRepositorio.Salvar(indexacao);
}
protected override Indexacao ModificaIndexacaoDoCampoReconhecido(
Indexacao indexacao,
ValorReconhecido valorReconhecido,
IList <PalavraReconhecida> palavras)
{
if (this.EhCampoAgenciaOuConta(indexacao) || this.EhCampoPacoteServicos(indexacao))
{
if (indexacao.BateCom(this.ObterPrimeiroValor(valorReconhecido, indexacao.Campo)))
{
indexacao.PrimeiroValor = this.ObterPrimeiroValor(valorReconhecido, indexacao.Campo);
indexacao.OcrComplementou = true;
indexacao.DataPrimeiraDigitacao = DateTime.Now;
indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.NaoDefinido;
}
return(indexacao);
}
indexacao.PrimeiroValor = this.ObterPrimeiroValor(valorReconhecido, indexacao.Campo);
indexacao.OcrComplementou = true;
indexacao.DataPrimeiraDigitacao = DateTime.Now;
indexacao.ValorUtilizadoParaValorFinal = ValorUtilizadoParaValorFinal.NaoDefinido;
return(indexacao);
}
private void AdicionarIndexacao(Indexacao indexacaoDocumento)
{
if (indexacaoDocumento.NaoTemConteudo() == false)
{
this.indexacaoRepositorio.Salvar(indexacaoDocumento);
}
}
protected override Indexacao ModificaIndexacaoDoCampoReconhecido(
Indexacao indexacao,
ValorReconhecido valorReconhecido,
IList <PalavraReconhecida> palavras)
{
return(indexacao);
}
public void ExecutarFullText(Indexacao indexacao, List <dynamic> palavras)
{
new TaskFactory().StartNew(() =>
{
try
{
var palavra = string.Empty;
palavra = palavras.Aggregate(palavra,
(current, dynamic) => string.Concat(current, ",", dynamic.Texto));
var logBatimento = new LogBatimento
{
Indexacao = indexacao,
CampoEngine = "FullText",
ValorReconhecido = palavra,
};
this.unitOfWork.Transacionar(() => this.logBatimentoRepositorio.Salvar(logBatimento));
}
catch (Exception exception)
{
Log.Application.Error(exception);
}
});
}
public LogBatimento ObterPorIndexacao(Indexacao indexacao)
{
return(this.Session.QueryOver <LogBatimento>()
.Where(x => x.Indexacao == indexacao)
.List()
.FirstOrDefault());
}
public bool ComparaFiliacaoCnhPrimeiroEUltimo(Indexacao indexacao, string nomeDeFiliacao)
{
if (string.IsNullOrEmpty(nomeDeFiliacao) || indexacao == null)
{
return(false);
}
var listaNomesPrimeiroValor = Equivalencia.LimpaConteudoNome(indexacao.SegundoValor).Split(' ').ToList();
var listaNomesAchadosNoOcr = Equivalencia.LimpaConteudoNome(nomeDeFiliacao.Replace("0", "O")).Split(' ').ToList();
if (listaNomesPrimeiroValor.Count < 2 || listaNomesAchadosNoOcr.Count < 2)
{
return(false);
}
if (listaNomesPrimeiroValor[0].Equals(listaNomesAchadosNoOcr[0]))
{
if (listaNomesPrimeiroValor[listaNomesPrimeiroValor.Count - 1].Equals(listaNomesAchadosNoOcr[listaNomesAchadosNoOcr.Count - 1]))
{
return(true);
}
if (listaNomesAchadosNoOcr.Count > 2)
{
var nomeDeQuebraDeLinha = listaNomesAchadosNoOcr[listaNomesAchadosNoOcr.Count - 2] + listaNomesAchadosNoOcr[listaNomesAchadosNoOcr.Count - 1];
if (listaNomesPrimeiroValor[listaNomesPrimeiroValor.Count - 1].Equals(nomeDeQuebraDeLinha))
{
return(true);
}
}
}
return(false);
}
public void Salvar([FromBody] IEnumerable <IndexacaoViewModel> indexacaoModel)
{
int documentoId = 0;
foreach (var index in indexacaoModel)
{
var indexacao = new Indexacao();
indexacao.Chave = new Chave {
Id = index.CampoId
};
indexacao.Documento = new Documento {
Id = index.DocumentoId
};
indexacao.Valor = index.Valor;
documentoId = index.DocumentoId;
this.indexacaoRepositorio.Salvar(indexacao);
}
var documento = this.documentoRepositorio.ObterPorIdComTipoDocumentoEIndexacoes(documentoId);
this.indexEngine.Index(documento, documento.Indexacao);
this.documentoRepositorio.AlterStatus(documentoId, SearchStatus.Indexed);
this.logarAcaoSistema.Execute(
TipoTrilha.Criacao,
"Indexação de Documento",
"Documento foi indexado #" + documentoId);
}
private void ComplementarEndereco(Documento documento, Indexacao campoCep)
{
var endereco = this.ObterEndereco(campoCep);
if (endereco == null || endereco.Cep == 0)
{
return;
}
this.SalvarIndice(
documento.ObterIndexacao(Campo.ReferenciaDeArquivoEstadoDaResidenciaDoParticipante),
endereco.Estado.RemoveAcentuacao());
this.SalvarIndice(
documento.ObterIndexacao(Campo.ReferenciaDeArquivoCidadeDaResidenciaDoParticipante),
endereco.Cidade.RemoveAcentuacao());
this.SalvarIndice(
documento.ObterIndexacao(Campo.ReferenciaDeArquivoBairroDaResidenciaDoParticipante),
endereco.Bairro.RemoveAcentuacao());
this.SalvarIndice(
documento.ObterIndexacao(Campo.ReferenciaDeArquivoLogradouroDaResidenciaDoParticipante),
endereco.Logradouro.RemoveAcentuacao());
}
private void CriarNovoDocumentoInserindoPaginas(
IEnumerable <Pagina> paginasNovas,
string cpf,
Lote lote,
Processo processo,
string versao = "0",
int ordem = 0)
{
var tipoDocAtual = this.DefinirTipoDocumento(paginasNovas);
var novoDocumento = Documento.Novo(
tipoDocAtual,
cpf,
lote,
processo,
versao);
novoDocumento.Ordem = ordem;
this.documentoRepositorio.Salvar(novoDocumento);
if (tipoDocAtual.Id != TipoDocumento.CodigoNaoIdentificado)
{
this.gravaLogDoDocumentoServico.Executar(
LogDocumento.AcaoDocumentoReclassificadoPeloOcr,
novoDocumento.Id,
string.Format("Classificado pelo OCR. Tipo [{0}]", tipoDocAtual.Id));
}
if (Contexto.ManterPalavrasReconhecidas)
{
var palavrasOcr = this.ObterPalavrasOcr(paginasNovas);
if (string.IsNullOrEmpty(palavrasOcr) == false)
{
var indexPalavras = new Indexacao()
{
Campo = new Campo {
Id = Campo.CampoPalavrasOcr
},
PrimeiroValor = palavrasOcr,
Documento = novoDocumento,
DataPrimeiraDigitacao = DateTime.Now,
OcrComplementou = true
};
this.indexacaoRepositorio.Salvar(indexPalavras);
}
}
foreach (var novaPagina in paginasNovas)
{
if (novaPagina.EmBranco || novaPagina.Separadora)
{
novaPagina.Status = PaginaStatus.StatusExcluida;
}
novoDocumento.AdicionaPagina(novaPagina);
this.paginaRepositorio.Salvar(novaPagina);
}
Log.Application.DebugFormat("Paginas do documento #{0} salvas com sucesso", novoDocumento.Id);
}
private dynamic ObterEndereco(Indexacao campoCep)
{
if (campoCep == null || string.IsNullOrEmpty(campoCep.PrimeiroValor))
{
return(null);
}
return(this.cepRepositorio.ObterEndereco(campoCep.PrimeiroValor.ToInt()));
}
public override bool EstaBatido(
Indexacao indexacao,
IList <PalavraReconhecida> palavrasReconhecidas)
{
if (indexacao == null)
{
return(false);
}
if (string.IsNullOrEmpty(indexacao.SegundoValor))
{
return(false);
}
//// tamanho minimo da data para batimento
var valorCadastro = indexacao.SegundoValor.Trim().ToLower();
if (valorCadastro.Length < 8)
{
return(false);
}
for (int i = 0; i < palavrasReconhecidas.Count(); i++)
{
var palavraAtual = palavrasReconhecidas[i].Texto.Trim().ToLower();
if (!string.IsNullOrEmpty(palavraAtual))
{
if (palavraAtual == valorCadastro)
{
return(true);
}
//// checa se houve quebra de palavra no numero procurado (espaço no meio da data, por exemplo)
var incremento = 1;
while (palavraAtual.Length < valorCadastro.Length)
{
if (i + incremento < palavraAtual.Length - 1)
{
palavraAtual = palavraAtual + palavrasReconhecidas[i + incremento].Texto.ObterInteirosRegistroRg();
incremento++;
}
else
{
break;
}
}
if (palavraAtual.IndexOf(valorCadastro) >= 0)
{
return(true);
}
}
}
return(false);
}
private bool PodeAbreviarValorIndexacao(Indexacao indexacaoDocumentoComprovacao)
{
if (indexacaoDocumentoComprovacao.ValorFinal == null)
{
return(false);
}
return((indexacaoDocumentoComprovacao.EhCampoNomeDaMae() || indexacaoDocumentoComprovacao.EhCampoNomeDoPai()) &&
indexacaoDocumentoComprovacao.ValorFinal.Length > 30);
}
private string ObterTabelaDinamicaDoOrgaoDeDi(Indexacao indexacao)
{
var tiposDeDi = this.indexacaoRepositorio.ObterPorReferenciaDeArquivo(indexacao.Documento.Id, Campo.ReferenciaDeArquivoTipoDeDocumentoDeIdentificacao);
if (tiposDeDi.FirstOrDefault() == null || string.IsNullOrEmpty(tiposDeDi.FirstOrDefault().ObterValor()))
{
return(indexacao.Campo.TabelaDinamica());
}
return(string.Format("DOMINIO_{0}", tiposDeDi.FirstOrDefault().ObterValor().Trim()));
}
private void GravarLog(Indexacao indexacao, string valorNovo)
{
this.gravaLogDoDocumentoServico.Executar(
LogDocumento.AcaoDocumentoAlteracaoValorFinal,
indexacao.Documento.Id,
string.Format("Valor final do campo {0} foi alterado para {1}", indexacao.Id, valorNovo));
this.gravaLogDoProcessoServico.Executar(
LogProcesso.AcaoAlteracaoDeCampo,
indexacao.Documento.Processo,
string.Format("Valor final do campo {0} foi alterado na aprovação", indexacao.Id));
}
private void AdicionarIndexacao(Indexacao indexacaoDocumento)
{
if (indexacaoDocumento.NaoTemConteudo() == false)
{
Log.Application.InfoFormat(
"Inserindo segundo valor do campo {0}:{1}",
indexacaoDocumento.Campo.Id,
indexacaoDocumento.SegundoValor);
this.indexacaoRepositorio.Salvar(indexacaoDocumento);
}
}
private string ObterValorPorReferenciaArquivo(Indexacao indexacao, string referenciaArquivo)
{
var indexacaoConjuge = this.indexacaoRepositorio.ObterPorReferenciaDeArquivo(
indexacao.Documento.Id,
referenciaArquivo);
if (indexacaoConjuge.FirstOrDefault() != null)
{
return(indexacaoConjuge.FirstOrDefault().ObterValor().Trim());
}
return(string.Empty);
}
private bool ConteudoEncontradoValido(ref Indexacao indexacao, Campo campoAtual, ValorReconhecido valorReconhecido)
{
if (indexacao == null)
{
indexacao = new Indexacao()
{
PrimeiroValor = string.Empty,
Campo = campoAtual,
OcrComplementou = true,
UsuarioPrimeiroValor = -2
};
}
var defineTipo = this.AvaliarConteudoCampo(campoAtual);
var valorTratado = string.Empty;
switch (defineTipo)
{
case TipoCampoAnalisado.DataNascimento:
valorTratado = this.TratarCampoDataNascimento(valorReconhecido, indexacao.PrimeiroValor);
break;
case TipoCampoAnalisado.Nome:
valorTratado = this.TratarCampoNome(valorReconhecido);
break;
case TipoCampoAnalisado.CodigoNumerico:
valorTratado = this.TratarCampoCodigoNumerico(valorReconhecido);
break;
case TipoCampoAnalisado.Cpf:
valorTratado = this.TratarCampoCpf(valorReconhecido);
break;
case TipoCampoAnalisado.Indefinido:
valorTratado = string.Empty;
return(false);
default:
valorTratado = string.Empty;
return(false);
}
if (!string.IsNullOrEmpty(valorTratado))
{
indexacao.PrimeiroValor = valorTratado;
return(true);
}
return(false);
}
public void Executar(Documento documentoMestre, Indexacao indexacaoDocumentoComprovacao)
{
var mapeamentosCamposDocumentoComprovacao = this.camposValidacaoRepositorio
.ObterPorCampoDocumentoComprovacao(indexacaoDocumentoComprovacao.Campo);
if (mapeamentosCamposDocumentoComprovacao == null)
{
return;
}
foreach (var mapeamentoCamposDocumentoComprovacao in mapeamentosCamposDocumentoComprovacao)
{
var indexacaoDocumentoMestre = documentoMestre
.Indexacao
.FirstOrDefault(x => x.Campo == mapeamentoCamposDocumentoComprovacao.CampoDocumentoMestre);
if (indexacaoDocumentoMestre == null)
{
continue;
}
if (string.IsNullOrWhiteSpace(indexacaoDocumentoMestre.ValorFinal) == false &
string.IsNullOrEmpty(indexacaoDocumentoMestre.ValorFinal) == false)
{
continue;
}
if (this.PodeComplementarTitularComCertidaoCasamento(documentoMestre, indexacaoDocumentoMestre))
{
indexacaoDocumentoMestre = this.titularDocumentoMestreComCertidaoCasamento.Complementar(documentoMestre, indexacaoDocumentoMestre);
}
else
{
indexacaoDocumentoMestre.PrimeiroValor = indexacaoDocumentoComprovacao.ValorFinal;
if (this.PodeAbreviarValorIndexacao(indexacaoDocumentoComprovacao))
{
indexacaoDocumentoMestre.ValorFinal = Nome.AbreviarExcetoPrimeiroEUltimo(indexacaoDocumentoComprovacao.ValorFinal);
}
else
{
indexacaoDocumentoMestre.ValorFinal = indexacaoDocumentoComprovacao.ValorFinal;
}
}
indexacaoDocumentoMestre.ValorUtilizadoParaValorFinal = indexacaoDocumentoComprovacao.ValorUtilizadoParaValorFinal;
indexacaoDocumentoMestre.ValidacaoComplementou = true;
this.indexacaoRepositorio.Salvar(indexacaoDocumentoMestre);
}
}
private bool ValidarEstadoCivil(Indexacao indexacaoEstadoCivil, string valor)
{
if (DominioCampo.EstadoCivilObrigaConjuge(valor) && string.IsNullOrEmpty(this.ObterValorPorReferenciaArquivo(indexacaoEstadoCivil, Campo.ReferenciaDeArquivoNomeConjuge)))
{
throw new RegraDeNegocioException("O nome do conjuge é necessário.");
}
if (DominioCampo.EstadoCivilProibeConjuge(valor) && string.IsNullOrEmpty(this.ObterValorPorReferenciaArquivo(indexacaoEstadoCivil, Campo.ReferenciaDeArquivoNomeConjuge)) == false)
{
throw new RegraDeNegocioException("O nome do conjuge deve ser retirado.");
}
return(true);
}
private void ApagarValores(Indexacao indexacao)
{
this.indexacaoRepositorio.LimparValor1E2(indexacao.Id);
this.gravaLogDoDocumentoServico.Executar(
LogDocumento.AcaoDocumentoAlteracaoValorFinal,
indexacao.Documento.Id,
string.Format("Primeiro valor do campo {0} era [{1}] e foi excluído na aprovação", indexacao.Id, indexacao.PrimeiroValor));
this.gravaLogDoDocumentoServico.Executar(
LogDocumento.AcaoDocumentoAlteracaoValorFinal,
indexacao.Documento.Id,
string.Format("Segundo valor do campo {0} era [{1}] e foi excluído na aprovação", indexacao.Id, indexacao.SegundoValor));
}
private void AtualizarIndexacao(Indexacao indexacao, Indexacao indexacaoAntiga)
{
if (indexacaoAntiga == null || indexacaoAntiga.ValorFinalValido() == false || string.IsNullOrEmpty(indexacaoAntiga.ValorFinal))
{
return;
}
indexacao.PrimeiroValor = indexacaoAntiga.PrimeiroValor;
indexacao.UsuarioPrimeiroValor = Usuario.CodigoDoUsuarioSistema;
indexacao.ValorFinal = indexacaoAntiga.ValorFinal;
indexacao.ValorUtilizadoParaValorFinal = indexacaoAntiga.ValorUtilizadoParaValorFinal;
indexacao.ValorRecuperado = true;
}
private bool VerificaSeJaBateuCampoAtual(Indexacao index)
{
if (index == null)
{
return(false);
}
if (string.IsNullOrEmpty(index.PrimeiroValor))
{
return(false);
}
return(true);
}
public DetalhamentoDoDocumentoCampo Obter(Indexacao indexacao)
{
return(new DetalhamentoDoDocumentoCampo
{
IndexacaoId = indexacao.Id,
Campo = indexacao.Campo,
Valor1 = indexacao.PrimeiroValor,
Valor2 = indexacao.SegundoValor,
ValorOk = indexacao.ValorFinal,
Valor1Formatado = this.obtemCampoFormatadoServico.Obter(indexacao.Campo, indexacao.PrimeiroValor),
Valor2Formatado = this.obtemCampoFormatadoServico.Obter(indexacao.Campo, indexacao.SegundoValor),
ValorFormatado = this.obtemCampoFormatadoServico.Obter(indexacao.Campo, indexacao.ObterValor()),
DominioDeValores = this.obtemOpcoesDeValorDeIndexacaoServico.Obter(indexacao)
});
}
public bool CampoEstaBatido(Indexacao indexacao)
{
CampoBatido campoBatido = null;
foreach (CampoBatido campo in this.Campos)
{
if (campo.Indexacao == indexacao)
{
campoBatido = campo;
break;
}
}
return(campoBatido != null && campoBatido.Batido);
}
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);
}
}
public IList <DominioCampo> Obter(Indexacao indexacao)
{
var tabelaDinamica = indexacao.Campo.TabelaDinamica();
if (indexacao.Campo.ReferenciaArquivo == Campo.ReferenciaDeArquivoOrgaoEmissorDoDocumento)
{
tabelaDinamica = this.ObterTabelaDinamicaDoOrgaoDeDi(indexacao);
}
if (string.IsNullOrEmpty(tabelaDinamica))
{
return(null);
}
return(this.dominioCampoRepositorio.ObterDominiosPorCodigo(tabelaDinamica));
}
