public static IQueryable Where(this IQueryable query, string path, ConditionOperators conditionOperator, object value,
QueryConvertStrategy convertStrategy = QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
QueryCollectionHandling collectionHandling = QueryCollectionHandling.Any, StringComparison?stringComparision = null)
{
query = query.Query(qb => qb.Compare(path, conditionOperator, value, convertStrategy: convertStrategy, collectionHandling: collectionHandling, stringComparision: stringComparision));
return(query);
}
/// <summary>
/// Adds a WHERE condition to the current query
/// </summary>
/// <param name="text">Text of WHERE condition</param>
/// <param name="op">Logical operator joining this condition with previous one</param>
public void AddCondition(string text, ConditionOperators op)
{
_conditions.Add(new ConditionInfo()
{
Text = text, Operator = op
});
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="question"></param>
/// <param name="condition"></param>
/// <param name="boolOp"></param>
public ConditionEvaluator(
IQuestion <TAnswer> question,
ICondition <TAnswer> condition,
ConditionOperators boolOp = ConditionOperators.And)
{
Question = question;
Condition = condition;
Operator = boolOp;
}
public virtual WhereBuilder Compare(string path, ConditionOperators conditionOperators, object value,
QueryConvertStrategy convertStrategy = QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
bool and = true, QueryCollectionHandling collectionHandling = QueryCollectionHandling.Any, StringComparison?stringComparision = null)
{
Filters.Add(new WhereBuilderCondition
{
And = and,
ConditionOperator = conditionOperators,
Path = path,
Value = value,
ConvertStrategy = convertStrategy,
CollectionHandling = collectionHandling,
StringComparisation = stringComparision
});
return(this);
}
public static IEnumerable <T> Where <T>(this IEnumerable <T> list, string path, ConditionOperators conditionOperator, object value,
QueryConvertStrategy convertStrategy = QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
QueryCollectionHandling collectionHandling = QueryCollectionHandling.Any, StringComparison?stringComparision = null)
=> list.AsQueryable().Where(path, conditionOperator, value, convertStrategy: convertStrategy, collectionHandling: collectionHandling, stringComparision: stringComparision);
private static bool IsOperatorMatching(ConditionOperators conditionOperator, object value, string valueToCompare)
{
decimal actValue;
decimal refValue;
string strValue = value.ToStringOrEmpty();
valueToCompare = valueToCompare.ToStringOrEmpty();
switch (conditionOperator)
{
case ConditionOperators.RegEx:
if (valueToCompare != null)
{
var regex = new Regex(valueToCompare);
if (regex.IsMatch(strValue))
{
return(true);
}
}
break;
case ConditionOperators.StartsWith:
if (strValue.StartsWith(valueToCompare))
{
return(true);
}
break;
case ConditionOperators.EndsWith:
if (strValue.EndsWith(valueToCompare))
{
return(true);
}
break;
case ConditionOperators.NotEquals:
if (!strValue.Equals(valueToCompare))
{
return(true);
}
break;
case ConditionOperators.Equals:
if (strValue.Equals(valueToCompare))
{
return(true);
}
break;
case ConditionOperators.IsNull:
if (string.IsNullOrEmpty(strValue))
{
return(true);
}
break;
case ConditionOperators.IsNotNull:
if (!string.IsNullOrEmpty(strValue))
{
return(true);
}
break;
case ConditionOperators.Contains:
if (strValue.Contains(valueToCompare))
{
return(true);
}
break;
case ConditionOperators.NotContains:
if (!strValue.Contains(valueToCompare))
{
return(true);
}
break;
case ConditionOperators.Lower:
if (decimal.TryParse(strValue, out actValue) && decimal.TryParse(valueToCompare, out refValue) && actValue < refValue)
{
return(true);
}
break;
case ConditionOperators.Greater:
if (decimal.TryParse(strValue, out actValue) && decimal.TryParse(valueToCompare, out refValue) && actValue > refValue)
{
return(true);
}
break;
case ConditionOperators.IsIn:
var splitValues = valueToCompare.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
if (splitValues != null)
{
foreach (var c in splitValues)
{
if (strValue.Equals(c))
{
return(true);
}
}
}
return(false);
case ConditionOperators.Like:
return(FileUtil.MatchesWildcard(strValue, valueToCompare));
default:
if (Equals(strValue, valueToCompare))
{
return(true);
}
break;
}
return(false);
}
public bool CheckRequestValueIsInRangeConditionValue(ConditionOperators conditionOperators, string conditionValue, int requestValue)
{
bool isInRange = false;
int conditionVal = 0;
switch (conditionOperators)
{
case ConditionOperators.Equal:
conditionVal = int.Parse(conditionValue, CultureInfo.InvariantCulture);
if (requestValue == conditionVal || conditionVal == 0)
{
isInRange = true;
}
break;
case ConditionOperators.NotEqual:
conditionVal = int.Parse(conditionValue, CultureInfo.InvariantCulture);
if (requestValue != conditionVal || conditionVal == 0)
{
isInRange = true;
}
break;
case ConditionOperators.GreaterThan:
conditionVal = int.Parse(conditionValue, CultureInfo.InvariantCulture);
if (requestValue > conditionVal || conditionVal == 0)
{
isInRange = true;
}
break;
case ConditionOperators.GreaterThanOrEqual:
conditionVal = int.Parse(conditionValue, CultureInfo.InvariantCulture);
if (requestValue >= conditionVal || conditionVal == 0)
{
isInRange = true;
}
break;
case ConditionOperators.LessThan:
conditionVal = int.Parse(conditionValue, CultureInfo.InvariantCulture);
if (requestValue < conditionVal || conditionVal == 0)
{
isInRange = true;
}
break;
case ConditionOperators.LessThanOrEqual:
conditionVal = int.Parse(conditionValue, CultureInfo.InvariantCulture);
if (requestValue <= conditionVal || conditionVal == 0)
{
isInRange = true;
}
break;
case ConditionOperators.Between:
string[] conditionValueParts = conditionValue.Split(new char[] { ',' });
if (conditionValueParts.Length == 2 && (requestValue >= int.Parse(conditionValueParts[0], CultureInfo.InvariantCulture) && requestValue <= int.Parse(conditionValueParts[1], CultureInfo.InvariantCulture)) || (int.Parse(conditionValueParts[0], CultureInfo.InvariantCulture) == 0 && (int.Parse(conditionValueParts[1], CultureInfo.InvariantCulture) == 0)))
{
isInRange = true;
}
break;
default:
break;
}
return(isInRange);
}
private bool CheckRequestValueAppliedFlowConditionValue(ManagerFlowCondition managerFlowCondition, Request request)
{
bool isAppliedFlowConditionValue = false;
if (managerFlowCondition != null)
{
ConditionOperators conditionOperator = (ConditionOperators)managerFlowCondition.Operator;
Precard precard = managerFlowCondition.PrecardAccessGroupDetail.Precard;
PrecardGroupsName precardGroupsName = (PrecardGroupsName)managerFlowCondition.PrecardAccessGroupDetail.Precard.PrecardGroup.IntLookupKey;
int requestValue = 0;
switch (precardGroupsName)
{
case PrecardGroupsName.leave:
case PrecardGroupsName.leaveestelajy:
case PrecardGroupsName.duty:
if (precard.IsHourly)
{
requestValue = request.TimeDuration;
}
else
if (precard.IsDaily)
{
requestValue = (int)(request.ToDate - request.FromDate).TotalDays + 1;
}
if (this.CheckRequestValueIsInRangeConditionValue(conditionOperator, managerFlowCondition.Value, requestValue))
{
isAppliedFlowConditionValue = true;
}
break;
case PrecardGroupsName.overwork:
requestValue = ((int)(request.ToDate - request.FromDate).TotalDays + 1) * request.TimeDuration;
if (this.CheckRequestValueIsInRangeConditionValue(conditionOperator, managerFlowCondition.Value, requestValue))
{
isAppliedFlowConditionValue = true;
}
break;
case PrecardGroupsName.traffic:
if (request.FromTime != -1000 && request.ToTime != 1000 && request.TimeDuration != 1000)
{
if (this.CheckRequestValueIsInRangeConditionValue(conditionOperator, managerFlowCondition.Value, request.TimeDuration))
{
isAppliedFlowConditionValue = true;
}
}
break;
case PrecardGroupsName.imperative:
if (this.CheckRequestValueIsInRangeConditionValue(conditionOperator, managerFlowCondition.Value, request.TimeDuration))
{
isAppliedFlowConditionValue = true;
}
break;
default:
break;
}
}
return(isAppliedFlowConditionValue);
}
public static Expression GetConditionExpressionForMember(ParameterExpression parameter, Expression member, ConditionOperators conditionOperator, ConstantExpression constant, StringComparison?stringComparision, bool negate)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (member == null)
{
throw new ArgumentNullException("member");
}
if (constant == null)
{
throw new ArgumentNullException("constant");
}
Type stringType = typeof(string);
Expression ret = null;
if (conditionOperator == ConditionOperators.Equal)
{
if (member.Type == stringType && stringComparision.HasValue)
{
ret = Expression.Call(member, Constants.StringEqualWithComparisation, constant, Expression.Constant(stringComparision.Value));
}
else
{
ret = Expression.Equal(member, constant);
}
}
else if (conditionOperator == ConditionOperators.NotEqual)
{
if (member.Type == stringType && stringComparision.HasValue)
{
ret = Expression.Not(Expression.Call(member, Constants.StringEqualWithComparisation, constant, Expression.Constant(stringComparision.Value)));
}
else
{
ret = Expression.NotEqual(member, constant);
}
}
else if (conditionOperator == ConditionOperators.GreaterThan)
{
if (member.Type == stringType)
{
ret = Expression.GreaterThan(Expression.Call(member, Constants.CompareToMethod, constant), Expression.Constant(0));
}
else
{
ret = Expression.GreaterThan(member, constant);
}
}
else if (conditionOperator == ConditionOperators.GreaterThanOrEqual)
{
if (member.Type == stringType)
{
ret = Expression.GreaterThanOrEqual(Expression.Call(member, Constants.CompareToMethod, constant), Expression.Constant(0));
}
else
{
ret = Expression.GreaterThanOrEqual(member, constant);
}
}
else if (conditionOperator == ConditionOperators.LessThan)
{
if (member.Type == stringType)
{
ret = Expression.LessThan(Expression.Call(member, Constants.CompareToMethod, constant), Expression.Constant(0));
}
else
{
ret = Expression.LessThan(member, constant);
}
}
else if (conditionOperator == ConditionOperators.LessThanOrEqual)
{
if (member.Type == stringType)
{
ret = Expression.LessThanOrEqual(Expression.Call(member, Constants.CompareToMethod, constant), Expression.Constant(0));
}
else
{
ret = Expression.LessThanOrEqual(member, constant);
}
}
else if (conditionOperator == ConditionOperators.Contains)
{
if (member.Type == stringType && stringComparision.HasValue)
{
ret = Expression.GreaterThan(Expression.Call(member, Constants.IndexOfMethod, constant, Expression.Constant(stringComparision.Value)), Expression.Constant(-1));
}
else
{
ret = Expression.Call(member, Constants.ContainsMethod, constant);
}
}
else if (conditionOperator == ConditionOperators.NotContains)
{
if (member.Type == stringType && stringComparision.HasValue)
{
ret = Expression.GreaterThan(Expression.Not(Expression.Call(member, Constants.IndexOfMethod, constant, Expression.Constant(stringComparision.Value))), Expression.Constant(-1));
}
else
{
ret = Expression.Not(Expression.Call(member, Constants.ContainsMethod, constant));
}
}
else if (conditionOperator == ConditionOperators.StartsWith)
{
if (member.Type == stringType && stringComparision.HasValue)
{
ret = Expression.Call(member, Constants.StartsWithMethodWithComparisation, constant, Expression.Constant(stringComparision.Value));
}
else
{
ret = Expression.Call(member, Constants.StartsWithMethod, constant);
}
}
else if (conditionOperator == ConditionOperators.EndsWith)
{
if (member.Type == stringType && stringComparision.HasValue)
{
ret = Expression.Call(member, Constants.EndsWithMethodWithComparisation, constant, Expression.Constant(stringComparision.Value));
}
else
{
ret = Expression.Call(member, Constants.EndsWithMethod, constant);
}
}
else
{
throw new ArgumentException("conditionOperator", "Must supply a known condition operator");
}
if (negate)
{
ret = Expression.Not(ret);
}
return(ret);
}
public WhereBuilder And(string path, ConditionOperators conditionOperator, object value,
QueryConvertStrategy convertStrategy = QueryConvertStrategy.ConvertConstantToComparedPropertyOrField, QueryCollectionHandling collectionHandling = QueryCollectionHandling.Any, StringComparison?stringComparision = null, bool negate = false)
=> Compare(path, conditionOperator, value, convertStrategy: convertStrategy, collectionHandling: collectionHandling, and: true, stringComparision: stringComparision, negate: negate);
public CamlQueryBuilder(ConditionOperators conditionOperator)
{
this.ConditionOperator = conditionOperator;
}
