/// <summary>
/// This will execute the compiled rules
/// </summary>
/// <param name="workflowName"></param>
/// <param name="ruleParams"></param>
/// <returns>list of rule result set</returns>
private List <RuleResultTree> ExecuteRuleByWorkflow(string workflowName, RuleParameter[] ruleParameters)
{
_logger.LogTrace($"Compiled rules found for {workflowName} workflow and executed");
List <RuleResultTree> result = new List <RuleResultTree>();
string compileRulesKey = _rulesCache.GetRulesCacheKey(workflowName);
foreach (var compiledRule in _rulesCache.GetCompiledRules(compileRulesKey))
{
IEnumerable <RuleParameter> evaluatedRuleParams = new List <RuleParameter>(ruleParameters);
if (compiledRule?.CompiledParameters?.CompiledParameters != null)
{
foreach (var compiledParam in compiledRule?.CompiledParameters?.CompiledParameters)
{
var evaluatedParam = ruleParamCompiler.EvaluateCompiledParam(compiledParam.Name, compiledParam.Value, evaluatedRuleParams);
evaluatedRuleParams = evaluatedRuleParams.Concat(new List <RuleParameter> {
evaluatedParam
});
}
}
var inputs = evaluatedRuleParams.Select(c => c.Value);
var resultTree = compiledRule.Rule.DynamicInvoke(new List <object>(inputs)
{
new RuleInput()
}.ToArray()) as RuleResultTree;
resultTree.RuleEvaluatedParams = evaluatedRuleParams;
result.Add(resultTree);
}
FormatErrorMessages(result?.Where(r => !r.IsSuccess));
return(result);
}
private RuleFunc <RuleResultTree> CompileRule(string workflowName, RuleParameter[] ruleParams, Rule rule)
{
if (!_reSettings.EnableLocalParams)
{
return(_ruleCompiler.CompileRule(rule, ruleParams));
}
var compiledParamsKey = GetCompiledParamsCacheKey(workflowName, rule.RuleName, ruleParams);
IEnumerable <CompiledParam> compiledParamList = _compiledParamsCache.GetOrCreate(compiledParamsKey, (entry) => _ruleParamCompiler.CompileParamsExpression(rule, ruleParams));
var compiledRuleParameters = compiledParamList?.Select(c => c.AsRuleParameter()) ?? new List <RuleParameter>();
var updatedRuleParams = ruleParams?.Concat(compiledRuleParameters);
var compiledRule = _ruleCompiler.CompileRule(rule, updatedRuleParams?.ToArray());
RuleFunc <RuleResultTree> updatedRule = (RuleParameter[] paramList) =>
{
var inputs = paramList.AsEnumerable();
IEnumerable <CompiledParam> localParams = compiledParamList ?? new List <CompiledParam>();
var evaluatedParamList = new List <RuleParameter>();
foreach (var localParam in localParams)
{
var evaluatedLocalParam = _ruleParamCompiler.EvaluateCompiledParam(localParam.Name, localParam.Value, inputs);
inputs = inputs.Append(evaluatedLocalParam);
evaluatedParamList.Add(evaluatedLocalParam);
}
var result = compiledRule(inputs.ToArray());
result.RuleEvaluatedParams = evaluatedParamList;
return(result);
};
return(updatedRule);
}
/// <summary>
/// This will compile the rules and store them to dictionary
/// </summary>
/// <param name="workflowName">workflow name</param>
/// <param name="ruleParams">The rule parameters.</param>
/// <returns>
/// bool result
/// </returns>
private bool RegisterRule(string workflowName, params RuleParameter[] ruleParams)
{
string compileRulesKey = _rulesCache.GetRulesCacheKey(workflowName);
if (_rulesCache.ContainsCompiledRules(compileRulesKey))
{
return(true);
}
var workflowRules = _rulesCache.GetWorkFlowRules(workflowName);
if (workflowRules != null)
{
var lstFunc = new List <RuleFunc <RuleResultTree> >();
var ruleCompiler = new RuleCompiler(new RuleExpressionBuilderFactory(_reSettings), _logger);
foreach (var rule in _rulesCache.GetRules(workflowName))
{
var compiledParamsKey = GetCompiledParamsCacheKey(workflowName, rule);
CompiledRuleParam compiledRuleParam = _compiledParamsCache.GetOrCreate(compiledParamsKey, (entry) => ruleParamCompiler.CompileParamsExpression(rule, ruleParams));
var updatedRuleParams = compiledRuleParam != null?ruleParams?.Concat(compiledRuleParam?.RuleParameters) : ruleParams;
var compiledRule = ruleCompiler.CompileRule(rule, updatedRuleParams?.ToArray());
RuleFunc <RuleResultTree> updatedRule = (object[] paramList) => {
var inputs = paramList.AsEnumerable();
IEnumerable <CompiledParam> localParams = compiledRuleParam?.CompiledParameters ?? new List <CompiledParam>();
foreach (var localParam in localParams)
{
var evaluatedLocalParam = ruleParamCompiler.EvaluateCompiledParam(localParam.Name, localParam.Value, inputs);
inputs = inputs.Append(evaluatedLocalParam.Value);
}
var result = compiledRule(inputs.ToArray());
result.RuleEvaluatedParams = compiledRuleParam?.RuleParameters;
return(result);
};
lstFunc.Add(updatedRule);
}
_rulesCache.AddOrUpdateCompiledRule(compileRulesKey, lstFunc);
_logger.LogTrace($"Rules has been compiled for the {workflowName} workflow and added to dictionary");
return(true);
}
else
{
return(false);
}
}
