/// <summary>
/// Gets the expression.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="param">The parameter.</param>
/// <param name="item">The item.</param>
/// <returns>Expression.</returns>
private static Expression GetExpression <T>(ParameterExpression param, ConditionItem item)
{
LambdaExpression exp = GetPropertyLambdaExpression <T>(item, param);
foreach (var provider in TransformProviders.Where(provider => provider.Match(item, exp.Body.Type)))
{
return(GetGroupExpression <T>(param, provider.Transform(item, exp.Body.Type), Expression.AndAlso));
}
var constant = ChangeTypeToExpression(item, exp.Body.Type);
return(ExpressionDict[item.Method](exp.Body, constant));
}
/// <summary>
/// Adds the between condition.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="beginVal">The begin value.</param>
/// <param name="endVal">The end value.</param>
/// <returns>SearchCondition.</returns>
public SearchCondition AddBetweenCondition(string field, object beginVal, object endVal)
{
ConditionItem item = new ConditionItem
{
Field = field,
Method = QueryMethod.Between,
Value = new[] { beginVal, endVal }
};
this.Items.Add(item);
return(this);
}
/// <summary>
/// Transforms the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="type">The type.</param>
/// <returns>IEnumerable<ConditionItem>.</returns>
public IEnumerable <ConditionItem> Transform(ConditionItem item, Type type)
{
var arr = (item.Value as Array);
if (arr == null)
{
var arrStr = item.Value.ToString();
if (!string.IsNullOrEmpty(arrStr))
{
arr = arrStr.Split(',');
}
}
return(new[] { new ConditionItem(item.Field, QueryMethod.StdIn, arr) });
}
/// <summary>
/// Gets the property lambda expression.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="item">The item.</param>
/// <param name="param">The parameter.</param>
/// <returns>LambdaExpression.</returns>
private static LambdaExpression GetPropertyLambdaExpression <T>(ConditionItem item, ParameterExpression param)
{
var props = item.Field.Split('.');
Expression propertyAccess = param;
var typeOfProp = typeof(T);
int i = 0;
do
{
PropertyInfo property = typeOfProp.GetProperty(props[i], BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
if (property == null)
{
return(null);
}
typeOfProp = property.PropertyType;
propertyAccess = Expression.MakeMemberAccess(propertyAccess, property);
i++;
} while (i < props.Length);
return(Expression.Lambda(propertyAccess, param));
}
/// <summary>
/// Matches the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="type">The type.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public bool Match(ConditionItem item, Type type)
{
return(item.Method == QueryMethod.DateBlock);
}
/// <summary>
/// Gets the where string.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.Exception">Query conditions cannot be converted to date</exception>
private string GetWhereString(ConditionItem item)
{
string str = "";
switch (item.Method)
{
case QueryMethod.Contains:
case QueryMethod.StdIn:
case QueryMethod.DateTimeLessThanOrEqual:
break;
case QueryMethod.Equal:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} = '{1}'", item.Field, item.Value);
//str = $"{item.Field}='{item.Value}'";
break;
case QueryMethod.LessThan:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} < '{1}'", item.Field, item.Value);
//str = $"{item.Field}<'{item.Value}'";
break;
case QueryMethod.GreaterThan:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} > '{1}'", item.Field, item.Value);
//str = $"{item.Field}>'{item.Value}'";
break;
case QueryMethod.LessThanOrEqual:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} <= '{1}'", item.Field, item.Value);
//str = $"{item.Field}<='{item.Value}'";
break;
case QueryMethod.GreaterThanOrEqual:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} >= '{1}'", item.Field, item.Value);
//str = $"{item.Field}>='{item.Value}'";
break;
case QueryMethod.Like:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} like '%{1}%'", item.Field, item.Value);
//str = $"{item.Field} like '%{item.Value}%'";
break;
case QueryMethod.In:
string strInValue;
if (item.Value is ICollection)
{
ICollection <string> collection = item.Value as ICollection <string>;
strInValue = string.Join("','", collection.ToArray());
}
else
{
strInValue = item.Value.ToString().Replace(",", "','");
}
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} in '{1}'", item.Field, strInValue);
//str = $"{item.Field} in ('{strInValue}')";
break;
case QueryMethod.DateBlock:
DateTime dt;
if (!DateTime.TryParse(item.Value.ToString(), out dt))
{
throw new Exception("Query conditions cannot be converted to date");
}
string start = dt.Date.ToString("yyyy-MM-dd");
string end = dt.Date.AddDays(1).ToString("yyyy-MM-dd");
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} between '{1}' and '{2}'", item.Field, start, end);
break;
case QueryMethod.NotEqual:
str = string.Format("{0} <> '{1}'", item.Field, item.Value);
//str = $"{item.Field}<>'{item.Value}'";
break;
case QueryMethod.StartsWith:
str = string.Format("{0} like '{1}%'", item.Field, item.Value);
break;
case QueryMethod.EndsWith:
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} like '%{1}'", item.Field, item.Value);
break;
case QueryMethod.Between:
object[] objs = item.Value as object[];
if (objs != null)
{
// ReSharper disable once UseStringInterpolation
str = string.Format("{0} between '{1}' and '{2}'", item.Field, objs[0], objs[1]);
}
break;
}
return(str);
}
/// <summary>
/// Matches the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="type">The type.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public bool Match(ConditionItem item, Type type)
{
return(item.Method == QueryMethod.Between);
}
