internal static Expression GetExpression <T>(ParameterExpression param, FiltroExpresion filter)
{
MemberExpression member = Expression.Property(param, filter.NombrePropiedad);
ConstantExpression constant = Expression.Constant(Convert.ChangeType(filter.Valor, member.Type));
switch (filter.Operador)
{
case Operador.Igual:
return(Expression.Equal(member, constant));
case Operador.Mayor:
return(Expression.GreaterThan(member, constant));
case Operador.MayorIgual:
return(Expression.GreaterThanOrEqual(member, constant));
case Operador.Menor:
return(Expression.LessThan(member, constant));
case Operador.MenorIgual:
return(Expression.LessThanOrEqual(member, constant));
case Operador.Diferente:
return(Expression.NotEqual(member, constant));
case Operador.Contiene:
return(Expression.Call(member, containsMethod, constant));
case Operador.IniciaCon:
return(Expression.Call(member, startsWithMethod, constant));
case Operador.TerminaCon:
return(Expression.Call(member, endsWithMethod, constant));
case Operador.IgualQue:
return(Expression.Call(member, equalsMethod, constant));
default:
return(null);
}
}
private static ExprContrato GeneraPredicadoContrato(ReglaEntradaContrato regla, out List <MensajeConfiguracionRegla> listaMensajes)
{
listaMensajes = new List <MensajeConfiguracionRegla>();
ExprContrato predicado = ConstructorPredicado.True <Contrato>();
if (regla.IsNull())
{
return(predicado);
}
if (regla.Region.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.Region.Contains(contrato.Region, StringComparison.InvariantCultureIgnoreCase);
predicado = predicado.And(criterio);
}
if (regla.Producto.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.Producto.Contains(contrato.Producto, StringComparison.InvariantCultureIgnoreCase);
predicado = predicado.And(criterio);
}
if (regla.CodigoEstado.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.CodigoEstado.Contains(contrato.CodigoEstado);
predicado = predicado.And(criterio);
}
if (regla.CodigoPlan.IsNotNullOrEmpty())
{
var nombrePropiedad = "CodigoPlan";
var filtros = new List <FiltroExpresion>();
foreach (var codigo in regla.CodigoPlan)
{
var valor = ExpresionRegular.EliminarComodin(codigo);
if (valor.IsNullOrEmpty())
{
continue;
}
var filtro = new FiltroExpresion
{
NombrePropiedad = nombrePropiedad,
Valor = valor
};
if (codigo.StartsWith("*") && codigo.EndsWith("*"))
{
filtro.Operador = Operador.Contiene;
}
else if (codigo.StartsWith("*"))
{
filtro.Operador = Operador.TerminaCon;
}
else if (codigo.EndsWith("*"))
{
filtro.Operador = Operador.IniciaCon;
}
else if (codigo.Trim().IsNotNullOrEmpty())
{
filtro.Operador = Operador.IgualQue;
}
filtros.Add(filtro);
}
ExprContrato exprOr = ConstruirArbolExpresionOr <Contrato>(filtros);
if (exprOr.IsNull())
{
listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
return(null);
}
predicado = predicado.And(exprOr);
}
if (regla.Version.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.Version.Contains(contrato.Version);
predicado = predicado.And(criterio);
}
if (regla.CoberturaMaxima.IsNotNullOrEmpty())
{
var nombrePropiedad = "CoberturaMaxima";
var expresionLogica = new ExpresionLogica(regla.CoberturaMaxima);
if (!expresionLogica.EsExpresionLogica)
{
listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.CoberturaMaxima));
return(null);
}
expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();
ExprContrato exprAnd = ConstruirArbolExpresionAnd <Contrato>(expresionLogica.Proposiciones);
if (exprAnd.IsNull())
{
listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
return(null);
}
predicado = predicado.And(exprAnd);
}
if (regla.Nivel.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.Nivel.Contains(contrato.Nivel);
predicado = predicado.And(criterio);
}
if (regla.DeducibleTotal.IsNotNullOrEmpty())
{
var nombrePropiedad = "DeducibleTotal";
var expresionLogica = new ExpresionLogica(regla.DeducibleTotal);
if (!expresionLogica.EsExpresionLogica)
{
listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorExpresionLogica(nombrePropiedad, regla.DeducibleTotal));
return(null);
}
expresionLogica.Proposiciones.Select(x => { x.NombrePropiedad = nombrePropiedad; return(x); }).ToList();
ExprContrato exprAnd = ConstruirArbolExpresionAnd <Contrato>(expresionLogica.Proposiciones);
if (exprAnd.IsNull())
{
listaMensajes.Add(CrearMensajeConfiguracionRegla.ObtenerMensajeErrorParametro(nombrePropiedad));
return(null);
}
predicado = predicado.And(exprAnd);
}
if (regla.TieneImpedimento.IsNotNull())
{
ExprContrato criterio = contrato => contrato.TieneImpedimento == regla.TieneImpedimento;
predicado = predicado.And(criterio);
}
if (regla.EsMoroso.IsNotNull())
{
ExprContrato criterio = contrato => contrato.EsMoroso == regla.EsMoroso;
predicado = predicado.And(criterio);
}
if (regla.NumeroEmpresa.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.NumeroEmpresa.Contains(contrato.NumeroEmpresa);
predicado = predicado.And(criterio);
}
if (regla.CodigoSucursal.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.CodigoSucursal.Contains(contrato.CodigoSucursal);
predicado = predicado.And(criterio);
}
if (regla.NumeroLista.IsNotNullOrEmpty())
{
ExprContrato criterio = contrato => regla.NumeroLista.Contains(contrato.NumeroLista);
predicado = predicado.And(criterio);
}
if (regla.EsDeducibleAnual.IsNotNull())
{
ExprContrato criterio = contrato => contrato.EsDeducibleAnual == regla.EsDeducibleAnual;
predicado = predicado.And(criterio);
}
if (regla.EsVigente.IsNotNull())
{
if (regla.EsVigente.Value)
{
ExprContrato criterio = contrato => contrato.FechaVigencia > DateTime.Now.Date;
predicado = predicado.And(criterio);
}
else
{
ExprContrato criterio = contrato => contrato.FechaVigencia <= DateTime.Now.Date;
predicado = predicado.And(criterio);
}
}
return(predicado);
}