RuleContext.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="RuleContext.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Context information provided to a business rule</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Csla.Core;
using Csla.Properties;
using Csla.Threading;
 
namespace Csla.Rules
{
  [Flags]
  public enum RuleContextModes
  {
    Any = 247,
    CheckRules = 1,
    CheckObjectRules = 2,
    PropertyChanged = 4,
    AsAffectedPoperty = 8,
  }
 
  public class RuleContext : IRuleContext
  {
    [EditorBrowsable(EditorBrowsableState.Never)]
    public IBusinessRuleBase Rule { get; internal set; }
 
    public object Target { get; internal set; }
 
    public Dictionary<Csla.Core.IPropertyInfo, object> InputPropertyValues { get; internal set; }
 
    private LazySingleton<List<IPropertyInfo>> _dirtyProperties;
    [EditorBrowsable(EditorBrowsableState.Never)]
    public List<IPropertyInfo> DirtyProperties
    {
      get
      {
        if (!_dirtyProperties.IsValueCreated)
          return null;
        return _dirtyProperties.Value;
      }
    }
 
    private readonly LazySingleton<Dictionary<IPropertyInfo, object>> _outputPropertyValues;
    [EditorBrowsable(EditorBrowsableState.Never)]
    public Dictionary<Csla.Core.IPropertyInfo, object> OutputPropertyValues
    {
      get
      {
        if (!_outputPropertyValues.IsValueCreated)
          return null;
        return _outputPropertyValues.Value;
      }
    }
 
    private List<RuleResult> _results;
    [EditorBrowsable(EditorBrowsableState.Never)]
    public List<RuleResult> Results
    {
      get
      {
        if (_results == null)
          _results = new List<RuleResult>();
        return _results;
      }
      private set
      {
        _results = value;
      }
    }
 
    private readonly Action<IRuleContext> _completeHandler;
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    public string OriginPropertyName { get; internal set; }
 
    public RuleContextModes ExecuteContext { get; internal set; }
 
 
    public void ExecuteRule(IBusinessRuleBase innerRule)
    {
      var chainedContext = GetChainedContext(innerRule);
      if (BusinessRules.CanRunRule(innerRule, chainedContext.ExecuteContext))
      {
        if (innerRule is IBusinessRule syncRule)
          syncRule.Execute(chainedContext);
        else if (innerRule is IBusinessRuleAsync asyncRule)
          asyncRule.ExecuteAsync(chainedContext).ContinueWith((t) => { chainedContext.Complete(); });
        else
          throw new ArgumentOutOfRangeException(innerRule.GetType().FullName);
      }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    public bool IsCascadeContext
    {
      get { return (ExecuteContext & RuleContextModes.AsAffectedPoperty) > 0; }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    public bool IsPropertyChangedContext
    {
      get { return (ExecuteContext & RuleContextModes.PropertyChanged) > 0; }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    public bool IsCheckRulesContext
    {
      get { return (ExecuteContext & RuleContextModes.CheckRules) > 0; }
    }
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    public bool IsCheckObjectRulesContext
    {
      get { return (ExecuteContext & RuleContextModes.CheckObjectRules) > 0; }
    }
 
    internal RuleContext(Action<IRuleContext> completeHandler)
    {
      _completeHandler = completeHandler;
      _outputPropertyValues = new LazySingleton<Dictionary<IPropertyInfo, object>>();
      _dirtyProperties = new LazySingleton<List<IPropertyInfo>>();
    }
 
    internal RuleContext(Action<IRuleContext> completeHandler, RuleContextModes executeContext) : this(completeHandler)
    {
      ExecuteContext = executeContext;
    }
 
    internal RuleContext(Action<IRuleContext> completeHandler, LazySingleton<Dictionary<IPropertyInfo, object>> outputPropertyValues, LazySingleton<List<IPropertyInfo>> dirtyProperties, RuleContextModes executeContext)
    {
      _completeHandler = completeHandler;
      _outputPropertyValues = outputPropertyValues;
      _dirtyProperties = dirtyProperties;
      ExecuteContext = executeContext;
    }
 
    public RuleContext(Action<IRuleContext> completeHandler, IBusinessRuleBase rule, object target, Dictionary<Csla.Core.IPropertyInfo, object> inputPropertyValues)
      : this(completeHandler)
    {
      Rule = rule;
      if (rule.PrimaryProperty != null)
        OriginPropertyName = rule.PrimaryProperty.Name;
      Target = target;
      InputPropertyValues = inputPropertyValues;
      ExecuteContext = RuleContextModes.PropertyChanged;
    }
 
    public IRuleContext GetChainedContext(IBusinessRuleBase rule)
    {
      var result = new RuleContext(_completeHandler, _outputPropertyValues, _dirtyProperties, ExecuteContext);
      result.Rule = rule;
      result.OriginPropertyName = OriginPropertyName;
      result.InputPropertyValues = InputPropertyValues;
      result.Results = Results;
 
      if (!rule.IsAsync || rule.ProvideTargetWhenAsync)
        result.Target = Target;
      return result;
    }
 
    public void AddErrorResult(string description)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description));
    }
 
