Csla.Validation.Shared/CommonRules.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="CommonRules.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Provides the Common rules for CSLA 3.x</summary>
//-----------------------------------------------------------------------
using System;
using Csla.Properties;
using System.Text.RegularExpressions;
using System.Reflection;
using Csla.Core;
#if NETFX_CORE
using Csla.Reflection;
#endif
using Csla.Rules;
 
namespace Csla.Validation
{
  public static partial class CommonRules
  {
 
    #region StringRequired
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]
    public static bool StringRequired(object target, RuleArgs e)
    {
      string value = (string)Utilities.CallByName(
        target, e.PropertyName, CallType.Get);
      if (string.IsNullOrEmpty(value))
      {
        e.Description = string.Format(Resources.StringRequiredRule, RuleArgs.GetPropertyName(e));
        return false;
      }
      return true;
    }
 
    #endregion
 
    #region StringMaxLength
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]
    public static bool StringMaxLength(
      object target, RuleArgs e)
    {
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      int max = (int)args["MaxLength"];
      string value = (string)Utilities.CallByName(
        target, e.PropertyName, CallType.Get);
      if (!String.IsNullOrEmpty(value) && (value.Length > max))
      {
        string format = (string)args["Format"];
        string outValue;
        if (string.IsNullOrEmpty(format))
          outValue = max.ToString();
        else
          outValue = max.ToString(format);
        e.Description = String.Format(
          Resources.StringMaxLengthRule,
          RuleArgs.GetPropertyName(e), outValue);
        return false;
      }
      return true;
    }
 
    public class MaxLengthRuleArgs : DecoratedRuleArgs
    {
      public int MaxLength
      {
        get { return (int)this["MaxLength"]; }
      }
 
      public MaxLengthRuleArgs(
        string propertyName, int maxLength)
        : base(propertyName)
      {
        this["MaxLength"] = maxLength;
        this["Format"] = string.Empty;
      }
 
      public MaxLengthRuleArgs(Core.IPropertyInfo propertyInfo, int maxLength)
        : base(propertyInfo)
      {
        this["MaxLength"] = maxLength;
        this["Format"] = string.Empty;
      }
 
      public MaxLengthRuleArgs(
        string propertyName, string friendlyName, int maxLength)
        : base(propertyName, friendlyName)
      {
        this["MaxLength"] = maxLength;
        this["Format"] = string.Empty;
      }
 
      public MaxLengthRuleArgs(
        string propertyName, int maxLength, string format)
        : base(propertyName)
      {
        this["MaxLength"] = maxLength;
        this["Format"] = format;
      }
 
      public MaxLengthRuleArgs(Core.IPropertyInfo propertyInfo, int maxLength, string format)
        : base(propertyInfo)
      {
        this["MaxLength"] = maxLength;
        this["Format"] = format;
      }
 
      public MaxLengthRuleArgs(
        string propertyName, string friendlyName, int maxLength, string format)
        : base(propertyName, friendlyName)
      {
        this["MaxLength"] = maxLength;
        this["Format"] = format;
      }
    }
 
    #endregion
 
    #region StringMinLength
 
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods")]
    public static bool StringMinLength(
      object target, RuleArgs e)
    {
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      int min = (int)args["MinLength"];
      string value = (string)Utilities.CallByName(
        target, e.PropertyName, CallType.Get);
      if (String.IsNullOrEmpty(value) || (value.Length < min))
      {
        string format = (string)args["Format"];
        string outValue;
        if (string.IsNullOrEmpty(format))
          outValue = min.ToString();
        else
          outValue = min.ToString(format);
        e.Description = String.Format(
          Resources.StringMinLengthRule,
          RuleArgs.GetPropertyName(e), outValue);
        return false;
      }
      return true;
    }
 
    public class MinLengthRuleArgs : DecoratedRuleArgs
    {
      public int MinLength
      {
        get { return (int)this["MinLength"]; }
      }
 
      public MinLengthRuleArgs(
        string propertyName, int minLength)
        : base(propertyName)
      {
        this["MinLength"] = minLength;
        this["Format"] = string.Empty;
      }
 
      public MinLengthRuleArgs(
        Core.IPropertyInfo propertyInfo, int minLength)
        : base(propertyInfo)
      {
        this["MinLength"] = minLength;
        this["Format"] = string.Empty;
      }
 
      public MinLengthRuleArgs(
        string propertyName, string friendlyName, int minLength)
        : base(propertyName, friendlyName)
      {
        this["MinLength"] = minLength;
        this["Format"] = string.Empty;
      }
 
      public MinLengthRuleArgs(
        string propertyName, int minLength, string format)
        : base(propertyName)
      {
        this["MinLength"] = minLength;
        this["Format"] = format;
      }
 
      public MinLengthRuleArgs(
        Core.IPropertyInfo propertyInfo, int minLength, string format)
        : base(propertyInfo)
      {
        this["MinLength"] = minLength;
        this["Format"] = format;
      }
 
      public MinLengthRuleArgs(
        string propertyName, string friendlyName, int minLength, string format)
        : base(propertyName, friendlyName)
      {
        this["MinLength"] = minLength;
        this["Format"] = format;
      }
    }
 
    #endregion
 
    #region IntegerMaxValue
 
    public static bool IntegerMaxValue(object target, RuleArgs e)
    {
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      int max = (int)args["MaxValue"];
      int value = (int)Utilities.CallByName(target, e.PropertyName, CallType.Get);
      if (value > max)
      {
        string format = (string)args["Format"];
        string outValue;
        if (string.IsNullOrEmpty(format))
          outValue = max.ToString();
        else
          outValue = max.ToString(format);
        e.Description = String.Format(Resources.MaxValueRule,
          RuleArgs.GetPropertyName(e), outValue);
        return false;
      }
      return true;
    }
 
    public class IntegerMaxValueRuleArgs : DecoratedRuleArgs
    {
      public int MaxValue
      {
        get { return (int)this["MaxValue"]; }
      }
 
      public IntegerMaxValueRuleArgs(string propertyName, int maxValue)
        : base(propertyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = string.Empty;
      }
 
      public IntegerMaxValueRuleArgs(Core.IPropertyInfo propertyInfo, int maxValue)
        : base(propertyInfo)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = string.Empty;
      }
 
      public IntegerMaxValueRuleArgs(
        string propertyName, string friendlyName, int maxValue)
        : base(propertyName, friendlyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = string.Empty;
      }
 
      public IntegerMaxValueRuleArgs(string propertyName, int maxValue, string format)
        : base(propertyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = format;
      }
 
      public IntegerMaxValueRuleArgs(Core.IPropertyInfo propertyInfo, int maxValue, string format)
        : base(propertyInfo)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = format;
      }
 
      public IntegerMaxValueRuleArgs(
        string propertyName, string friendlyName, int maxValue, string format)
        : base(propertyName, friendlyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = format;
      }
    }
 
    #endregion
 
    #region IntegerMinValue
 
    public static bool IntegerMinValue(object target, RuleArgs e)
    {
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      int min = (int)args["MinValue"];
      int value = (int)Utilities.CallByName(target, e.PropertyName, CallType.Get);
      if (value < min)
      {
        string format = (string)args["Format"];
        string outValue;
        if (string.IsNullOrEmpty(format))
          outValue = min.ToString();
        else
          outValue = min.ToString(format);
        e.Description = String.Format(Resources.MinValueRule,
          RuleArgs.GetPropertyName(e), outValue);
        return false;
      }
      return true;
    }
 
    public class IntegerMinValueRuleArgs : DecoratedRuleArgs
    {
      public int MinValue
      {
        get { return (int)this["MinValue"]; }
      }
 
      public IntegerMinValueRuleArgs(string propertyName, int minValue)
        : base(propertyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = string.Empty;
      }
 
      public IntegerMinValueRuleArgs(Core.IPropertyInfo propertyInfo, int minValue)
        : base(propertyInfo)
      {
        this["MinValue"] = minValue;
        this["Format"] = string.Empty;
      }
 
      public IntegerMinValueRuleArgs(
        string propertyName, string friendlyName, int minValue)
        : base(propertyName, friendlyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = string.Empty;
      }
 
      public IntegerMinValueRuleArgs(string propertyName, int minValue, string format)
        : base(propertyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = format;
      }
 
      public IntegerMinValueRuleArgs(Core.IPropertyInfo propertyInfo, int minValue, string format)
        : base(propertyInfo)
      {
        this["MinValue"] = minValue;
        this["Format"] = format;
      }
 
      public IntegerMinValueRuleArgs(
        string propertyName, string friendlyName, int minValue, string format)
        : base(propertyName, friendlyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = format;
      }
    }
 
    #endregion
 
    #region MaxValue
 
    public static bool MaxValue<T>(object target, RuleArgs e) where T : IComparable
    {
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      PropertyInfo pi = target.GetType().GetProperty(e.PropertyName);
      T value = (T)pi.GetValue(target, null);
      T max = (T)args["MaxValue"];
 
      int result = value.CompareTo(max);
      if (result >= 1)
      {
        string format = (string)args["Format"];
        string outValue;
        if (string.IsNullOrEmpty(format))
          outValue = max.ToString();
        else
          outValue = string.Format(string.Format("{{0:{0}}}", format), max);
        e.Description = string.Format(Resources.MaxValueRule,
          RuleArgs.GetPropertyName(e), outValue);
        return false;
      }
      else
        return true;
    }
 
    public class MaxValueRuleArgs<T> : DecoratedRuleArgs
    {
      public T MaxValue
      {
        get { return (T)this["MaxValue"]; }
      }
 
      public MaxValueRuleArgs(string propertyName, T maxValue)
        : base(propertyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = string.Empty;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MaxValueRuleArgs(Core.IPropertyInfo propertyInfo, T maxValue)
        : base(propertyInfo)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = string.Empty;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MaxValueRuleArgs(
        string propertyName, string friendlyName, T maxValue)
        : base(propertyName, friendlyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = string.Empty;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MaxValueRuleArgs(string propertyName, T maxValue, string format)
        : base(propertyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = format;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MaxValueRuleArgs(Core.IPropertyInfo propertyInfo, T maxValue, string format)
        : base(propertyInfo)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = format;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MaxValueRuleArgs(
        string propertyName, string friendlyName, T maxValue, string format)
        : base(propertyName, friendlyName)
      {
        this["MaxValue"] = maxValue;
        this["Format"] = format;
        this["ValueType"] = typeof(T).FullName;
      }
    }
 
    #endregion
 
    #region MinValue
 
    public static bool MinValue<T>(object target, RuleArgs e) where T : IComparable
    {
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      PropertyInfo pi = target.GetType().GetProperty(e.PropertyName);
      T value = (T)pi.GetValue(target, null);
      T min = (T)args["MinValue"];
 
      int result = value.CompareTo(min);
      if (result <= -1)
      {
        string format = (string)args["Format"];
        string outValue;
        if (string.IsNullOrEmpty(format))
          outValue = min.ToString();
        else
          outValue = string.Format(string.Format("{{0:{0}}}", format), min);
        e.Description = string.Format(Resources.MinValueRule,
          RuleArgs.GetPropertyName(e), outValue);
        return false;
      }
      else
        return true;
    }
 
    public class MinValueRuleArgs<T> : DecoratedRuleArgs
    {
      public T MinValue
      {
        get { return (T)this["MinValue"]; }
      }
 
      public MinValueRuleArgs(string propertyName, T minValue)
        : base(propertyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = string.Empty;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MinValueRuleArgs(Core.IPropertyInfo propertyInfo, T minValue)
        : base(propertyInfo)
      {
        this["MinValue"] = minValue;
        this["Format"] = string.Empty;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MinValueRuleArgs(
        string propertyName, string friendlyName, T minValue)
        : base(propertyName, friendlyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = string.Empty;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MinValueRuleArgs(string propertyName, T minValue, string format)
        : base(propertyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = format;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MinValueRuleArgs(Core.IPropertyInfo propertyInfo, T minValue, string format)
        : base(propertyInfo)
      {
        this["MinValue"] = minValue;
        this["Format"] = format;
        this["ValueType"] = typeof(T).FullName;
      }
 
      public MinValueRuleArgs(
        string propertyName, string friendlyName, T minValue, string format)
        : base(propertyName, friendlyName)
      {
        this["MinValue"] = minValue;
        this["Format"] = format;
        this["ValueType"] = typeof(T).FullName;
      }
    }
 
    #endregion
 
    #region RegEx
 
    public static bool RegExMatch(object target, RuleArgs e)
    {
      bool ruleSatisfied = false;
      DecoratedRuleArgs args = (DecoratedRuleArgs)e;
      RegExRuleArgs.NullResultOptions nullOption =
        (RegExRuleArgs.NullResultOptions)args["NullOption"];
      Regex expression = (Regex)args["RegEx"];
 
      object value = Utilities.CallByName(target, e.PropertyName, CallType.Get);
      if (value == null && nullOption == RegExRuleArgs.NullResultOptions.ConvertToEmptyString)
        value = string.Empty;
 
      if (value == null)
      {
        // if the value is null at this point
        // then return the pre-defined result value
        ruleSatisfied = (nullOption == RegExRuleArgs.NullResultOptions.ReturnTrue);
      }
      else
      {
        // the value is not null, so run the 
        // regular expression
        ruleSatisfied = expression.IsMatch(value.ToString());
      }
 
      if (!ruleSatisfied)
      {
        e.Description = String.Format(Resources.RegExMatchRule, RuleArgs.GetPropertyName(e));
        return false;
      }
      else
        return true;
    }
 
    public enum RegExPatterns
    {
      SSN,
      Email
    }
 
    public class RegExRuleArgs : DecoratedRuleArgs
    {
      #region NullResultOptions
 
      public enum NullResultOptions
      {
        ReturnFalse,
        ReturnTrue,
        ConvertToEmptyString
      }
 
      #endregion
 
      public Regex RegEx
      {
        get { return (Regex)this["RegEx"]; }
      }
 
      public NullResultOptions NullResult
      {
        get
        {
          return (NullResultOptions)this["NullOption"];
        }
      }
 
      public RegExRuleArgs(string propertyName, RegExPatterns pattern)
        : base(propertyName)
      {
        this["RegEx"] = new Regex(GetPattern(pattern));
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(Core.IPropertyInfo propertyInfo, RegExPatterns pattern)
        : base(propertyInfo)
      {
        this["RegEx"] = new Regex(GetPattern(pattern));
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(
        string propertyName, string friendlyName, RegExPatterns pattern)
        : base(propertyName, friendlyName)
      {
        this["RegEx"] = new Regex(GetPattern(pattern));
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(string propertyName, string pattern)
        : base(propertyName)
      {
        this["RegEx"] = new Regex(pattern);
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(Core.IPropertyInfo propertyInfo, string pattern)
        : base(propertyInfo)
      {
        this["RegEx"] = new Regex(pattern);
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(
        string propertyName, string friendlyName, string pattern)
        : base(propertyName, friendlyName)
      {
        this["RegEx"] = new Regex(pattern);
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(string propertyName, System.Text.RegularExpressions.Regex regEx)
        : base(propertyName)
      {
        this["RegEx"] = regEx;
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(Core.IPropertyInfo propertyInfo, System.Text.RegularExpressions.Regex regEx)
        : base(propertyInfo)
      {
        this["RegEx"] = regEx;
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(
        string propertyName, string friendlyName, System.Text.RegularExpressions.Regex regEx)
        : base(propertyName, friendlyName)
      {
        this["RegEx"] = regEx;
        this["NullOption"] = NullResultOptions.ReturnFalse;
      }
 
      public RegExRuleArgs(string propertyName, RegExPatterns pattern, NullResultOptions nullResult)
        : base(propertyName)
      {
        this["RegEx"] = new Regex(GetPattern(pattern));
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(Core.IPropertyInfo propertyInfo, RegExPatterns pattern, NullResultOptions nullResult)
        : base(propertyInfo)
      {
        this["RegEx"] = new Regex(GetPattern(pattern));
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(
        string propertyName, string friendlyName, RegExPatterns pattern, NullResultOptions nullResult)
        : base(propertyName, friendlyName)
      {
        this["RegEx"] = new Regex(GetPattern(pattern));
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(string propertyName, string pattern, NullResultOptions nullResult)
        : base(propertyName)
      {
        this["RegEx"] = new Regex(pattern);
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(Core.IPropertyInfo propertyInfo, string pattern, NullResultOptions nullResult)
        : base(propertyInfo)
      {
        this["RegEx"] = new Regex(pattern);
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(
        string propertyName, string friendlyName, string pattern, NullResultOptions nullResult)
        : base(propertyName, friendlyName)
      {
        this["RegEx"] = new Regex(pattern);
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(string propertyName, System.Text.RegularExpressions.Regex regEx, NullResultOptions nullResult)
        : base(propertyName)
      {
        this["RegEx"] = regEx;
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(Core.IPropertyInfo propertyInfo, System.Text.RegularExpressions.Regex regEx, NullResultOptions nullResult)
        : base(propertyInfo)
      {
        this["RegEx"] = regEx;
        this["NullOption"] = nullResult;
      }
 
      public RegExRuleArgs(
        string propertyName, string friendlyName, System.Text.RegularExpressions.Regex regEx, NullResultOptions nullResult)
        : base(propertyName, friendlyName)
      {
        this["RegEx"] = regEx;
        this["NullOption"] = nullResult;
      }
 
      public static string GetPattern(RegExPatterns pattern)
      {
        switch (pattern)
        {
          case RegExPatterns.SSN:
            return @"^\d{3}-\d{2}-\d{4}$";
          case RegExPatterns.Email:
            return @"^[A-Za-z0-9._%-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}$";
          default:
            return string.Empty;
        }
      }
    }
 
    #endregion
 
    #region CanRead
 
    public static bool CanRead(object target, RuleArgs e)
    {
      bool isAuthorized = true;
 
      BusinessBase business = target as BusinessBase;
      if (business != null && !string.IsNullOrEmpty(e.PropertyName))
        isAuthorized = business.CanReadProperty(e.PropertyName);
 
      if (!isAuthorized)
      {
        e.Severity = RuleSeverity.Information;
        e.Description = string.Format("You are not authorized to read this field {0}", RuleArgs.GetPropertyName(e));
      }
 
      return isAuthorized;
    }
 
    #endregion
 
    #region CanWrite
 
    public static bool CanWrite(object target, RuleArgs e)
    {
      bool isAuthorized = true;
 
      BusinessBase business = target as BusinessBase;
      if (business != null && !string.IsNullOrEmpty(e.PropertyName))
        isAuthorized = business.CanWriteProperty(e.PropertyName);
 
      if (!isAuthorized)
      {
        e.Severity = RuleSeverity.Information;
        e.Description = string.Format("You are not authorized to write to this field {0}", RuleArgs.GetPropertyName(e));
      }
 
      return isAuthorized;
    }
 
    #endregion
 
    #region DataAnnotations
 
    public class DataAnnotationRuleArgs : RuleArgs
    {
      public DataAnnotationRuleArgs(string name, System.ComponentModel.DataAnnotations.ValidationAttribute attribute)
        : base(name)
      {
        Attribute = attribute;
      }
 
      public System.ComponentModel.DataAnnotations.ValidationAttribute Attribute { get; set; }
 
      public override string ToString()
      {
        return string.Format("{0}?Attribute={1}", base.ToString(), Attribute.GetType().FullName);
      }
    }
 
    public static bool DataAnnotation(object target, RuleArgs e)
    {
      var args = (DataAnnotationRuleArgs)e;
      object pValue = Utilities.CallByName(target, e.PropertyName, CallType.Get);
 
      var ctx = new System.ComponentModel.DataAnnotations.ValidationContext(target, null, null)
      {
        MemberName = RuleArgs.GetPropertyName(e)
      };
 
      var result = args.Attribute.GetValidationResult(pValue, ctx);
 
      if (result != null)
      {
        e.Description = result.ErrorMessage;
        return false;
      }
 
      return true;
    }
 
    #endregion
  }
}