/// <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)
{
object[] objs = item.Value as object[];
if (objs == null)
{
return new[]
{
new ConditionItem(item.Field, QueryMethod.GreaterThanOrEqual, ""),
new ConditionItem(item.Field, QueryMethod.LessThan, "")
};
}
if (objs.Length < 2)
{
return new[]
{
new ConditionItem(item.Field, QueryMethod.GreaterThanOrEqual, ""),
new ConditionItem(item.Field, QueryMethod.LessThan, "")
};
}
return new[]
{
new ConditionItem(item.Field, QueryMethod.GreaterThanOrEqual, objs[0]),
new ConditionItem(item.Field, QueryMethod.LessThan, objs[1])
};
}
/// <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)
{
DateTime willTime;
Type instanceType = TypeUtil.GetUnNullableType(type);
if (DateTime.TryParse(item.Value.ToString(), out willTime))
{
var method = item.Method;
if (method == QueryMethod.LessThan || method == QueryMethod.LessThanOrEqual)
{
method = QueryMethod.DateTimeLessThanOrEqual;
if (willTime.Hour == 0 && willTime.Minute == 0 && willTime.Second == 0)
{
willTime = willTime.AddDays(1).AddMilliseconds(-1);
}
}
object value = null;
if (instanceType == typeof(DateTime))
{
value = willTime;
}
else if (instanceType == typeof(int))
{
value = (int)UnixTime.FromDateTime(willTime);
}
else if (instanceType == typeof(long))
{
value = UnixTime.FromDateTime(willTime);
}
return new[] { new ConditionItem(item.Field, method, value) };
}
return new[] { new ConditionItem(item.Field, item.Method, Convert.ChangeType(item.Value, type)) };
}
/// <summary>
/// add key=value into QueryModel.Items
/// </summary>
/// <param name="model">QueryModel</param>
/// <param name="key">the name of Element (input/select/area/radio/checkbox)</param>
/// <param name="val">the value of Element (input/select/area/radio/checkbox)</param>
public static void AddSearchItem(QueryBuilder model, string key, string val)
{
if (model == null)
{
model = new QueryBuilder();
}
string orGroup = "";
var keywords = key.Split("$', ')', '}".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (keywords.Length != 2)
return;
var method = SearchMethodAdapter(keywords[0]);
var field = keywords[1];
if (string.IsNullOrEmpty(method)) return;
if (!string.IsNullOrEmpty(field))
{
var item = new ConditionItem
{
Field = field,
Value = val.Trim(),
OrGroup = orGroup,
Method = (QueryMethod)Enum.Parse(typeof(QueryMethod), method)
};
model.Items.Add(item);
}
}
/// <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)
{
return new[]
{
new ConditionItem(item.Field, QueryMethod.GreaterThanOrEqual, item.Value),
new ConditionItem(item.Field, QueryMethod.LessThan, item.Value)
};
}
/// <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)
{
var elementType = TypeUtil.GetUnNullableType(type);
return ((elementType == typeof(int) && !(item.Value is int))
|| (elementType == typeof(long) && !(item.Value is long))
|| (elementType == typeof(DateTime) && !(item.Value is DateTime))
)
&& item.Value.ToString().Contains("-");
}
/// <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>
/// 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>
/// 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>
/// 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>
/// 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 str = item.Value.ToString();
var keyWords = str.Split('*');
if (keyWords.Length == 1)
{
return new[] { new ConditionItem(item.Field, QueryMethod.Contains, item.Value) };
}
var list = new List<ConditionItem>();
if (!string.IsNullOrEmpty(keyWords.First()))
list.Add(new ConditionItem(item.Field, QueryMethod.StartsWith, keyWords.First()));
if (!string.IsNullOrEmpty(keyWords.Last()))
list.Add(new ConditionItem(item.Field, QueryMethod.EndsWith, keyWords.Last()));
for (int i = 1; i < keyWords.Length - 1; i++)
{
if (!string.IsNullOrEmpty(keyWords[i]))
list.Add(new ConditionItem(item.Field, QueryMethod.Contains, keyWords[i]));
}
return list;
}
/// <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]);
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>
/// Adds the specified field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="method">The method.</param>
/// <param name="val">The value.</param>
/// <returns>SearchCondition.</returns>
public SearchCondition Add(string field, QueryMethod method, object val)
{
ConditionItem item = new ConditionItem(field, method, val);
this.Items.Add(item);
return this;
}
/// <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;
}
/// <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.In);
}
