Csla/Rules/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>Base class used to create common rules.</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Csla.Properties;
using System.Text.RegularExpressions;
 
namespace Csla.Rules.CommonRules
{
  public abstract class CommonBusinessRule : PropertyRule
  {
    public RuleSeverity Severity { get; set; }
 
    protected CommonBusinessRule(Csla.Core.IPropertyInfo primaryProperty)  : base(primaryProperty)
    {
      Severity = RuleSeverity.Error;
    }
 
    protected CommonBusinessRule()
    {
      Severity = RuleSeverity.Error;
    }
  }
 
  public class DataAnnotation : BusinessRule
  {
    public System.ComponentModel.DataAnnotations.ValidationAttribute Attribute { get; private set; }
 
    public DataAnnotation(Csla.Core.IPropertyInfo primaryProperty, System.ComponentModel.DataAnnotations.ValidationAttribute attribute)
      : base(primaryProperty)
    {
      this.Attribute = attribute;
      RuleUri.AddQueryParameter("a", attribute.GetType().FullName);
      if (primaryProperty != null)
        InputProperties.Add(primaryProperty);
    }
 
    protected override void Execute(IRuleContext context)
    {
      var ctx = new System.ComponentModel.DataAnnotations.ValidationContext(context.Target, null, null);
      if (PrimaryProperty != null)
        ctx.MemberName = PrimaryProperty.FriendlyName;
 
      System.ComponentModel.DataAnnotations.ValidationResult result = null;
      try
      {
        if (PrimaryProperty != null)
        {
          object value = context.InputPropertyValues[PrimaryProperty];
          result = this.Attribute.GetValidationResult(value, ctx);
        }
        else
        {
          result = this.Attribute.GetValidationResult(null, ctx);
        }
      }
      catch (Exception ex)
      {
        context.AddErrorResult(ex.Message);
      }
      if (result != null)
        context.AddErrorResult(result.ErrorMessage);
    }
  }
 
  public class Required : CommonBusinessRule
  {
    public Required(Csla.Core.IPropertyInfo primaryProperty)
      : base(primaryProperty)
    {
      InputProperties.Add(primaryProperty);
    }
 
 
    public Required(Csla.Core.IPropertyInfo primaryProperty, string message)
      : this(primaryProperty)
    {
      MessageText = message;
    }
 
    public Required(Csla.Core.IPropertyInfo primaryProperty, Func<string> messageDelegate )
      : this(primaryProperty)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override string GetMessage()
    {
      return HasMessageDelegate ? base.MessageText : Csla.Properties.Resources.StringRequiredRule;
    }
 
