public ResultadoCondicaoDeRegra Validar(Processo processo, Regra regra, RegraCondicional condicao)
{
var processadorBinarios = this.criadorDeProcessadorDeBinario.Obter(condicao.Binario);
if (processadorBinarios == null)
{
Log.Application.DebugFormat(
"Não foi encontrado processador do binario {0}",
condicao.Binario);
}
return(processadorBinarios.Processar(processo, regra, condicao));
}
private string ObterValorDoCampoDeComparacao(Processo processo, RegraCondicional condicao)
{
var tipoDado = TipoDado.Numeric;
var valorParaComparar = condicao.ObterValorParaComparar(processo);
var indexacaoParaComparar = condicao.ObterIndexacaoParaComparar(processo);
if (indexacaoParaComparar != null)
{
tipoDado = indexacaoParaComparar.Campo.TipoDado;
}
if (condicao.DeveAplicarFatorMatematico())
{
return(FatorMatematico.Aplicar(
valorParaComparar,
condicao.OperadorMatematico,
condicao.FatorMatematico,
tipoDado));
}
return(valorParaComparar);
}
private double CalcularSomatorioDeCampos(Processo processo, RegraCondicional condicao)
{
var total = 0.0;
foreach (var documento in processo.Documentos)
{
var indexacao = documento.Indexacao.FirstOrDefault(x => x.Campo == condicao.Campo);
if (indexacao == null)
{
continue;
}
var valorDoCampo = 0.0;
if (double.TryParse(indexacao.ObterValor(), out valorDoCampo))
{
total += valorDoCampo;
}
}
return(total);
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(condicao.ValorFixo));
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(processo.PossuiDocumentoDoTipo(condicao.TipoDocumento)));
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(this.CalcularQuantidadeDeDocumentos(processo, condicao)));
}
private double CalcularQuantidadeDeDocumentos(Processo processo, RegraCondicional condicao)
{
return(processo.Documentos.Count(x => x.TipoDocumento == condicao.TipoDocumento));
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(this.regraVioladaRepositorio
.ExistePorProcessoERegraEStatus(processo.Id, regra.Id, RegraVioladaStatus.Aprovada)));
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(this.CalcularSomatorioDeCampos(processo, condicao)));
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(processo.PossuiCampoComValorPreenchido(condicao.Campo)));
}
private bool AtendeComparacaoEntreValorDosCampos(Processo processo, RegraCondicional condicao)
{
//// TODO: Verificar quando o processo não possui um campo do tipo solicitado na regra
var valorPrincipal = condicao.ObterValor(processo);
var valorParaComparar = this.ObterValorDoCampoDeComparacao(processo, condicao);
////if (string.IsNullOrEmpty(valorParaComparar))
////{
//// return false;
////}
if (condicao.Conectivo == ConectivoDeComparacao.Menor)
{
return(this.criadorDeComparador
.CriaEncontrandoTipoDado(valorPrincipal)
.EhMenor(valorPrincipal, valorParaComparar));
}
if (condicao.Conectivo == ConectivoDeComparacao.Maior)
{
return(this.criadorDeComparador
.CriaEncontrandoTipoDado(valorPrincipal)
.EhMaior(valorPrincipal, valorParaComparar));
}
if (condicao.Conectivo == ConectivoDeComparacao.Igual)
{
return(this.criadorDeComparador
.CriaEncontrandoTipoDado(valorPrincipal)
.SaoIguais(valorPrincipal, valorParaComparar));
}
if (condicao.Conectivo == ConectivoDeComparacao.MenorOuIgual)
{
return(this.criadorDeComparador
.CriaEncontrandoTipoDado(valorPrincipal)
.EhMenorOuIgual(valorPrincipal, valorParaComparar));
}
if (condicao.Conectivo == ConectivoDeComparacao.MaiorOuIgual)
{
return(this.criadorDeComparador
.CriaEncontrandoTipoDado(valorPrincipal)
.EhMaiorOuIgual(valorPrincipal, valorParaComparar));
}
if (condicao.Conectivo == ConectivoDeComparacao.Diferente)
{
////TODO: Verificar forma melhor de fazer isso
if (condicao.Campo != null && condicao.Campo.TipoDado == TipoDado.CodigoDeBarras)
{
return(this.criadorDeComparador
.Cria(condicao.Campo.TipoDado)
.SaoIguais(valorPrincipal, valorParaComparar) == false);
}
return(this.criadorDeComparador
.CriaEncontrandoTipoDado(valorPrincipal)
.SaoIguais(valorPrincipal, valorParaComparar) == false);
}
if (condicao.Conectivo == ConectivoDeComparacao.In)
{
return(this.criadorDeComparador
.CriaEncontrandoTipoDado("TEXTO")
.Contem(valorPrincipal, valorParaComparar));
}
if (condicao.Conectivo == ConectivoDeComparacao.PrimeiroeUltimo)
{
return(this.criadorDeComparador
.Cria(TipoDado.PrimeiroEUltimo)
.SaoIguais(valorPrincipal, valorParaComparar));
}
return(false);
}
public ResultadoCondicaoDeRegra Processar(Processo processo, Regra regra, RegraCondicional condicao)
{
return(new ResultadoCondicaoDeRegra(this.AtendeComparacaoEntreValorDosCampos(processo, condicao)));
}
