internal ICondition ToCondition(string keyword)
{
var conditions = new ConditionCollection(ConditionCombination.Or);
foreach (var field in this.Fields)
{
if (this.Singleton)
{
conditions.Add(Condition.Equal(field, keyword));
}
else
{
conditions.Add(Condition.Like(field, '%' + keyword + '%'));
}
}
if (conditions.Count == 1)
{
return(conditions[0]);
}
else
{
return(conditions);
}
}
public virtual ICondition Convert(ConditionalConverterContext context)
{
//如果当前属性值为默认值，则忽略它
if (this.IsDefaultValue(context))
{
return(null);
}
var opt = context.Operator;
var isRange = Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(ConditionalRange), context.Type);
//只有当属性没有指定运算符并且不是区间属性，才需要生成运算符
if (opt == null && (!isRange))
{
opt = ConditionOperator.Equal;
if (context.Type == typeof(string) && context.Value != null)
{
opt = ConditionOperator.Like;
}
else if (typeof(IEnumerable).IsAssignableFrom(context.Type) || Zongsoft.Common.TypeExtension.IsAssignableFrom(typeof(IEnumerable <>), context.Type))
{
opt = ConditionOperator.In;
}
}
//如果当前属性只对应一个条件
if (context.Names.Length == 1)
{
if (isRange)
{
return(((ConditionalRange)context.Value).ToCondition(context.Names[0]));
}
else
{
return(new Condition(context.Names[0], (opt == ConditionOperator.Like && _wildcard != '\0' ? _wildcard + context.Value.ToString().Trim(_wildcard) + _wildcard : context.Value), opt.Value));
}
}
//当一个属性对应多个条件，则这些条件之间以“或”关系进行组合
var conditions = new ConditionCollection(ConditionCombination.Or);
foreach (var name in context.Names)
{
if (isRange)
{
conditions.Add(((ConditionalRange)context.Value).ToCondition(name));
}
else
{
conditions.Add(new Condition(name, (opt == ConditionOperator.Like && _wildcard != '\0' ? _wildcard + context.Value.ToString().Trim(_wildcard) + _wildcard : context.Value), opt.Value));
}
}
return(conditions);
}
private static ConditionCollection ToConditions(IModel conditional, IDictionary <string, object> changes)
{
if (changes == null || changes.Count == 0)
{
return(null);
}
ConditionCollection conditions = null;
var descriptor = _cache.GetOrAdd(conditional.GetType(), type => new ConditionalDescriptor(type));
//处理已经被更改过的属性
foreach (var change in changes)
{
var condition = GenerateCondition(conditional, descriptor.Properties[change.Key]);
if (condition != null)
{
if (conditions == null)
{
conditions = ConditionCollection.And();
}
conditions.Add(condition);
}
}
return(conditions);
}
private static ICondition ConvertToCondition(string name, object value)
{
if (value == null)
{
return(new Condition(name, null));
}
Type valueType = value.GetType();
if (valueType.IsEnum)
{
return(new Condition(name, Zongsoft.Common.Convert.ConvertValue(value, Enum.GetUnderlyingType(valueType))));
}
if (valueType.IsArray || typeof(ICollection).IsAssignableFrom(valueType))
{
return(new Condition(name, value, ConditionOperator.In));
}
if (typeof(IDictionary).IsAssignableFrom(valueType))
{
var clauses = new ConditionCollection(ConditionCombination.Or);
foreach (DictionaryEntry entry in (IDictionary)value)
{
if (entry.Key != null)
{
clauses.Add(ConvertToCondition(entry.Key.ToString(), entry.Value));
}
}
return(clauses);
}
if (typeof(IDictionary <string, object>).IsAssignableFrom(valueType))
{
var clauses = new ConditionCollection(ConditionCombination.Or);
foreach (var entry in (IDictionary <string, object>)value)
{
if (entry.Key != null)
{
clauses.Add(ConvertToCondition(entry.Key, entry.Value));
}
}
return(clauses);
}
return(new Condition(name, value));
}
private static ConditionCollection ResolveCondition(IDictionary <string, object> condition)
{
if (condition == null || condition.Count < 1)
{
return(null);
}
var result = new ConditionCollection(ConditionCombination.Or);
foreach (var parameter in condition)
{
result.Add(ConvertToCondition(parameter.Key, parameter.Value));
}
return(result);
}
private ICondition EnsureInquiryKey(object[] values)
{
if (values != null && values.Length > 3)
{
throw new NotSupportedException("Too many the keys.");
}
//获取查询键值对数组
var items = this.GetKey(values ?? new object[0]);
if (items == null || items.Length == 0)
{
return(null);
}
if (items.Length == 1)
{
if (IsNothing(items[0].Value))
{
return(null);
}
return(items[0].Value is ICondition ? (ICondition)items[0].Value : Condition.Equal(items[0].Key, items[0].Value));
}
var conditions = new ConditionCollection(ConditionCombination.And);
foreach (var item in items)
{
if (!IsNothing(item.Value))
{
conditions.Add(item.Value is ICondition ? (ICondition)item.Value : Condition.Equal(item.Key, item.Value));
}
}
if (conditions.Count > 1)
{
return(conditions);
}
return(conditions.FirstOrDefault());
}
private static ConditionCollection ResolveCondition(object condition)
{
if (condition == null)
{
return(null);
}
var properties = TypeDescriptor.GetProperties(condition);
if (properties == null || properties.Count < 1)
{
return(null);
}
var result = new ConditionCollection(ConditionCombination.Or);
foreach (PropertyDescriptor property in properties)
{
result.Add(ConvertToCondition(property.Name, property.GetValue(condition)));
}
return(result);
}