    public void AddErrorResult(string description, bool stopProcessing)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description) { StopProcessing = stopProcessing });
    }
 
    public void AddErrorResult(Csla.Core.IPropertyInfo property, string description)
    {
      if (!Rule.AffectedProperties.Contains(property))
        throw new ArgumentOutOfRangeException(property.Name, string.Format(Resources.PropertyNotInAffectedPropertiesException, property.Name));
      Results.Add(new RuleResult(Rule.RuleName, property, description));
    }
 
    public void AddWarningResult(string description)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description) { Severity = RuleSeverity.Warning });
    }
 
    public void AddWarningResult(string description, bool stopProcessing)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description) { Severity = RuleSeverity.Warning, StopProcessing = stopProcessing });
    }
 
 
    public void AddWarningResult(Csla.Core.IPropertyInfo property, string description)
    {
      if (!Rule.AffectedProperties.Contains(property))
        throw new ArgumentOutOfRangeException(property.Name, string.Format(Resources.PropertyNotInAffectedPropertiesException, property.Name));
      Results.Add(new RuleResult(Rule.RuleName, property, description) { Severity = RuleSeverity.Warning });
    }
 
    public void AddInformationResult(string description)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description) { Severity = RuleSeverity.Information });
    }
 
    public void AddInformationResult(string description, bool stopProcessing)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description) { Severity = RuleSeverity.Information, StopProcessing = stopProcessing });
    }
 
    public void AddInformationResult(Csla.Core.IPropertyInfo property, string description)
    {
      if (!Rule.AffectedProperties.Contains(property))
        throw new ArgumentOutOfRangeException(property.Name, string.Format(Resources.PropertyNotInAffectedPropertiesException, property.Name));
      Results.Add(new RuleResult(Rule.RuleName, property, description) { Severity = RuleSeverity.Information });
    }
 
    public void AddSuccessResult(bool stopProcessing)
    {
      Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty) { Severity = RuleSeverity.Success, StopProcessing = stopProcessing });
    }
 
    public void AddOutValue(object value)
    {
      _outputPropertyValues.Value.Add(Rule.PrimaryProperty, value);
    }
 
    public void AddOutValue(Csla.Core.IPropertyInfo property, object value)
    {
      _outputPropertyValues.Value[property] = value;
    }
 
 
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void AddDirtyProperty(Csla.Core.IPropertyInfo property)
    {
      if (!Rule.AffectedProperties.Contains(property))
        throw new ArgumentOutOfRangeException(property.Name, string.Format(Resources.PropertyNotInAffectedPropertiesException, property.Name));
      _dirtyProperties.Value.Add(property);
    }
 
    public void Complete()
    {
      if (Results.Count == 0)
        Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty));
      _completeHandler?.Invoke(this);
    }
 
    public  T GetInputValue<T>(PropertyInfo<T> propertyInfo)
    {
      return (T)InputPropertyValues[propertyInfo];
    }
 
    public T GetInputValue<T>(IPropertyInfo propertyInfo)
    {
      return (T)InputPropertyValues[propertyInfo];
    }
 
    public bool TryGetInputValue<T>(PropertyInfo<T> propertyInfo, ref T value)
    {
      if (!InputPropertyValues.ContainsKey(propertyInfo))
      {
        value = default(T);
        return false;
      }
 
      value = (T)InputPropertyValues[propertyInfo];
      return true;
    }
 
    public bool TryGetInputValue<T>(IPropertyInfo propertyInfo, ref T value)
    {
      if (!InputPropertyValues.ContainsKey(propertyInfo))
      {
        value = default(T);
        return false;
      }
 
      value = (T)InputPropertyValues[propertyInfo];
      return true;
    }
  }
}