/// <summary>
/// 查询规则构造函数
/// </summary>
/// <param name="operate">操作符</param>
/// <param name="fieldName">数据库可接受的查询字段名称，未传直接取属性名称</param>
/// <param name="group">隶属分组</param>
/// <param name="groupOperate">分组查询操作符</param>
public QueryRuleAttribute(FilterOperate operate, string fieldName, string group = "", FilterOperate groupOperate = FilterOperate.And)
{
FieldName = fieldName;
Group = group;
Operate = operate;
GroupOperate = groupOperate;
}
/// <summary>
/// 使用指定数据名称，数据值及操作方式初始化一个<see cref="ReqRule"/>的新实例
/// </summary>
/// <param name="field">数据名称</param>
/// <param name="value">数据值</param>
/// <param name="operate">操作方式</param>
public ReqRule(string field, object value, FilterOperate operate, ConditionLink link)
{
Field = field;
Value = value;
Operate = operate;
Link = link;
}
public ReqFieldAttribute(string fieldName = "",
FilterOperate op = FilterOperate.Equal,
ConditionLink link = ConditionLink.And)
{
FieldName = fieldName;
Op = op;
Link = link;
}
public ReqMultiFieldAttribute(string[] fields,
FilterOperate op,
ConditionLink innerLink,
ConditionLink outerLink)
{
Fields = fields;
Op = op;
InnerLink = innerLink;
OuterLink = outerLink;
}
/// <summary>
/// 把查询操作的枚举表示转换为操作码
/// </summary>
/// <param name="operate">查询操作的枚举表示</param>
public static string ToOperateCode(this FilterOperate operate)
{
Type type = operate.GetType();
MemberInfo[] members = type.GetMember(operate.CastTo <string>());
if (members.Length > 0)
{
OperateCodeAttribute attribute = members[0].GetAttribute <OperateCodeAttribute>();
return(attribute == null ? null : attribute.Code);
}
return(null);
}
/// <summary>
/// 把查询操作的枚举表示转换为操作名称
/// </summary>
/// <param name="operate">查询操作的枚举表示</param>
/// <returns></returns>
public static string ToOperateName(this FilterOperate operate)
{
var type = operate.GetType();
var members = type.GetMember(operate.CastTo <string>());
if (members.Length > 0)
{
var attributes = members[0].GetCustomAttributes(typeof(OperateCodeAttribute), false);
if (attributes.Length > 0)
{
return(((OperateCodeAttribute)attributes[0]).Name);
}
}
return(null);
}
public static FilterOperate GetFilterOperate(string code)
{
Type type = typeof(FilterOperate);
MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Static);
foreach (var member in members)
{
FilterOperate operate = member.Name.CastTo <FilterOperate>();
if (operate.ToOperateCode() == code)
{
return(operate);
}
}
throw new NotSupportedException("获取操作码的查询操作枚举表示时不支持代码：" + code);
}
/// <summary>
/// 把查询操作的枚举表示转换为操作码
/// </summary>
/// <param name="operate">查询操作的枚举表示</param>
public static string ToOperateCode(this FilterOperate operate)
{
Type type = operate.GetType();
MemberInfo[] members = type.GetMember(operate.CastTo <string>());
if (members.Length > 0)
{
object[] attributes = members[0].GetCustomAttributes(typeof(OperateCodeAttribute), false);
if (attributes.Length > 0)
{
return(((OperateCodeAttribute)attributes[0]).Code);
}
}
return(null);
}
/// <summary>
/// 获取操作码的查询操作枚举表示
/// </summary>
/// <param name="code">操作码</param>
/// <returns></returns>
public static FilterOperate GetFilterOperate(string code)
{
if (string.IsNullOrEmpty(code))
{
throw new ArgumentNullException("message");
}
Type type = typeof(FilterOperate);
MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Static);
foreach (MemberInfo member in members)
{
FilterOperate operate = member.Name.CastTo <FilterOperate>();
if (operate.ToOperateCode() == code)
{
return(operate);
}
}
throw new NotSupportedException("获取操作码的查询操作枚举表示时不支持代码：" + code);
}
public static String GetOperate(FilterOperate operate)
{
String str = String.Empty;
switch (operate)
{
case FilterOperate.Eq:
return("=");
case FilterOperate.NotEq:
return("<>");
case FilterOperate.Gt:
case FilterOperate.GtIndicator:
return(">");
case FilterOperate.Gte:
return(">=");
case FilterOperate.Lt:
case FilterOperate.LtIndicator:
return("<");
case FilterOperate.Lte:
return("<=");
case FilterOperate.StartWith:
case FilterOperate.EndWith:
case FilterOperate.Contains:
return("like");
case FilterOperate.NotContains:
return("not like");
case FilterOperate.And:
return(" and ");
case FilterOperate.Or:
return(" or ");
}
return(str);
}
protected virtual string AddFilteringParam(object value, FilterOperate operate)
{
var paramName = $"{Context.DbParameterPrefix}Field_{FilteringParams.Count}";
var val = value;
if (operate == FilterOperate.StartsWith)
{
val = $"{value}%";
}
else if (operate == FilterOperate.EndsWith)
{
val = $"%{value}";
}
else if (operate == FilterOperate.Contains)
{
val = $"%{value}%";
}
FilteringParams.Add(new FilteringParam(paramName, val));
return(paramName);
}
/// <summary>
/// 使用操作方式初始化一个<see cref="FilterGroup"/>的新实例
/// </summary>
/// <param name="operate">条件间操作方式</param>
public FilterGroup(FilterOperate operate)
: this()
{
Operate = operate;
}
/// <summary>
/// 使用指定数据名称，数据值及操作方式初始化一个<see cref="FilterRule"/>的新实例
/// </summary>
/// <param name="field">数据名称</param>
/// <param name="value">数据值</param>
/// <param name="operate">操作方式</param>
public FilterRule(string field, object value, FilterOperate operate)
{
Field = field;
Value = value;
Operate = operate;
}
/// <summary>
/// 使用操作方式初始化一个<see cref="FilterGroup"/>的新实例
/// </summary>
/// <param name="operate">条件间操作方式</param>
public FilterGroup(FilterOperate operate)
{
Operate = operate;
Rules = new List<FilterRule>();
Groups = new List<FilterGroup>();
}
/// <summary>
/// 使用指定数据名称，数据值及操作方式初始化一个<see cref="FilterRule"/>的新实例
/// </summary>
/// <param name="field">数据名称</param>
/// <param name="value">数据值</param>
/// <param name="operate">操作方式</param>
public FilterRule(string field, object value, FilterOperate operate)
{
Field = field;
Value = value;
Operate = operate;
}
/// <summary>
/// 使用指定数据名称，数据值及操作方式初始化一个<see cref="FilterRule"/>的新实例
/// </summary>
/// <param name="field">数据名称</param>
/// <param name="value">数据值</param>
/// <param name="operate">操作方式</param>
public FilterRule(string field, object value, FilterOperate operate)
: this(field, value)
{
Operate = operate;
}
public ReqMultiFieldAttribute(string[] fields, FilterOperate op)
: this(fields, op, ConditionLink.Or)
{
}
public ReqMultiFieldAttribute(string[] fields, FilterOperate op, ConditionLink innerLink)
: this(fields, op, innerLink, ConditionLink.And)
{
}
/// <summary>
/// 使用操作方式初始化一个<see cref="FilterGroup"/>的新实例
/// </summary>
/// <param name="operate">条件间操作方式</param>
public FilterGroup(FilterOperate operate)
{
Operate = operate;
Rules = new List <FilterRule>();
Groups = new List <FilterGroup>();
}
/// <summary>
/// 使用指定数据名称，数据值及操作方式初始化一个<see cref="FilterRule"/>的新实例
/// </summary>
/// <param name="field">数据名称</param>
/// <param name="value">数据值</param>
/// <param name="operate">操作方式</param>
public FilterRule(string field, object value, FilterOperate operate)
: this(field, value)
{
Operate = operate;
}
/// <summary>
/// 使用操作方式初始化一个<see cref="FilterGroup" />的新实例
/// </summary>
/// <param name="operate">条件间操作方式</param>
public FilterGroup(FilterOperate operate)
: this()
{
Operate = operate;
}
/// <summary>
/// 添加规则
/// </summary>
public FilterGroup AddRule(string field, object value, FilterOperate operate = FilterOperate.Equal)
{
FilterRule rule = new FilterRule(field, value, operate);
return(AddRule(rule));
}
public ReqFieldAttribute(string fieldName, FilterOperate op)
: this(fieldName, op, ConditionLink.And)
{
}
