/// <summary>Creates and initializes the rule.</summary> /// <param name="pHandler">The address of the method implementing the rule.</param> /// <param name="pArgs">A RuleArgs object.</param> /// <param name="pPropertyNames">The fields, properties or columns to which the rule applies.</param> public MultiPropertyRuleMethod(RuleHandler pHandler, RuleArgs pArgs, params string[] pPropertyNames) : base(pHandler, pArgs) { if (pPropertyNames == null || pPropertyNames.Length < 2) { throw new ArgumentException("MultiPropertyRules require at least two properties."); } mPropertyNames = pPropertyNames; }
public static bool ObjectRequired(object target, RuleArgs e) { if (null == ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName)) { e.Description = string.Format(Resources.StringRequiredRule, e.DisplayPropertyName); return(false); } return(true); }
public static bool StringRequired(object target, RuleArgs e) { string value = (string)ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName); if (string.IsNullOrEmpty(value)) { e.Description = string.Format(Resources.StringRequiredRule, e.DisplayPropertyName); return(false); } return(true); }
public static bool StringMinLength(object target, RuleArgs e) { int min = ((MinMaxArgs <Int32>)e).MinValue; string value = (string)ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName); if (String.IsNullOrEmpty(value) || (value.Trim().Length < min)) { e.Description = String.Format( Resources.StringMinLengthRule, e.DisplayPropertyName, min.ToString()); return(false); } return(true); }
public static bool StringMaxLength(object target, RuleArgs e) { int max = (int)((MinMaxArgs <Int32>)e).MaxValue; string value = (string)ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName); if (!String.IsNullOrEmpty(value) && (value.Length > max)) { e.Description = String.Format( Resources.StringMaxLengthRule, e.DisplayPropertyName, max.ToString()); return(false); } return(true); }
/// <summary>Creates and initializes the rule.</summary> /// <param name="pHandler">The address of the method implementing the rule.</param> /// <param name="pArgs">Rule arguments.</param> /// <param name="pBusinessPropertys">The entity columns to which the rule applies.</param> public MultiPropertyRuleMethod(RuleHandler pHandler, RuleArgs pArgs, params BusinessProperty[] pBusinessPropertys) : base(pHandler, pArgs) { if (pBusinessPropertys == null || pBusinessPropertys.Length < 2) { throw new ArgumentException("MultiPropertyRules require at least two properties."); } mPropertyNames = new string[pBusinessPropertys.Length]; for (int i = 0; i < pBusinessPropertys.Length; i++) { mPropertyNames[i] = pBusinessPropertys[i].Name; } }
private static bool PropertyRequiredHandler(object pTarget, RuleArgs pArgs) { PropertyRequiredRuleArgs args = (PropertyRequiredRuleArgs)pArgs; bool ok = HasValue(pTarget, args); if (ok) { return(true); } args.Description = string.Format(Properties.Resources.StringRequiredRule, args.DisplayPropertyName); return(false); }
/// <summary>Rule ensuring that a numeric value is not less than the specified minimum.</summary> /// <typeparam name="T">Type of the property to validate.</typeparam> /// <param name="target">Object containing value to validate.</param> /// <param name="e">Arguments variable specifying the name of the property to validate, /// along with the min allowed value.</param> /// <remarks> /// Converts the arguments to the target type, T, if it can and calls CompareTo. /// <para>Heavily revised by IdeaBlade.</para> /// </remarks> public static bool MinValue <T>(object target, RuleArgs e) { T min = (T)((MinMaxArgs <T>)e).MinValue; object value = ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName); bool result = Compare <T>(value, min) >= 0; if (!result) { e.Description = string.Format(Resources.MinValueRule, e.DisplayPropertyName, min.ToString()); return(false); } else { return(true); } }
public static bool MinMaxValue <T>(object target, RuleArgs e) { T min = ((MinMaxArgs <T>)e).MinValue; T max = ((MinMaxArgs <T>)e).MaxValue; object value = ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName); bool ok = true; if (value != null) { ok = (Compare <T>(value, min) >= 0 && Compare <T>(value, max) <= 0); } if (ok) { return(true); } e.Description = String.Format( Resources.BetweenRule, e.DisplayPropertyName, min.ToString(), max.ToString()); return(false); }
public static bool IntegerMinMaxValue(object target, RuleArgs e) { long min = ((MinMaxArgs <Int64>)e).MinValue; long max = ((MinMaxArgs <Int64>)e).MaxValue; object value = ExtendedReflectionFns.GetPropertyValue(target, e.PropertyName); bool ok = true; if (value != null) { long testValue = Convert.ToInt64(value); ok = (testValue >= min) && (testValue <= max); } if (ok) { return(true); } e.Description = String.Format( Resources.BetweenRule, e.DisplayPropertyName, min.ToString(), max.ToString()); return(false); }
/// <summary>Rule that check that value matches a given regex pattern.</summary> /// <param name="target">Object containing the data to validate</param> /// <param name="e">RegExRuleArgs parameter specifying the name of the /// property to validate and the regex pattern.</param> /// <returns>False if the rule is broken</returns> /// <remarks>This implementation uses late binding.</remarks> public static bool RegExMatch(object target, RuleArgs e) { RegExRuleArgs args = (RegExRuleArgs)e; Regex rx = args.RegEx; string value = (string)ExtendedReflectionFns.GetPropertyValue(target, args.PropertyName); // Contra CSLA, rule does NOT fail if there is no entry; // That test is the job of a "PropertyRequired" rule. if (value == null || value.Trim() == String.Empty) { return(true); } if (!rx.IsMatch(value)) { args.Description = String.Format(args.MessageTemplate, args.DisplayPropertyName); return(false); } else { return(true); } }
/// <summary>Rule ensuring an integer value doesn't go below a specified value.</summary> /// <param name="target">Object containing the data to validate.</param> /// <param name="e">Arguments parameter specifying the name of the property to validate.</param> /// <returns><see langword="false"/> if the rule is broken.</returns> /// <remarks>Re-routed Csla version to MinValue(Of T).</remarks> public static bool IntegerMinValue(object target, RuleArgs e) { return(MinValue <int>(target, e)); }
/// <summary>Creates and initializes the rule.</summary> /// <param name="pHandler">The address of the method implementing the rule.</param> /// <param name="pArgs">A RuleArgs object.</param> public RuleMethod(RuleHandler pHandler, RuleArgs pArgs) { mHandler = pHandler; mArgs = pArgs; MakeRuleName(); }
/// <summary>Return a rule name from the RuleHandler + RuleArgs.</summary> internal string MakeRuleName(RuleHandler pHandler, RuleArgs pArgs) { return(pHandler.Method.Name + "!" + pArgs.ToString()); }
/// <summary>Creates and adds a RuleMethod to the list of rules to be enforced.</summary> /// <param name="pHandler">The handler that implements the rule. Should be a static delegate.</param> /// <param name="args"> /// A RuleArgs object specifying the property name (or group name) and other arguments /// passed to the rule method</param> /// <returns>The added RuleMethod.</returns> /// <remarks> /// A rule is implemented by a delegate which conforms to the /// method signature defined by the RuleHandler delegate. /// </remarks> public RuleMethod Add(RuleHandler pHandler, RuleArgs args) { RuleMethod method = new RuleMethod(pHandler, args); return(AddX(args.PropertyName, method)); }
/// <summary>Remove a specific rule from the rule list.</summary> public void Remove(RuleHandler pHandler, RuleArgs args) { Remove(pHandler, args.PropertyName); }
/// <summary>Creates and initializes the rule.</summary> /// <param name="pHandler">The address of the method implementing the rule.</param> /// <param name="pPropertyName">The field, property or column to which the rule applies.</param> public RuleMethod(RuleHandler pHandler, string pPropertyName) { mHandler = pHandler; mArgs = new RuleArgs(pPropertyName); MakeRuleName(); }