private async Task InvokeNestedRulesAsync(bool invokeNestedRules, IGeneralRule <T> rule)
{
if (invokeNestedRules && rule.IsNested)
{
await ExecuteAsyncRules(_activeRuleService.FilterActivatingRules(rule.GetRules()));
}
}
private void InvokeNestedRules(bool invokeNestedRules, IGeneralRule <T> rule)
{
if (invokeNestedRules && rule.IsNested)
{
Execute(_activeRuleService.FilterActivatingRules(OrderByExecutionOrder(rule.GetRules())));
}
}
private void InvokeReactiveRules(IGeneralRule<T> rule)
{
if (_rxRuleService.GetReactiveRules().ContainsKey(rule.GetType()))
{
Execute(_rxRuleService.GetReactiveRules()[rule.GetType()].ToList());
}
}
private void InitializeRule(IGeneralRule <T> rule, IGeneralRule <T> nestingRule = null)
{
rule.Model = _model;
rule.Configuration = new RuleEngineConfiguration <T>(rule.Configuration)
{
RuleEngineId = _ruleEngineId
};
if (nestingRule != null && nestingRule.Configuration.NestedRulesInheritConstraint)
{
rule.Configuration.Constraint = nestingRule.Configuration.Constraint;
rule.Configuration.NestedRulesInheritConstraint = true;
}
if (rule is RuleAsync <T> parallelRule && parallelRule.IsParallel &&
nestingRule is RuleAsync <T> nestingParallelRule)
{
if (nestingParallelRule.ParallelConfiguration != null &&
nestingParallelRule.ParallelConfiguration.NestedParallelRulesInherit)
{
var cancellationTokenSource = parallelRule.ParallelConfiguration.CancellationTokenSource;
parallelRule.ParallelConfiguration = new ParallelConfiguration <T>
{
NestedParallelRulesInherit = true,
CancellationTokenSource = cancellationTokenSource,
TaskCreationOptions = nestingParallelRule.ParallelConfiguration.TaskCreationOptions,
TaskScheduler = nestingParallelRule.ParallelConfiguration.TaskScheduler
};
}
}
rule.Resolve = _dependencyResolver;
}
public static void UpdateRuleEngineConfiguration <T>(this IGeneralRule <T> rule,
IConfiguration <T> ruleEngineConfiguration) where T : class, new()
{
if (ruleEngineConfiguration.Terminate == null && rule.Configuration.Terminate == true)
{
ruleEngineConfiguration.Terminate = true;
}
}
public void Initialize(IEnumerable <IGeneralRule <T> > rules, IGeneralRule <T> nestingRule = null)
{
foreach (var rule in rules.OfType <IRule <T> >())
{
RuleInitializer(rule, nestingRule);
rule.Initialize();
if (rule.IsNested)
{
Initialize(rule.GetRules(), rule);
}
}
}
public void RuleInitializer(IGeneralRule <T> rule, IGeneralRule <T> nestingRule = null)
{
rule.Model = _model;
rule.Configuration = new RuleEngineConfiguration <T>(rule.Configuration)
{
RuleEngineId = _ruleEngineId
};
if (nestingRule != null && nestingRule.Configuration.NestedRulesInheritConstraint)
{
rule.Configuration.Constraint = nestingRule.Configuration.Constraint;
rule.Configuration.NestedRulesInheritConstraint = true;
}
rule.Resolve = _dependencyResolver;
}
public Task InitializeAsync(IEnumerable <IGeneralRule <T> > rules, IGeneralRule <T> nestingRule = null)
{
var initBag = new ConcurrentBag <Task>();
Parallel.ForEach(rules.OfType <IRuleAsync <T> >(), rule =>
{
RuleInitializer(rule, nestingRule);
initBag.Add(rule.InitializeAsync());
if (rule.IsNested)
{
InitializeAsync(rule.GetRules(), rule);
}
});
return(Task.WhenAll(initBag));
}
public static RuleType GetRuleType <T>(this IGeneralRule <T> rule) where T : class, new()
{
if (rule.IsProactive)
{
return(RuleType.ProActiveRule);
}
if (rule.IsReactive)
{
return(RuleType.ReActiveRule);
}
if (rule.IsExceptionHandler)
{
return(RuleType.ExceptionHandlerRule);
}
return(RuleType.None);
}
public static string GetRuleName <T>(this IGeneralRule <T> rule) where T : class, new() => rule.GetType().Name;
public static Guid GetRuleEngineId <T>(this IGeneralRule <T> rule) where T : class, new() => rule.Configuration.To <RuleEngineConfiguration <T> >().RuleEngineId;
public void AddRule(IGeneralRule <T> rule) => Rules.Add(rule);
public static bool CanInvoke <T>(this IGeneralRule <T> rule) where T : class, new() => !rule.Configuration.Skip && rule.Configuration.Constraint.Invoke2(rule.Model);
public static void Verbose <T>(IGeneralRule <T> rule, string message) where T : class, new()
{
Trace.WriteLineIf(TraceSwitch.TraceVerbose, $"Executing {rule.GetType().Name} - {message}", "Information");
}
public static bool CanInvoke <T>(this IGeneralRule <T> rule, T model, bool terminated) where T : class, new() => !rule.Configuration.Skip && rule.Configuration.Constraint.Invoke2(model) && !terminated;
