RuleExtensions.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="PropertyHelper.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>internal implementation to get a registered property</summary>
//----------------------------------------------------------------------
using System;
using System.Linq;
using System.Text;
using Csla.Core;
using Csla.Core.FieldManager;
using Csla.Rules;
using Csla.Rules.CommonRules;
 
namespace Csla.Validation
{
 
  public delegate bool RuleHandler(object target, RuleArgs e);
 
  public delegate bool RuleHandler<T, R>(T target, R e) where R : RuleArgs;
 
  //[Obsolete("For migration of older apps to Csla 4.x only")]
  public static class RuleExtensions
  {
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules, RuleHandler<T,RuleArgs> ruleHandler, Csla.Core.IPropertyInfo primaryProperty, RuleArgs ruleArgs, int priority) where T : BusinessBase<T>
    {
      var rule = new Csla.Rules.CommonRules.Lambda(primaryProperty, (o) =>
                  {
 
                    var target = (T)o.Target;
                    using (new ObjectAccessor().BypassPropertyChecks(target))
                    {
                      if (!ruleHandler(target, ruleArgs))
                      {
                        o.Results.Add(new RuleResult(o.Rule.RuleName, o.Rule.PrimaryProperty, ruleArgs.Description) { Severity = ruleArgs.Severity, StopProcessing = ruleArgs.StopProcessing });
                      }
                      else if (ruleArgs.StopProcessing)
                      {
                        o.AddSuccessResult(true);
                      }
                      else
                      {
                        o.AddSuccessResult(false);
                      }
                      ruleArgs.StopProcessing = false;
                    }
                  });
 
#if NETFX_CORE
      var methodName = Guid.NewGuid().ToString();
#else
      var methodName = ruleHandler.Method.ToString();
#endif
      rule.AddQueryParameter("r", Convert.ToBase64String(Encoding.Unicode.GetBytes(methodName)));
      rule.Priority = priority;
      businessRules.AddRule(rule);
    }
 
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules, RuleHandler<T, RuleArgs> ruleHandler, Csla.Core.IPropertyInfo primaryProperty) where T : BusinessBase<T>
    {
      AddRule(businessRules, ruleHandler,  primaryProperty, new RuleArgs(primaryProperty), 0);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules,  RuleHandler<T,RuleArgs> ruleHandler , Csla.Core.IPropertyInfo primaryProperty, int priority) where T : BusinessBase<T>
    {
      AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), priority);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules, RuleHandler<T, RuleArgs> ruleHandler, string primaryPropertyName, int priority) where T : BusinessBase<T>
    {
        if (string.IsNullOrEmpty(primaryPropertyName)) throw new ArgumentException("primaryPropertyName");
 
        var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, primaryPropertyName);
        AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), priority);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules, RuleHandler<T, RuleArgs> ruleHandler, RuleArgs args) where T : BusinessBase<T>
    {
      var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, args.PropertyName);
      AddRule(businessRules, ruleHandler, primaryProperty, args, 0);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules, RuleHandler<T, RuleArgs> ruleHandler, RuleArgs args, int priority) where T : BusinessBase<T>
    {
      var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, args.PropertyName);
      AddRule(businessRules, ruleHandler, primaryProperty, args, priority);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule<T>(this BusinessRules businessRules, RuleHandler<T, RuleArgs> ruleHandler, string primaryPropertyName) where T : BusinessBase<T>
    {
        if (string.IsNullOrEmpty(primaryPropertyName)) throw new ArgumentException("primaryPropertyName");
 
        var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, primaryPropertyName);
        AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), 0);
    }
 
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, Csla.Core.IPropertyInfo primaryProperty, RuleArgs ruleArgs, int priority) 
    {
      var rule = new Csla.Rules.CommonRules.Lambda(primaryProperty, (o) =>
                  {
 
                    var target = (Csla.Core.BusinessBase)o.Target;
                    using (new ObjectAccessor().BypassPropertyChecks(target))
                    {
                      if (!ruleHandler(target, ruleArgs))
                      {
                        o.Results.Add(new RuleResult(o.Rule.RuleName, o.Rule.PrimaryProperty, ruleArgs.Description) { Severity = ruleArgs.Severity, StopProcessing = ruleArgs.StopProcessing });
                      }
                      else if (ruleArgs.StopProcessing)
                      {
                        o.AddSuccessResult(true);
                      }
                      else
                      {
                        o.AddSuccessResult(false);
                      }
                      ruleArgs.StopProcessing = false;
                    }
                  });
 
#if NETFX_CORE
      var methodName = Guid.NewGuid().ToString();
#else
      var methodName = ruleHandler.Method.ToString();
#endif
      rule.AddQueryParameter("r", Convert.ToBase64String(Encoding.Unicode.GetBytes(methodName)));
      rule.Priority = priority;
      businessRules.AddRule(rule);
    }
 
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, Csla.Core.IPropertyInfo primaryProperty) 
    {
      AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), 0);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, Csla.Core.IPropertyInfo primaryProperty, int priority) 
    {
      AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), priority);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, string primaryPropertyName, int priority)
    {
        if (string.IsNullOrEmpty(primaryPropertyName)) throw new ArgumentException("primaryPropertyName");
        var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, primaryPropertyName);
        AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), priority);
    }
 
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, string primaryPropertyName)
    {
        if (string.IsNullOrEmpty(primaryPropertyName)) throw new ArgumentException("primaryPropertyName");
 
        var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, primaryPropertyName);
        AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), 0);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, RuleArgs args) 
    {
      var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, args.PropertyName);
      AddRule(businessRules, ruleHandler, primaryProperty, args, 0);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, RuleArgs args, int priority) 
    {
      var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, args.PropertyName);
      AddRule(businessRules, ruleHandler, primaryProperty, args, priority);
    }
 
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddDependentProperty(this BusinessRules businessRules, IPropertyInfo propertyInfo, IPropertyInfo dependentPropertyInfo, bool isBidirectional)
    {
      if (propertyInfo == null) throw new ArgumentNullException("propertyInfo");
      if (dependentPropertyInfo == null) throw new ArgumentNullException("dependentPropertyInfo");
 
      businessRules.AddRule(new Dependency(propertyInfo, dependentPropertyInfo));
      if (isBidirectional)
        businessRules.AddRule(new Dependency(dependentPropertyInfo, propertyInfo));
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddDependentProperty(this BusinessRules businessRules, IPropertyInfo propertyInfo, IPropertyInfo dependentPropertyInfo)
    {
      AddDependentProperty(businessRules, propertyInfo, dependentPropertyInfo, false);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddDependentProperty(this BusinessRules businessRules, string propertyName, string dependentPropertyName)
    {
        AddDependentProperty(businessRules, propertyName, dependentPropertyName, false);
    }
 
    //[Obsolete("For migration of older apps to Csla 4.x only")]
    public static void AddDependentProperty(this BusinessRules businessRules, string propertyName, string dependentPropertyName, bool isBidirectional)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      var dependentPropertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, dependentPropertyName);
      
      AddDependentProperty(businessRules, propertyInfo, dependentPropertyInfo, isBidirectional);
    }
 
    #region  Add Per-Type Roles
 
    public static void AllowRead(this BusinessRules businessRules, Core.IPropertyInfo propertyInfo, params string[] roles)
    {
      businessRules.AddRule(new IsInRole(AuthorizationActions.ReadProperty, propertyInfo, roles));
    }
 
    public static void AllowRead(this BusinessRules businessRules, string propertyName, params string[] roles)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      businessRules.AddRule(new IsInRole(AuthorizationActions.ReadProperty, propertyInfo, roles));
    }
 
    public static void DenyRead(this BusinessRules businessRules, Core.IPropertyInfo propertyInfo, params string[] roles)
    {
      businessRules.AddRule(new IsNotInRole(AuthorizationActions.ReadProperty, propertyInfo, roles));
    }
 
    public static void DenyRead(this BusinessRules businessRules, string propertyName, params string[] roles)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      businessRules.AddRule(new IsNotInRole(AuthorizationActions.ReadProperty, propertyInfo, roles));
    }
 
    public static void AllowWrite(this BusinessRules businessRules, Core.IPropertyInfo propertyInfo, params string[] roles)
    {
      businessRules.AddRule(new IsInRole(AuthorizationActions.WriteProperty, propertyInfo, roles));
    }
 
    public static void AllowWrite(this BusinessRules businessRules, string propertyName, params string[] roles)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      businessRules.AddRule(new IsInRole(AuthorizationActions.WriteProperty, propertyInfo, roles));
    }
 
    public static void DenyWrite(this BusinessRules businessRules, Core.IPropertyInfo propertyInfo, params string[] roles)
    {
      businessRules.AddRule(new IsNotInRole(AuthorizationActions.WriteProperty, propertyInfo, roles));
    }
 
    public static void DenyWrite(this BusinessRules businessRules, string propertyName, params string[] roles)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      businessRules.AddRule(new IsNotInRole(AuthorizationActions.WriteProperty, propertyInfo, roles));
    }
 
    public static void AllowExecute(this BusinessRules businessRules, Core.IMemberInfo memberInfo, params string[] roles)
    {
      businessRules.AddRule(new IsInRole(AuthorizationActions.ExecuteMethod, memberInfo, roles));
    }
 
    public static void AllowExecute(this BusinessRules businessRules, string methodName, params string[] roles)
    {
      var methodInfo = new MethodInfo(methodName);
      businessRules.AddRule(new IsInRole(AuthorizationActions.ReadProperty, methodInfo, roles));
    }
 
    public static void DenyExecute(this BusinessRules businessRules, Core.IMemberInfo methodInfo, params string[] roles)
    {
      businessRules.AddRule(new IsNotInRole(AuthorizationActions.ReadProperty, methodInfo, roles));
    }
 
    public static void DenyExecute(this BusinessRules businessRules, string methodName, params string[] roles)
    {
      var methodInfo = new MethodInfo(methodName);
      businessRules.AddRule(new IsNotInRole(AuthorizationActions.ReadProperty, methodInfo, roles));
    }
 
    #endregion
 
    #region Check Roles
 
    public static bool HasReadAllowedRoles(this BusinessRules businessRules, string propertyName)
    {
      return true;
    }
 
    public static bool IsReadAllowed(this BusinessRules businessRules, string propertyName)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      return businessRules.HasPermission(AuthorizationActions.ReadProperty, propertyInfo);
    }
 
    public static bool HasReadDeniedRoles(this BusinessRules businessRules, string propertyName)
    {
      return true;
    }
 
    public static bool IsReadDenied(this BusinessRules businessRules, string propertyName)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      return !businessRules.HasPermission(AuthorizationActions.ReadProperty, propertyInfo);
    }
 
    public static bool HasWriteAllowedRoles(this BusinessRules businessRules, string propertyName)
    {
      return true;
    }
 
    public static bool IsWriteAllowed(this BusinessRules businessRules, string propertyName)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      return businessRules.HasPermission(AuthorizationActions.WriteProperty, propertyInfo);
    }
 
    public static bool HasWriteDeniedRoles(this BusinessRules businessRules, string propertyName)
    {
      return true;
    }
 
    public static bool IsWriteDenied(this BusinessRules businessRules, string propertyName)
    {
      var propertyInfo = PropertyHelper.GetRegisteredProperty(businessRules, propertyName);
      return !businessRules.HasPermission(AuthorizationActions.ReadProperty, propertyInfo);
    }
 
    public static bool HasExecuteAllowedRoles(this BusinessRules businessRules, string methodName)
    {
      return true;
    }
 
    public static bool IsExecuteAllowed(this BusinessRules businessRules, string methodName)
    {
      var methodInfo = new MethodInfo(methodName);
      return businessRules.HasPermission(AuthorizationActions.ExecuteMethod, methodInfo);
    }
 
    public static bool HasExecuteDeniedRoles(this BusinessRules businessRules, string methodName)
    {
      return true;
    }
 
    public static bool IsExecuteDenied(this BusinessRules businessRules, string methodName)
    {
      var methodInfo = new MethodInfo(methodName);
      return businessRules.HasPermission(AuthorizationActions.ReadProperty, methodInfo);
    }
 
    #endregion
  }
}