/// <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); }