public FilterStatement(string propertyId, eBooleanOperatorType operation, Enum value, Enum value2 = default(Enum), eLogicOperatorType connector = eLogicOperatorType.And)
{
PropertyName = propertyId;
LogicOperator = connector;
BooleanOperator = operation;
Value = value;
Value2 = value2;
TypeGroups = new Dictionary <TypeGroup, HashSet <Type> >
{
{ TypeGroup.Text, new HashSet <Type> {
typeof(string), typeof(char)
} },
{ TypeGroup.Number, new HashSet <Type> {
typeof(int), typeof(uint), typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(long), typeof(ulong), typeof(Single), typeof(double), typeof(decimal)
} },
{ TypeGroup.Boolean, new HashSet <Type> {
typeof(bool)
} },
{ TypeGroup.Date, new HashSet <Type> {
typeof(DateTime)
} },
{ TypeGroup.Nullable, new HashSet <Type> {
typeof(Nullable <>)
} }
};
Validate();
}
public FilterStatement(string propertyId, eBooleanOperatorType operation, TPropertyType value, TPropertyType value2 = default(TPropertyType), eLogicOperatorType connector = eLogicOperatorType.And)
{
PropertyName = propertyId;
LogicOperator = connector;
BooleanOperator = operation;
if (typeof(TPropertyType).IsArray)
{
if (operation != eBooleanOperatorType.Contains && operation != eBooleanOperatorType.In)
{
throw new ArgumentException("Only 'Operacao.Contains' and 'Operacao.In' support arrays as parameters.");
}
var listType = typeof(List <>);
var constructedListType = listType.MakeGenericType(typeof(TPropertyType).GetElementType());
Value = value != null?Activator.CreateInstance(constructedListType, value) : null;
Value2 = value2 != null?Activator.CreateInstance(constructedListType, value2) : null;
}
else
{
Value = value;
Value2 = value2;
}
TypeGroups = new Dictionary <TypeGroup, HashSet <Type> >
{
{ TypeGroup.Text, new HashSet <Type> {
typeof(string), typeof(char)
} },
{ TypeGroup.Number, new HashSet <Type> {
typeof(int), typeof(uint), typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(long), typeof(ulong), typeof(Single), typeof(double), typeof(decimal)
} },
{ TypeGroup.Boolean, new HashSet <Type> {
typeof(bool)
} },
{ TypeGroup.Date, new HashSet <Type> {
typeof(DateTime)
} },
{ TypeGroup.Nullable, new HashSet <Type> {
typeof(Nullable <>)
} }
};
Validate();
}
public static Filter <T> CreateFilters <T>(List <EntityFilter> valFilter) where T : class
{
var filter = new Filter <T>();
T valInstace = Activator.CreateInstance <T>();
PropertyInfo[] vProperties = valInstace.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
foreach (EntityFilter item in valFilter)
{
var vProperty = vProperties.FirstOrDefault(p => p.Name.Equals(item.PropertyName, StringComparison.CurrentCultureIgnoreCase));
eBooleanOperatorType vBooleanOperatorType = (eBooleanOperatorType)Enum.Parse(typeof(eBooleanOperatorType), item.BooleanOperator);
eLogicOperatorType vLogicOperatorType = (eLogicOperatorType)Enum.Parse(typeof(eLogicOperatorType), item.LogicOperator);
object vValue1 = item.Value1;
object vValue2 = item.Value2;
GetValue(vProperty, item, vBooleanOperatorType, ref vValue1, ref vValue2);
filter.Add(item.PropertyName, vBooleanOperatorType, vLogicOperatorType, vValue1, vValue2);
}
return(filter);
}
private Expression CombineExpressions(Expression expr1, Expression expr2, eLogicOperatorType connector)
{
return(connector == eLogicOperatorType.And ? Expression.AndAlso(expr1, expr2) : Expression.OrElse(expr1, expr2));
}
public void Add <TPropertyType>(string valPropertyName, eBooleanOperatorType valBooleanOperator, eLogicOperatorType valLogicOperator, TPropertyType value, TPropertyType value2)
{
IFilterStatement statement = new FilterStatement <TPropertyType>(valPropertyName, valBooleanOperator, value, value2, valLogicOperator);
_Statements.Add(statement);
}
public void Add <TPropertyType>(string valPropertyName, eBooleanOperatorType valBooleanOperator, eLogicOperatorType valLogicOperator, TPropertyType value)
{
Add <TPropertyType>(valPropertyName, valBooleanOperator, valLogicOperator, value, default(TPropertyType));
}
