BusinessRules.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BusinessRules.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Tracks the business rules for a business object.</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Linq;
using System.Collections.Generic;
using Csla.Serialization.Mobile;
using Csla.Core;
using System.Threading.Tasks;
using Csla.Threading;
using System.Security.Principal;
 
namespace Csla.Rules
{
  [Serializable]
  public class BusinessRules :
    MobileObject, ISerializationNotification, IBusinessRules, IUseApplicationContext
  {
    public BusinessRules()
    { }
 
    public BusinessRules(ApplicationContext applicationContext, IHostRules target)
    {
      ApplicationContext = applicationContext;
      SetTarget(target);
    }
 
    [NonSerialized]
    private object SyncRoot = new();
 
    ApplicationContext IUseApplicationContext.ApplicationContext { get => ApplicationContext; set => ApplicationContext = value; }
    private ApplicationContext ApplicationContext { get; set; }
 
    // list of broken rules for this business object.
    private BrokenRulesCollection _brokenRules;
    private BrokenRulesCollection BrokenRules
    {
      get
      {
        if (_brokenRules == null)
          _brokenRules = new BrokenRulesCollection(true);
        return _brokenRules;
      }
    }
 
    private bool _suppressRuleChecking;
    public bool SuppressRuleChecking
    {
      get { return _suppressRuleChecking; }
      set { _suppressRuleChecking = value; }
    }
 
    private int _processThroughPriority;
    public int ProcessThroughPriority
    {
      get { return _processThroughPriority; }
      set { _processThroughPriority = value; }
    }
 
    private string _ruleSet = null;
    public string RuleSet
    {
      get { return string.IsNullOrEmpty(_ruleSet) ? ApplicationContext.DefaultRuleSet : _ruleSet; }
      set
      {
        _typeRules = null;
        _typeAuthRules = null;
        _ruleSet = value == ApplicationContext.DefaultRuleSet ? null : value;
        if (BrokenRules.Count > 0)
        {
          BrokenRules.ClearRules();
        }
      }
    }
 
    public bool CascadeOnDirtyProperties
    {
      get { return _cascadeOnDirtyProperties; }
      set { _cascadeOnDirtyProperties = value; }
    }
 
 
    [NonSerialized]
    private BusinessRuleManager _typeRules;
    internal BusinessRuleManager TypeRules
    {
      get
      {
        if (_typeRules == null && _target != null)
          _typeRules = BusinessRuleManager.GetRulesForType(_target.GetType(), _ruleSet);
        return _typeRules;
      }
    }
 
    [NonSerialized]
    private AuthorizationRuleManager _typeAuthRules;
    internal AuthorizationRuleManager TypeAuthRules
    {
      get
      {
        if (_typeAuthRules == null && _target != null)
          _typeAuthRules = AuthorizationRuleManager.GetRulesForType(ApplicationContext, _target.GetType(), _ruleSet);
        return _typeAuthRules;
      }
    }
 
    public string[] GetRuleDescriptions()
    {
      var result = new List<string>();
      foreach (var item in TypeRules.Rules)
        result.Add(item.RuleName);
      return result.ToArray();
    }
 
    // reference to current business object
    [NonSerialized]
    private IHostRules _target;
 
    internal void SetTarget(IHostRules target)
    {
      _target = target;
    }
 
    internal object Target
    {
      get { return _target; }
    }
 
    public void AddRule(IBusinessRuleBase rule)
    {
      TypeRules.Rules.Add(rule);
    }
 
    public void AddRule(IBusinessRuleBase rule, string ruleSet)
    {
      var typeRules = BusinessRuleManager.GetRulesForType(_target.GetType(), ruleSet);
      typeRules.Rules.Add(rule);
    }
 
    public void AddRule(IAuthorizationRule rule)
    {
      EnsureUniqueRule(TypeAuthRules, rule);
      TypeAuthRules.Rules.Add(rule);
    }
 
    public static void AddRule(Type objectType, IAuthorizationRule rule)
    {
      AddRule(objectType, rule, ApplicationContext.DefaultRuleSet);
    }
 
    public static void AddRule(Type objectType, IAuthorizationRule rule, string ruleSet)
    {
      AddRule(null, objectType, rule, ruleSet);
    }
 
    public static void AddRule(ApplicationContext applicationContext, Type objectType, IAuthorizationRule rule, string ruleSet)
    {
      var typeRules = AuthorizationRuleManager.GetRulesForType(applicationContext, objectType, ruleSet);
      EnsureUniqueRule(typeRules, rule);
      typeRules.Rules.Add(rule);
    }
 
    private static void EnsureUniqueRule(AuthorizationRuleManager mgr, IAuthorizationRule rule)
    {
      IAuthorizationRule oldRule = null;
      if (rule.Element != null)
        oldRule = mgr.Rules.FirstOrDefault(c => c.Element != null && c.Element.Name == rule.Element.Name && c.Action == rule.Action);
      else
        oldRule = mgr.Rules.FirstOrDefault(c => c.Element == null && c.Action == rule.Action);
      if (oldRule != null)
        throw new ArgumentException(nameof(rule));
    }
 
    public bool IsValid
    {
      get { return BrokenRules.ErrorCount == 0; }
    }
 
    public BrokenRulesCollection GetBrokenRules()
    {
      return BrokenRules;
    }
 
    [NonSerialized]
    private bool _runningRules;
    public bool RunningRules
    {
      get { return _runningRules; }
      private set { _runningRules = value; }
    }
 
    [NonSerialized]
    private bool _isBusy;
 
    [NonSerialized]
    private AsyncManualResetEvent _busyChanged;
    private AsyncManualResetEvent BusyChanged
    {
      get
      {
        if (_busyChanged == null)
          _busyChanged = new AsyncManualResetEvent();
        return _busyChanged;
      }
    }
 
    public bool RunningAsyncRules
    {
      get { return _isBusy; }
      set
      {
        _isBusy = value;
        if (_isBusy)
          BusyChanged.Reset();
        else
          BusyChanged.Set();
      }
    }
 
    public bool GetPropertyBusy(Csla.Core.IPropertyInfo property)
    {
      return BusyProperties.Contains(property);
    }
 
    public static bool HasPermission(ApplicationContext applicationContext, AuthorizationActions action, Type objectType)
    {
      if (applicationContext == null)
        throw new ArgumentNullException(nameof(applicationContext));
      // no object specified so must use RuleSet from ApplicationContext
      return HasPermission(action, null, applicationContext, objectType, null, applicationContext.RuleSet);
    }
 
    public static bool HasPermission(ApplicationContext applicationContext, AuthorizationActions action, Type objectType, object[] criteria)
    {
      if (applicationContext == null)
        throw new ArgumentNullException(nameof(applicationContext));
      // no object specified so must use RuleSet from ApplicationContext
      return HasPermission(action, null, applicationContext, objectType, criteria, applicationContext.RuleSet);
    }
 
    public static bool HasPermission(ApplicationContext applicationContext, AuthorizationActions action, Type objectType, string ruleSet)
    {
      if (applicationContext == null)
        throw new ArgumentNullException(nameof(applicationContext));
      return HasPermission(action, null, applicationContext, objectType, null, ruleSet);
    }
 
    public static bool HasPermission(ApplicationContext applicationContext, AuthorizationActions action, object obj)
    {
      if (applicationContext == null)
        throw new ArgumentNullException(nameof(applicationContext));
      return HasPermission(action, obj, applicationContext, obj.GetType(), null, applicationContext.RuleSet);
    }
 
    private static bool HasPermission(AuthorizationActions action, object obj, ApplicationContext applicationContext, Type objType, object[] criteria, string ruleSet)
    {
 
      if (action == AuthorizationActions.ReadProperty ||
          action == AuthorizationActions.WriteProperty ||
          action == AuthorizationActions.ExecuteMethod)
        throw new ArgumentOutOfRangeException($"{nameof(action)}, {action}");
 
      bool result = true;
      var rule =
        AuthorizationRuleManager.GetRulesForType(applicationContext, objType, ruleSet).Rules.FirstOrDefault(c => c.Element == null && c.Action == action);
      if (rule != null)
      {
        var context = new AuthorizationContext(applicationContext, rule, obj, objType) { Criteria = criteria };
        rule.Execute(context);
        result = context.HasPermission;
      }
      return result;
    }
 
    public bool HasPermission(ApplicationContext applicationContext, AuthorizationActions action, Csla.Core.IMemberInfo element)
    {
      if (_suppressRuleChecking)
        return true;
 
      if (action == AuthorizationActions.CreateObject ||
          action == AuthorizationActions.DeleteObject ||
          action == AuthorizationActions.GetObject ||
          action == AuthorizationActions.EditObject)
        throw new ArgumentOutOfRangeException($"{nameof(action)}, {action}");
 
      bool result = true;
      var rule =
        TypeAuthRules.Rules.FirstOrDefault(c => c.Element != null && c.Element.Name == element.Name && c.Action == action);
      if (rule != null)
      {
        var context = new AuthorizationContext(applicationContext, rule, this.Target, this.Target.GetType());
        rule.Execute(context);
        result = context.HasPermission;
      }
      return result;
    }
 
    public bool CachePermissionResult(AuthorizationActions action, IMemberInfo element)
    {
      // cannot cache result when suppressRuleChecking as HasPermission is then short circuited to return true.
      if (_suppressRuleChecking)
        return false;
 
      bool result = true;
      var rule =
        TypeAuthRules.Rules.FirstOrDefault(c => c.Element != null && c.Element.Name == element.Name && c.Action == action);
      if (rule != null)
        result = rule.CacheResult;
      return result;
    }
 
    public async Task<List<string>> CheckRulesAsync(int timeout)
    {
      var result = CheckRules();
      if (RunningAsyncRules)
      {
        var tasks = new Task[] { BusyChanged.WaitAsync(), Task.Delay(timeout) };
        var final = await Task.WhenAny(tasks);
        if (final == tasks[1])
          throw new TimeoutException(nameof(CheckRulesAsync));
      }
      return result;
    }
 
    public async Task<List<string>> CheckRulesAsync()
    {
      return await CheckRulesAsync(int.MaxValue);
    }
 
    public List<string> CheckRules()
    {
      if (_suppressRuleChecking)
        return new List<string>();
 
      RunningRules = true;
      var affectedProperties = CheckObjectRules(RuleContextModes.CheckRules, false);
      var properties = TypeRules.Rules.Where(p => p.PrimaryProperty != null)
                                          .Select(p => p.PrimaryProperty)
                                          .Distinct();
      foreach (var property in properties)
        affectedProperties.AddRange(CheckRules(property, RuleContextModes.CheckRules));
      RunningRules = false;
      if (!RunningRules && !RunningAsyncRules)
        _target.AllRulesComplete();
      return affectedProperties.Distinct().ToList();
    }
 
    public List<string> CheckObjectRules()
    {
      return CheckObjectRules(RuleContextModes.CheckObjectRules, true);
    }
 
 
    private List<string> CheckObjectRules(RuleContextModes executionContext, bool cascade)
    {
      if (_suppressRuleChecking)
        return new List<string>();
       
      var oldRR = RunningRules;
      RunningRules = true;
      var rules = from r in TypeRules.Rules
                  where r.PrimaryProperty == null
                    && CanRunRule(ApplicationContext, r, executionContext)
                  orderby r.Priority
                  select r;
      BrokenRules.ClearRules(null);
      // Changed to cascade propertyrule to make async ObjectLevel rules rerun PropertLevel rules.
      var firstResult = RunRules(rules, false, executionContext);
 
      // rerun property level rules for affected properties 
      if (cascade)
      {
        var propertiesToRun = new List<Csla.Core.IPropertyInfo>();
        foreach (var item in rules)
          if (!item.IsAsync)
          {
            foreach (var p in item.AffectedProperties)
              propertiesToRun.Add(p);
          }
        // run rules for affected properties
        foreach (var item in propertiesToRun.Distinct())
        {
          var doCascade = false;
          if (CascadeOnDirtyProperties)
            doCascade = firstResult.DirtyProperties.Any(p => p == item.Name);
          firstResult.AffectedProperties.AddRange(CheckRulesForProperty(item, doCascade,
                                                            executionContext | RuleContextModes.AsAffectedPoperty));
        }
      }
 
      RunningRules = oldRR;
      if (!RunningRules && !RunningAsyncRules)
        _target.AllRulesComplete();
      return firstResult.AffectedProperties.Distinct().ToList();
    }
 
    public List<string> CheckRules(Csla.Core.IPropertyInfo property)
    {
      return CheckRules(property, RuleContextModes.PropertyChanged);
    }
 
    private  List<string> CheckRules(Csla.Core.IPropertyInfo property, RuleContextModes executionContext)
    {
      if (property == null)
        throw new ArgumentNullException(nameof(property));
 
      if (_suppressRuleChecking)
        return new List<string>();
 
      var oldRR = RunningRules;
      RunningRules = true;
 
      var affectedProperties = new List<string>();
      affectedProperties.AddRange(CheckRulesForProperty(property, true, executionContext));
 
      RunningRules = oldRR;
      if (!RunningRules && !RunningAsyncRules)
        _target.AllRulesComplete();
      return affectedProperties.Distinct().ToList();
    }
 
    internal static bool CanRunRule(ApplicationContext applicationContext, IBusinessRuleBase rule, RuleContextModes contextMode)
    {
      // default then just return true
      if (rule.RunMode == RunModes.Default) return true;
 
      bool canRun = true;
 
      if ((contextMode & RuleContextModes.AsAffectedPoperty) > 0)
        canRun &= (rule.RunMode & RunModes.DenyAsAffectedProperty) == 0;
 
      if ((rule.RunMode & RunModes.DenyOnServerSidePortal) > 0) 
        canRun &= applicationContext.LogicalExecutionLocation != ApplicationContext.LogicalExecutionLocations.Server;
 
      if ((contextMode & RuleContextModes.CheckRules) > 0)
        canRun &= (rule.RunMode & RunModes.DenyCheckRules) == 0;
 
      return canRun;
    }
 
    private List<string> CheckRulesForProperty(Csla.Core.IPropertyInfo property, bool cascade, RuleContextModes executionContext)
    {
      var rules = from r in TypeRules.Rules
                  where ReferenceEquals(r.PrimaryProperty, property)
                    && CanRunRule(ApplicationContext, r, executionContext)
                  orderby r.Priority
                  select r;
 
      BrokenRules.ClearRules(property);
      var firstResult = RunRules(rules, cascade, executionContext);
      if (CascadeOnDirtyProperties)
          cascade = cascade || firstResult.DirtyProperties.Any();
      if (cascade)
      {
        // get properties affected by all rules
        var propertiesToRun = new List<Csla.Core.IPropertyInfo>();
        foreach (var item in rules)
          if (!item.IsAsync)
          {
            foreach (var p in item.AffectedProperties)
              if (!ReferenceEquals(property, p))
                propertiesToRun.Add(p);
          }
 
        // add PrimaryProperty where property is in InputProperties
        var input = from r in TypeRules.Rules
                    where !ReferenceEquals(r.PrimaryProperty, property)
                          && r.PrimaryProperty != null
                          && r.InputProperties != null
                          && r.InputProperties.Contains(property)
                    select r.PrimaryProperty;
 
        foreach (var p in input)
        {
            if (!ReferenceEquals(property, p))
                propertiesToRun.Add(p);
        }
        // run rules for affected properties
        foreach (var item in propertiesToRun.Distinct())
        {
          var doCascade = false; 
          if (CascadeOnDirtyProperties)
            doCascade = firstResult.DirtyProperties.Any(p => p == item.Name);
          firstResult.AffectedProperties.AddRange(CheckRulesForProperty(item, doCascade,
                                                               executionContext | RuleContextModes.AsAffectedPoperty));
        }
      }
 
      // always make sure to add PrimaryProperty
      firstResult.AffectedProperties.Add(property.Name);
      return firstResult.AffectedProperties.Distinct().ToList();
    }
 
    [NonSerialized]
    private List<Csla.Core.IPropertyInfo> _busyProperties;
 
    private bool _cascadeOnDirtyProperties;
 
    private List<Csla.Core.IPropertyInfo> BusyProperties
    {
      get
      {
        if (_busyProperties == null)
          _busyProperties = new List<Csla.Core.IPropertyInfo>();
        return _busyProperties;
      }
    }
 
    private RunRulesResult RunRules(IEnumerable<IBusinessRuleBase> rules, bool cascade, RuleContextModes executionContext)
    {
      var affectedProperties = new List<string>();
      var dirtyProperties = new List<string>();
      bool anyRuleBroken = false;
      foreach (var rule in rules)
      {
        // implicit short-circuiting
        if (anyRuleBroken && rule.Priority > ProcessThroughPriority)
          break;
        bool complete = false;
        // set up context
        var context = new RuleContext(ApplicationContext, (r) =>
        {
          if (r.Rule.IsAsync)
          {
            lock (SyncRoot)
            {
              // update output values
              if (r.OutputPropertyValues != null)
                foreach (var item in r.OutputPropertyValues)
                {
                  // value is changed add to dirtyValues
                  if (((IManageProperties)_target).LoadPropertyMarkDirty(item.Key, item.Value))
                    r.AddDirtyProperty(item.Key);
                }
              // update broken rules list
              BrokenRules.SetBrokenRules(r.Results, r.OriginPropertyName);
 
              // run rules on affected properties for this async rule
              var affected = new List<string>();
              if (cascade)
                foreach (var item in r.Rule.AffectedProperties.Distinct())
                  if (!ReferenceEquals(r.Rule.PrimaryProperty, item))
                  {
                    var doCascade = false;
                    if (CascadeOnDirtyProperties && (r.DirtyProperties != null))
                      doCascade = r.DirtyProperties.Any(p => p.Name == item.Name);
                    affected.AddRange(CheckRulesForProperty(item, doCascade, r.ExecuteContext | RuleContextModes.AsAffectedPoperty));
                  }
 
              // mark each property as not busy
              foreach (var item in r.Rule.AffectedProperties)
              {
                BusyProperties.Remove(item);
                RunningAsyncRules = BusyProperties.Count > 0;
                if (!BusyProperties.Contains(item))
                  _target.RuleComplete(item);
              }
 
              foreach (var property in affected.Distinct())
              {
                // property is not in AffectedProperties (already signalled to UI)
                if (!r.Rule.AffectedProperties.Any(p => p.Name == property))
                  _target.RuleComplete(property);
              }
 
              if (!RunningRules && !RunningAsyncRules)
                _target.AllRulesComplete();
            }
          }
          else  // Rule is Sync 
          {
            // update output values
            if (r.OutputPropertyValues != null)
              foreach (var item in r.OutputPropertyValues)
              {
                // value is changed add to dirtyValues
                if (((IManageProperties)_target).LoadPropertyMarkDirty(item.Key, item.Value))
                  r.AddDirtyProperty(item.Key);
              }
 
            // update broken rules list
            if (r.Results != null)
            {
              BrokenRules.SetBrokenRules(r.Results, r.OriginPropertyName);
 
              // is any rules here broken with severity Error
              if (r.Results.Any(p => !p.Success && p.Severity == RuleSeverity.Error))
                anyRuleBroken = true;
            }
 
            complete = true;
          }
        })
        {
          Rule = rule
        };
        if (rule.PrimaryProperty != null)
          context.OriginPropertyName = rule.PrimaryProperty.Name;
        context.ExecuteContext = executionContext;
        if (!rule.IsAsync || rule.ProvideTargetWhenAsync)
          context.Target = _target;
 
        // get input properties
        if (rule.InputProperties != null)
        {
          var target = (IManageProperties) _target;
          context.InputPropertyValues = new Dictionary<IPropertyInfo, object>();
          foreach (var item in rule.InputProperties)
          {
            // do not add lazy loaded fields that have no field data.
            if ((item.RelationshipType & RelationshipTypes.LazyLoad) == RelationshipTypes.LazyLoad)
            {
              if (target.FieldExists(item))
                context.InputPropertyValues.Add(item, target.ReadProperty(item));
            }
            else
              context.InputPropertyValues.Add(item, target.ReadProperty(item));
          }
        }
 
        // mark properties busy
        if (rule.IsAsync)
        {
          lock (SyncRoot)
          {
            // mark each property as busy
            foreach (var item in rule.AffectedProperties)
            {
              var alreadyBusy = BusyProperties.Contains(item);
              BusyProperties.Add(item);
              RunningAsyncRules = true;
              if (!alreadyBusy)
                _target.RuleStart(item);
            }
          }
        }
 
        // execute (or start executing) rule
        try
        {
          if (rule is IBusinessRule syncRule)
            syncRule.Execute(context);
          else if (rule is IBusinessRuleAsync asyncRule)
            RunAsyncRule(asyncRule, context);
          else
            throw new ArgumentOutOfRangeException(rule.GetType().FullName);
        }
        catch (Exception ex)
        {
          context.AddErrorResult(string.Format("{0}:{1}", rule.RuleName, ex.Message));
          if (rule.IsAsync)
            context.Complete();
        }
 
        if (!rule.IsAsync)
        {
          // process results
          if (!complete)
            context.Complete();
          // copy affected property names
          affectedProperties.AddRange(rule.AffectedProperties.Select(c => c.Name));
          // copy output property names
          if (context.OutputPropertyValues != null)
            affectedProperties.AddRange(context.OutputPropertyValues.Select(c =>c.Key.Name));
          // copy dirty properties 
          if (context.DirtyProperties != null)
            dirtyProperties.AddRange(context.DirtyProperties.Select(c => c.Name));
 
          if (context.Results != null)
          {
            // explicit short-circuiting
            if (context.Results.Any(r => r.StopProcessing))
              break;
          }
        }
      }
      // return any synchronous results
      return new RunRulesResult(affectedProperties, dirtyProperties);
    }
 
    private static async void RunAsyncRule(IBusinessRuleAsync asyncRule, IRuleContext context)
    {
      try
      {
        await asyncRule.ExecuteAsync(context);
      }
      finally
      {
        context.Complete();
      }
    }
 
    #region DataAnnotations
 
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public void AddDataAnnotations()
    {
      Type metadataType;
#if !NETSTANDARD2_0 && !NET5_0 && !NET6_0
      // add data annotations from metadata class if specified
      var classAttList = _target.GetType().GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.MetadataTypeAttribute), true);
      if (classAttList.Length > 0)
      {
        metadataType = ((System.ComponentModel.DataAnnotations.MetadataTypeAttribute)classAttList[0]).MetadataClassType;
        AddDataAnnotationsFromType(metadataType);
      }
#endif
 
