public bool Apply(RuleParameter param, object paramValue, object inputValue) { Require.NotNull(param, "param"); Require.NotNull(paramValue, "paramValue"); Require.NotNull(inputValue, "inputValue"); return paramValue.ToString().Contains(inputValue.ToString(), StringComparison.OrdinalIgnoreCase); }
public override object ResolveValue(RuleParameter param, object dataContext) { var referenceResolver = TypeActivator.CreateInstance(_referenceResolverType) as IReferenceResolver; if (referenceResolver == null) throw new InvalidOperationException("Cannot resolve reference resolver type: " + _referenceResolverType + "."); return referenceResolver.Resolve(_referencingType, dataContext); }
public override object ResolveValue(RuleParameter param, object dataContext) { if (dataContext == null) { return null; } return _property.GetValue(dataContext, null); }
public bool Apply(RuleParameter param, object paramValue, object inputValue) { if (paramValue is String && inputValue is String) { return (paramValue as String).Equals((inputValue as String), StringComparison.OrdinalIgnoreCase); } return paramValue.Equals(inputValue); }
public override object ResolveValue(RuleParameter param, object dataContext) { if (dataContext == null) { return(null); } return(_property.GetValue(dataContext, null)); }
public bool Apply(RuleParameter param, object paramValue, object inputValue) { Require.NotNull(param, "param"); Require.NotNull(paramValue, "paramValue"); Require.That(paramValue is IComparable, "paramValue", "Require comparable parameter value."); Require.NotNull(inputValue, "inputValue"); Require.That(inputValue is IComparable, "inputValue", "Require comparable input value."); return ((IComparable)paramValue).CompareTo((IComparable)inputValue) > 0; }
public override object ResolveValue(RuleParameter param, object dataContext) { var referenceResolver = TypeActivator.CreateInstance(_referenceResolverType) as IReferenceResolver; if (referenceResolver == null) { throw new InvalidOperationException("Cannot resolve reference resolver type: " + _referenceResolverType + "."); } return(referenceResolver.Resolve(_referencingType, dataContext)); }
// 此方法用于获取自定义条件参数的值 private string GetCustomerCompnay(RuleParameter parameter, object dataContext) { var order = (Order)dataContext; // 返回其 "Company" 这个 CustomField 的值 var field = order.Customer.CustomFields.FirstOrDefault(f => f.Name == "Company"); if (field == null) { return null; } return field.Value; }
public override object ResolveValue(RuleParameter param, object dataContext) { var value = dataContext; foreach (var resolver in _resolvers) { value = resolver.ResolveValue(param, value); if (value == null) { break; } } return value; }
public override object ResolveValue(RuleParameter param, object dataContext) { var value = dataContext; foreach (var resolver in _resolvers) { value = resolver.ResolveValue(param, value); if (value == null) { break; } } return(value); }
public RuleParameterModel(RuleParameter param) : this() { Name = param.Name; DisplayName = param.Name; ValueType = param.ValueType.FullName; IsNumberValue = param.ValueType.IsNumericType(); foreach (var @operator in param.SupportedOperators) { SupportedOperators.Add(new ComparisonOperatorModel(@operator)); } if (param.ValueSource != null) { Values = param.ValueSource.GetValues(param).Select(x => new SelectListItem { Text = x.Key, Value = x.Value }) .ToList(); } }
public IDictionary <string, string> GetValues(RuleParameter param) { return(_values); }
public override object ResolveValue(RuleParameter param, object dataContext) { return _resolveValue(param, dataContext); }
/// <summary> /// Resolve the parameter value of the specified parameter from the context object. /// </summary> /// <param name="param">The parameter to resolve value.</param> /// <param name="dataContext">The context object.</param> /// <returns>The value of the parameter.</returns> public abstract object ResolveValue(RuleParameter param, object dataContext);
public override object ResolveValue(RuleParameter param, object dataContext) { return(_resolveValue(param, dataContext)); }
/// <summary> /// Resolve the parameter value of the specified parameter from the context object. /// </summary> /// <param name="param">The parameter to resolve value.</param> /// <param name="dataContext">The context object.</param> /// <returns>The value of the parameter.</returns> public abstract object ResolveValue(RuleParameter param, object dataContext);
public IDictionary<string, string> GetValues(RuleParameter param) { return _values; }
public bool Apply(RuleParameter param, object paramValue, object inputValue) { return !ComparisonOperators.GreaterThan.Apply(param, paramValue, inputValue); }
private List<RuleParameter> FindConditionParameters(Type containerType, RuleParameterValueResolver containerResolver, string prefix) { var parameters = new List<RuleParameter>(); foreach (var property in containerType.GetProperties(BindingFlags.Public | BindingFlags.Instance)) { var refAttr = property.GetCustomAttribute<ReferenceAttribute>(false); if (refAttr != null) { var resolver = new ChainedRuleParameterValueResolver().Chain(containerResolver, new PropertyBackedRuleParameterValueResolver(property)); var referencingType = refAttr.ReferencingType ?? property.PropertyType; // Indirect reference if (referencingType != property.PropertyType) { if (refAttr.ReferenceResolver == null) throw new InvalidOperationException("Indirect reference must speicify a reference resolver. Property: " + property.ReflectedType.FullName + "." + property.Name + "."); resolver.Chain(new IndirectReferenceAdapter(referencingType, refAttr.ReferenceResolver)); } var newPrefix = prefix; // refAttr.Prefix == null: Generate a default prefix // refAttr.Prefix == String.Empty: Do not use prefix // otherwise, use the specified prefix if (refAttr.Prefix != null) { if (refAttr.Prefix.Length > 0) { newPrefix = prefix + (refAttr.Prefix.EndsWith(".") ? refAttr.Prefix : refAttr.Prefix + "."); } } else { // Try to get a smart default preifx if developer doesn't specify one. // If the property name is like BrandId, // then we use 'Brand' instead of 'BrandId'. // So when we are investigating Brand.Name property, we can get a better parameter name 'BrandName' instead of 'BrandIdName' if (property.Name.EndsWith("Id")) { newPrefix = prefix + property.Name.Substring(0, property.Name.Length - 2); } else { newPrefix = prefix + property.Name; } newPrefix = newPrefix + "."; } parameters.AddRange(FindConditionParameters(referencingType, resolver, newPrefix)); // Add also extended parameters foreach (var provider in Providers) { if (provider.GetType() != typeof(DefaultRuleParameterProvider)) { var additionalParams = provider.GetParameters(referencingType); foreach (var param in additionalParams) { var valueResolver = new ChainedRuleParameterValueResolver(); valueResolver.Chain(resolver); valueResolver.Chain(param.ValueResolver); var adaptedParam = new RuleParameter(newPrefix + param.Name, param.ValueType, valueResolver, param.SupportedOperators) { ValueSource = param.ValueSource }; parameters.Add(adaptedParam); } } } } else { var paramAttr = property.GetCustomAttribute<ParamAttribute>(false); if (paramAttr != null) { parameters.Add(CreateConditionParameter(containerType, containerResolver, prefix, property, paramAttr)); } } } return parameters; }
private List <RuleParameter> FindConditionParameters(Type containerType, RuleParameterValueResolver containerResolver, string prefix) { var parameters = new List <RuleParameter>(); foreach (var property in containerType.GetProperties(BindingFlags.Public | BindingFlags.Instance)) { var refAttr = property.GetCustomAttribute <ReferenceAttribute>(false); if (refAttr != null) { var resolver = new ChainedRuleParameterValueResolver().Chain(containerResolver, new PropertyBackedRuleParameterValueResolver(property)); var referencingType = refAttr.ReferencingType ?? property.PropertyType; // Indirect reference if (referencingType != property.PropertyType) { if (refAttr.ReferenceResolver == null) { throw new InvalidOperationException("Indirect reference must speicify a reference resolver. Property: " + property.ReflectedType.FullName + "." + property.Name + "."); } resolver.Chain(new IndirectReferenceAdapter(referencingType, refAttr.ReferenceResolver)); } var newPrefix = prefix; // refAttr.Prefix == null: Generate a default prefix // refAttr.Prefix == String.Empty: Do not use prefix // otherwise, use the specified prefix if (refAttr.Prefix != null) { if (refAttr.Prefix.Length > 0) { newPrefix = prefix + (refAttr.Prefix.EndsWith(".") ? refAttr.Prefix : refAttr.Prefix + "."); } } else { // Try to get a smart default preifx if developer doesn't specify one. // If the property name is like BrandId, // then we use 'Brand' instead of 'BrandId'. // So when we are investigating Brand.Name property, we can get a better parameter name 'BrandName' instead of 'BrandIdName' if (property.Name.EndsWith("Id")) { newPrefix = prefix + property.Name.Substring(0, property.Name.Length - 2); } else { newPrefix = prefix + property.Name; } newPrefix = newPrefix + "."; } parameters.AddRange(FindConditionParameters(referencingType, resolver, newPrefix)); // Add also extended parameters foreach (var provider in Providers) { if (provider.GetType() != typeof(DefaultRuleParameterProvider)) { var additionalParams = provider.GetParameters(referencingType); foreach (var param in additionalParams) { var valueResolver = new ChainedRuleParameterValueResolver(); valueResolver.Chain(resolver); valueResolver.Chain(param.ValueResolver); var adaptedParam = new RuleParameter(newPrefix + param.Name, param.ValueType, valueResolver, param.SupportedOperators) { ValueSource = param.ValueSource }; parameters.Add(adaptedParam); } } } } else { var paramAttr = property.GetCustomAttribute <ParamAttribute>(false); if (paramAttr != null) { parameters.Add(CreateConditionParameter(containerType, containerResolver, prefix, property, paramAttr)); } } } return(parameters); }
public SwitchCaseRule(RuleParameter parameter) { Parameter = parameter; }