BrokenRulesCollection.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BrokenRulesCollection.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>A collection of currently broken rules.</summary>
//-----------------------------------------------------------------------
using System;
using System.Linq;
using System.Collections.Generic;
using Csla.Properties;
using Csla.Serialization.Mobile;
 
namespace Csla.Rules
{
  [Serializable]
  public class BrokenRulesCollection : Core.ReadOnlyObservableBindingList<BrokenRule>
  {
    private int _errorCount;
    private int _warnCount;
    private int _infoCount;
 
    private object _syncRoot = new object();
 
 
    public BrokenRulesCollection()
      : this(false)
    { }
 
    internal BrokenRulesCollection(bool readOnly)
    {
      IsReadOnly = readOnly;
    }
 
    internal void ClearRules()
    {
      lock (_syncRoot)
      {
        IsReadOnly = false;
        base.Clear();
        _errorCount = _warnCount = _infoCount = 0;
        IsReadOnly = true;
      }
    }
 
    internal void ClearRules(Csla.Core.IPropertyInfo property)
    {
      lock (_syncRoot)
      {
        this.IsReadOnly = false;
 
        var propertyName = property == null ? null : property.Name;
        for (int i = 0, n = Count; i < n; i++)
        {
            var x = this[i];
            if (x.OriginProperty == propertyName)
            {
                RemoveAt(i);
                i--;
                n--;
            }
        }
 
        this.IsReadOnly = true;
      }
    }
    
    internal void SetBrokenRules(List<RuleResult> results, string originPropertyName)
    {
      lock (_syncRoot)
      {
        this.IsReadOnly = false;
 
        ISet<string> rulesDone = new HashSet<string>();
 
        for(int i = 0, n = results.Count; i < n; i++)
        {
          var result = results[i];
          var resultRuleName = result.RuleName;
 
          if(!rulesDone.Contains(resultRuleName))
          {
            rulesDone.Add(resultRuleName);
 
            ClearRules(resultRuleName, originPropertyName);
          }
 
          if(result.Success)
            continue;
 
          var resultDescription = result.Description;
 
          if(string.IsNullOrEmpty(resultDescription))
            throw new ArgumentException(string.Format(Resources.RuleMessageRequired,
                                                      resultRuleName));
 
          var resultPrimaryProperty = result.PrimaryProperty;
 
          BrokenRule broken = new BrokenRule
          {
            RuleName = resultRuleName,
            Description = resultDescription,
            Property = resultPrimaryProperty == null
                       ? null : resultPrimaryProperty.Name,
            Severity = result.Severity,
            OriginProperty = originPropertyName
          };
 
          Add(broken);
        }
 
        this.IsReadOnly = true;
      }
    }
 
    private void ClearRules(string ruleName, string originProperty)
    {
      for(int i = 0, n = Count; i < n; i++)
      {
        var x = this[i];
 
        if(x.RuleName == ruleName && x.OriginProperty == originProperty)
        {
          RemoveAt(i);
          i--;
          n--;
        }
      }
    }
 
    new void RemoveAt(int i)
    {
      CountOne(this[i].Severity, -1);
 
      base.RemoveAt(i);
    }
 
    new void Add(BrokenRule item)
    {
      base.Add(item);
 
      CountOne(item.Severity, 1);
    }
 
    private void CountOne(RuleSeverity severity, int one)
    {
        switch (severity)
        {
            case RuleSeverity.Error:
                _errorCount += one;
                break;
            case RuleSeverity.Warning:
                _warnCount += one;
                break;
            case RuleSeverity.Information:
                _infoCount += one;
                break;
            default:
                throw new Exception("unhandled severity=" + severity);
        }
    }
 
    public int ErrorCount
    {
      get { return _errorCount; }
    }
 
    public int WarningCount
    {
      get { return _warnCount; }
    }
 
    public int InformationCount
    {
      get { return _infoCount; }
    }
 
    public BrokenRule GetFirstBrokenRule(Csla.Core.IPropertyInfo property)
    {
      return GetFirstMessage(property.Name, RuleSeverity.Error);
    }
 
    public BrokenRule GetFirstBrokenRule(string property)
    {
      return GetFirstMessage(property, RuleSeverity.Error);
    }
 
    public BrokenRule GetFirstMessage(Csla.Core.IPropertyInfo property)
    {
      return this.Where(c => c.Property == property.Name).FirstOrDefault();
    }
 
    public BrokenRule GetFirstMessage(Csla.Core.IPropertyInfo property, RuleSeverity severity)
    {
      return GetFirstMessage(property.Name, severity);
    }
 
    public BrokenRule GetFirstMessage(string property, RuleSeverity severity)
    {
      return this.Where(c => c.Property == property && c.Severity == severity).FirstOrDefault();
    }
 
    public override string ToString()
    {
      return ToString(Environment.NewLine);
    }
 
    public string ToString(RuleSeverity severity)
    {
      return ToString(Environment.NewLine, severity);
    }
 
    public string ToString(string separator)
    {
      System.Text.StringBuilder result = new System.Text.StringBuilder();
      bool first = true;
      foreach (BrokenRule item in this)
      {
        if (first)
          first = false;
        else
          result.Append(separator);
        result.Append(item.Description);
      }
      return result.ToString();
    }
 
    public string ToString(string separator, RuleSeverity severity)
    {
      System.Text.StringBuilder result = new System.Text.StringBuilder();
      bool first = true;
      foreach (BrokenRule item in this)
      {
        if (item.Severity == severity)
        {
          if (first)
            first = false;
          else
            result.Append(separator);
          result.Append(item.Description);
        }
      }
      return result.ToString();
    }
 
    public string ToString(string separator, RuleSeverity severity, string propertyName)
    {
      System.Text.StringBuilder result = new System.Text.StringBuilder();
      bool first = true;
      foreach (BrokenRule item in this.Where(r => r.Property == propertyName))
      {
        if (item.Severity == severity)
        {
          if (first)
            first = false;
          else
            result.Append(separator);
          result.Append(item.Description);
        }
      }
      return result.ToString();
    }
 
    public string[] ToArray()
    {
      return this.Select(c => c.Description).ToArray();
    }
 
    public string[] ToArray(RuleSeverity severity)
    {
      return this.Where(c => c.Severity == severity).Select(c => c.Description).ToArray();
    }
 
    public void AddRange(List<BrokenRule> list)
    {
      foreach (var item in list)
        Add(item);
    }
 
    protected override void OnGetState(SerializationInfo info)
    {
      info.AddValue("_errorCount", _errorCount);
      info.AddValue("_warnCount", _warnCount);
      info.AddValue("_infoCount", _infoCount);
      base.OnGetState(info);
    }
 
    protected override void OnSetState(SerializationInfo info)
    {
      _errorCount = info.GetValue<int>("_errorCount");
      _warnCount = info.GetValue<int>("_warnCount");
      _infoCount = info.GetValue<int>("_infoCount");
      base.OnSetState(info);
    }
  }
}