public void MergeActiveResults(RuleResultsCollection fromCollection, RuleResultsCollection toCollection, Predicate<RuleConditionsCollection> rulesEvaluator)
        {
            if (fromCollection == null || fromCollection.Data == null) return;
            if (toCollection == null || toCollection.Data == null) return;
            if (!_validators.IsValid(fromCollection)) return;

            if (fromCollection.Conditions != null
                && rulesEvaluator != null
                && !rulesEvaluator(fromCollection.Conditions))
            {
                return;
            }

            var activeResults = GetActiveResults(fromCollection).ToList();
            foreach (var activeResult in activeResults)
            {
                toCollection.Data.RemoveAll(d => d.Name == activeResult.Name);
                toCollection.Data.Add(activeResult);
            }

            if (fromCollection.Results != null)
            {
                foreach (var innerResults in fromCollection.Results)
                    MergeActiveResults(innerResults, toCollection, rulesEvaluator);
            }
        }
        public IEnumerable<RuleResult> GetActiveResults(RuleResultsCollection fromCollection)
        {
            if (fromCollection == null
                || fromCollection.Data == null)
                return new List<RuleResult>();

            if (!_validators.IsValid(fromCollection))
                return new List<RuleResult>();

            return fromCollection.Data.Where(ruleResult => _validators.IsValid(ruleResult));
        }
        public virtual RuleResultsCollection Evaluate()
        {
            var result = new RuleResultsCollection();

            if (!_validators.IsValid(_rulesData))
                return result;

            var filters = new ResultsFilters(_validators);
            filters.MergeActiveResults(_rulesData.DefaultResults, result, Evaluate);

            if (!_validators.IsValid(_rulesData.Rules))
                return result;

            foreach (var rule in _rulesData.Rules.Data)
            {
                if (!_validators.IsValid(rule))
                    continue;

                if (!_validators.IsValid(rule.Conditions))
                    continue;

                var success = Evaluate(rule.Conditions);

                if (success)
                {
                    filters.MergeActiveResults(rule.OnSuccessResults, result, Evaluate);
                    if (!rule.ContinueOnSuccess)
                        break;
                }
                else
                {
                    filters.MergeActiveResults(rule.OnFailureResults, result, Evaluate);
                }
            }

            return result;
        }
Exemple #4
0
 public Rule()
 {
     Conditions = new RuleConditionsCollection();
     OnSuccessResults = new RuleResultsCollection();
     OnFailureResults = new RuleResultsCollection();
 }