      // attributes on class
      metadataType = _target.GetType();
      AddDataAnnotationsFromType(metadataType);
    }
 
    private void AddDataAnnotationsFromType(Type metadataType)
    {
      var attList = metadataType.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.ValidationAttribute), true);
      foreach (var att in attList)
        AddRule(new CommonRules.DataAnnotation(null, (System.ComponentModel.DataAnnotations.ValidationAttribute)att));
 
      // attributes on properties
      var propList = metadataType.GetProperties();
      foreach (var prop in propList)
      {
        attList = prop.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.ValidationAttribute), true);
        foreach (var att in attList)
        {
          var target = (IManageProperties)_target;
          var pi = target.GetManagedProperties().First(c => c.Name == prop.Name);
          AddRule(new CommonRules.DataAnnotation(pi, (System.ComponentModel.DataAnnotations.ValidationAttribute)att));
        }
      }
    }
 
    #endregion
 
    #region MobileObject overrides
 
    protected override void OnGetState(SerializationInfo info, StateMode mode)
    {
      info.AddValue("_processThroughPriority", _processThroughPriority);
      info.AddValue("_ruleSet", _ruleSet);
      info.AddValue("_cascadeWhenChanged", _cascadeOnDirtyProperties);
      base.OnGetState(info, mode);
    }
 
    protected override void OnSetState(SerializationInfo info, StateMode mode)
    {
      _processThroughPriority = info.GetValue<int>("_processThroughPriority");
      _ruleSet = info.GetValue<string>("_ruleSet");
      _cascadeOnDirtyProperties = info.GetValue<bool>("_cascadeWhenChanged");
      base.OnSetState(info, mode);
    }
 
    protected override void OnGetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      if (_brokenRules != null && _brokenRules.Count > 0)
      {
        SerializationInfo brInfo = formatter.SerializeObject(_brokenRules);
        info.AddChild("_brokenRules", brInfo.ReferenceId);
      }
 
      base.OnGetChildren(info, formatter);
    }
 
    protected override void OnSetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      if (info.Children.ContainsKey("_brokenRules"))
      {
        int referenceId = info.Children["_brokenRules"].ReferenceId;
        _brokenRules = (BrokenRulesCollection)formatter.GetObject(referenceId);
      }
 
      base.OnSetChildren(info, formatter);
    }
    #endregion
 
    #region Serialization Notification
 
    void ISerializationNotification.Deserialized()
    {
      OnDeserializedHandler(new System.Runtime.Serialization.StreamingContext());
    }
 
    [System.Runtime.Serialization.OnDeserialized]
    private void OnDeserializedHandler(System.Runtime.Serialization.StreamingContext context)
    {
      SyncRoot = new object();
    }
 
    #endregion
 
    #region Get All Broken Rules (tree)
 
    public static BrokenRulesTree GetAllBrokenRules(object root)
    {
      return GetAllBrokenRules(root, true);
    }
    public static BrokenRulesTree GetAllBrokenRules(object root, bool errorsOnly)
    {
      var list = new BrokenRulesTree();
      long counter = 1;
      long childBrokenRuleCount = 0;
      AddNodeToBrukenRules(ref list, ref counter, null, root, errorsOnly, ref childBrokenRuleCount);
 
      return list;
    }
 
    private static void AddNodeToBrukenRules(ref BrokenRulesTree list, ref long counter, object parentKey, object obj, bool errorsOnly, ref long childBrokenRuleCount)
    {
      // is this a single editable object 
      if (obj is Csla.Core.BusinessBase bbase)
      {
        var nodeKey = counter++;
        var bo = bbase;
        long myChildBrokenRuleCount = bo.BrokenRulesCollection.Count;
        var node = new BrokenRulesNode() { Parent = parentKey, Node = nodeKey, BrokenRules = bo.BrokenRulesCollection, Object = obj };
        list.Add(node);
 
        // get managed child properties 
        foreach (var child in ((IManageProperties)bo).GetChildren())
        {
          AddNodeToBrukenRules(ref list, ref counter, nodeKey, child, errorsOnly, ref myChildBrokenRuleCount);
        }
 
        // remove node if it has no child with broken rules. 
        if (!errorsOnly && myChildBrokenRuleCount == 0)
        {
          list.Remove(node);
        }
        if (errorsOnly && bo.IsValid)
        {
          list.Remove(node);
        }
        childBrokenRuleCount += myChildBrokenRuleCount;
      }
 
      // or a list of EditableObject (both BindingList and ObservableCollection)
      else if (obj is IEditableCollection)
      {
        var nodeKey = counter++;
        var isValid = ((ITrackStatus)obj).IsValid;
        var node = new BrokenRulesNode() { Parent = parentKey, Node = nodeKey, Object = obj, BrokenRules = new BrokenRulesCollection(true) };
        long myChildBrokenRuleCount = 0;
 
        list.Add(node);
 
        foreach (var child in (IEnumerable)obj)
        {
          AddNodeToBrukenRules(ref list, ref counter, nodeKey, child, errorsOnly, ref myChildBrokenRuleCount);
        }
 
        // remove node if it has no child with broken rules. 
        if (!errorsOnly && myChildBrokenRuleCount == 0)
        {
          list.Remove(node);
        }
        if (errorsOnly && isValid)
        {
          list.Remove(node);
        }
        childBrokenRuleCount += myChildBrokenRuleCount;
      }
      return;
    }
 
    #endregion
 
 
    internal class RunRulesResult
    {
      public RunRulesResult(List<string> affectedProperties, List<string> dirtyProperties)
      {
        AffectedProperties = affectedProperties;
        DirtyProperties = dirtyProperties;
      }
 
      public List<string> AffectedProperties { get; set; }
      public List<string> DirtyProperties { get; set; }
    }
 
    object IBusinessRules.Target
    {
      get { return Target; }
    }
  }
}