/// <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 RegisterCompiledRule(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 <CompiledRule>(); var ruleCompiler = new RuleCompiler(new RuleExpressionBuilderFactory(_reSettings), _logger); foreach (var rule in _rulesCache.GetRules(workflowName)) { var compiledParamsKey = _compiledParamsCache.GetCompiledParamsCacheKey(workflowName, rule); CompiledRuleParam compiledRuleParam; if (_compiledParamsCache.ContainsParams(compiledParamsKey)) { compiledRuleParam = _compiledParamsCache.GetParams(compiledParamsKey); } else { compiledRuleParam = ruleParamCompiler.CompileParamsExpression(rule, ruleParams); _compiledParamsCache.AddOrUpdateParams(compiledParamsKey, compiledRuleParam); } var updatedRuleParams = compiledRuleParam != null?ruleParams?.Concat(compiledRuleParam?.RuleParameters) : ruleParams; var compiledRule = ruleCompiler.CompileRule(rule, updatedRuleParams?.ToArray()); lstFunc.Add(new CompiledRule { Rule = compiledRule, CompiledParameters = compiledRuleParam }); } _rulesCache.AddOrUpdateCompiledRule(compileRulesKey, lstFunc); _logger.LogTrace($"Rules has been compiled for the {workflowName} workflow and added to dictionary"); return(true); } else { return(false); } }
/// <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); } }
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); }