    protected override void Execute(IRuleContext context)
    {
      var value = context.InputPropertyValues[PrimaryProperty];
      if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
      {
        var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName);
        context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity });
      }
    }
  }
 
  public class MaxLength : CommonBusinessRule
  {
    public int Max { get; private set; }
 
    public MaxLength(Csla.Core.IPropertyInfo primaryProperty, int max)
      : base(primaryProperty)
    {
      Max = max;
      this.RuleUri.AddQueryParameter("max", max.ToString());
      InputProperties.Add(primaryProperty);
    }
 
    public MaxLength(Csla.Core.IPropertyInfo primaryProperty, int max, string message)
      : this(primaryProperty, max)
    {
      MessageText = message;
    }
 
    public MaxLength(Csla.Core.IPropertyInfo primaryProperty, int max, Func<string> messageDelegate)
      : this(primaryProperty, max)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override string GetMessage()
    {
        return HasMessageDelegate ? base.MessageText : Csla.Properties.Resources.StringMaxLengthRule;
    }
 
    protected override void Execute(IRuleContext context)
    {
      var value = context.InputPropertyValues[PrimaryProperty];
      if (value != null && value.ToString().Length > Max)
      {
        var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName, Max);
        context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity });
      }
    }
  }
 
  public class MinLength : CommonBusinessRule
  {
    public int Min { get; private set; }
 
    public MinLength(Csla.Core.IPropertyInfo primaryProperty, int min)
      : base(primaryProperty)
    {
      Min = min;
      this.RuleUri.AddQueryParameter("min", min.ToString());
      InputProperties.Add(primaryProperty);
    }
 
    public MinLength(Csla.Core.IPropertyInfo primaryProperty, int min, string message)
      : this(primaryProperty, min)
    {
      MessageText = message;
    }
 
    public MinLength(Csla.Core.IPropertyInfo primaryProperty, int min, Func<string> messageDelegate)
      : this(primaryProperty, min)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override string GetMessage()
    {
      return HasMessageDelegate ? base.MessageText : Csla.Properties.Resources.StringMinLengthRule;
    }
 
    protected override void Execute(IRuleContext context)
    {
      var value = context.InputPropertyValues[PrimaryProperty];
      if (value != null && value.ToString().Length < Min)
      {
        var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName, Min);
        context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity });
      }
    }
  }
 
  public class MinValue<T> : CommonBusinessRule
    where T : IComparable
  {
    public T Min { get; private set; }
    public string Format { get; set; }
 
    public MinValue(Csla.Core.IPropertyInfo primaryProperty, T min) 
      : base(primaryProperty) 
    {
      Min = min;
      this.RuleUri.AddQueryParameter("min", min.ToString());
      InputProperties.Add(primaryProperty);
    }
 
    public MinValue(Csla.Core.IPropertyInfo primaryProperty, T min,  string message)
      : this(primaryProperty, min)
    {
      MessageText = message;
    }
 
    public MinValue(Csla.Core.IPropertyInfo primaryProperty, T min, Func<string> messageDelegate)
      : this(primaryProperty, min)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override string GetMessage()
    {
      return HasMessageDelegate ? base.MessageText : Csla.Properties.Resources.MinValueRule;
    }
 
    protected override void Execute(IRuleContext context)
    {
      var value = context.InputPropertyValues[PrimaryProperty] != null
                      ? (T)context.InputPropertyValues[PrimaryProperty]
                      : PrimaryProperty.DefaultValue != null
                        ? (T)PrimaryProperty.DefaultValue
                        : default(T);
 
      var result = value.CompareTo(Min);
      if (result <= -1)
      {
        string outValue;
        if (string.IsNullOrEmpty(Format))
          outValue = Min.ToString();
        else
          outValue = string.Format(string.Format("{{0:{0}}}", Format), Min);
        var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName, outValue);
        context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity });
      }
    }
  }
 
  public class MaxValue<T> : CommonBusinessRule
    where T : IComparable
  {
    public T Max { get; private set; }
    public string Format { get; set; }
 
    public MaxValue(Csla.Core.IPropertyInfo primaryProperty, T max)
      : base(primaryProperty)
    {
      Max = max;
      this.RuleUri.AddQueryParameter("max", max.ToString());
      InputProperties.Add(primaryProperty);
    }
 
    public MaxValue(Csla.Core.IPropertyInfo primaryProperty, T max, string message)
      : this(primaryProperty, max)
    {
      MessageText = message;
    }
 
    public MaxValue(Csla.Core.IPropertyInfo primaryProperty, T max, Func<string> messageDelegate)
      : this(primaryProperty, max)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override string GetMessage()
    {
      return HasMessageDelegate ? base.MessageText : Csla.Properties.Resources.MaxValueRule;
    }
 
    protected override void Execute(IRuleContext context)
    {
      var value = context.InputPropertyValues[PrimaryProperty] != null
                      ? (T)context.InputPropertyValues[PrimaryProperty]
                      : PrimaryProperty.DefaultValue != null 
                        ? (T)PrimaryProperty.DefaultValue
                        : default(T);
 
      var result = value.CompareTo(Max);
      if (result >= 1)
      {
        string outValue;
        if (string.IsNullOrEmpty(Format))
          outValue = Max.ToString();
        else
          outValue = string.Format(string.Format("{{0:{0}}}", Format), Max);
        var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName, outValue);
        context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity });
      }
    }
  }
 
  public class RegExMatch : CommonBusinessRule
  {
    #region NullResultOptions
 
    public enum NullResultOptions
    {
      ReturnFalse,
      ReturnTrue,
      ConvertToEmptyString
    }
 
    #endregion
 
    public string Expression { get; private set; }
 
    public NullResultOptions NullOption { get; set; }
 
    public RegExMatch(Csla.Core.IPropertyInfo primaryProperty, string expression)
      : base(primaryProperty)
    {
      Expression = expression;
      RuleUri.AddQueryParameter("e", expression);
      InputProperties.Add(primaryProperty);
    }
 
    public RegExMatch(Csla.Core.IPropertyInfo primaryProperty, string expression, string message)
      : this(primaryProperty, expression)
    {
      MessageText = message;
    }
 
 
    public RegExMatch(Csla.Core.IPropertyInfo primaryProperty, string expression, Func<string> messageDelegate)
      : this(primaryProperty, expression)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override string GetMessage()
    {
      return HasMessageDelegate ? base.MessageText : Csla.Properties.Resources.RegExMatchRule;
    }
 
    protected override void Execute(IRuleContext context)
    {
      var value = context.InputPropertyValues[PrimaryProperty];
      bool ruleSatisfied;
      var expression = new Regex(Expression);
 
      if (value == null && NullOption == 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 == NullResultOptions.ReturnTrue);
      }
      else
      {
        // the value is not null, so run the 
        // regular expression
        ruleSatisfied = expression.IsMatch(value.ToString());
      }
 
      if (!ruleSatisfied)
      {
        var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName);
        context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity });
      }
    }
  }
 
  public class InfoMessage : BusinessRule
  {
    public string MessageText
    {
      get { return _messageDelegate.Invoke(); }
      protected set { MessageDelegate = () => value; }
    }
 
    private Func<string> _messageDelegate;
 
    public Func<string> MessageDelegate
    {
      get { return _messageDelegate; }
      set { _messageDelegate = value; }
    }
 
    public InfoMessage(Csla.Core.IPropertyInfo primaryProperty)
      : base(primaryProperty)
    {
      Priority = 1;
    }
 
    public InfoMessage(Csla.Core.IPropertyInfo primaryProperty, string messageText)
      : this(primaryProperty)
    {
      MessageText = messageText;
    }
 
    public InfoMessage(Csla.Core.IPropertyInfo primaryProperty, Func<string> messageDelegate)
      : this(primaryProperty)
    {
      MessageDelegate = messageDelegate;
    }
 
    protected override void Execute(IRuleContext context)
    {
      context.AddInformationResult(MessageText);
    }
  }
 
  public class Lambda : BusinessRule
  {
    public Lambda(Action<IRuleContext> rule)
    {
      Initialize(rule);
    }
    
    public Lambda(Csla.Core.IPropertyInfo primaryProperty, Action<IRuleContext> rule)
      : base(primaryProperty)
    {
      Initialize(rule);
    }
 
    private void Initialize(Action<IRuleContext> rule)
    {
      Rule = rule;
      var methodName = Rule.Method.ToString();
      base.RuleUri.AddQueryParameter("r", Convert.ToBase64String(Encoding.Unicode.GetBytes(methodName)));
    }
 
    public void AddQueryParameter(string key, string value)
    {
      base.RuleUri.AddQueryParameter(key, value);
    }
 
    private Action<IRuleContext> Rule { get; set; }
 
    protected override void Execute(IRuleContext context)
    {
      Rule(context);
    }
  }
 
  public class Dependency : BusinessRule
  {
    public Dependency(Csla.Core.IPropertyInfo primaryProperty, params Csla.Core.IPropertyInfo[] dependencyProperty)
      : base(primaryProperty)
    {
      AffectedProperties.AddRange(dependencyProperty);
    }
  }
}