public ELContext CreateElContext(IVariableContext variableContext) { SimpleContext elContext = new SimpleContext(resolver); elContext.PutContext(typeof(IVariableContext), variableContext); return(elContext); }
protected internal virtual object EvaluateElExpression(string expressionLanguage, string expressionText, IVariableContext variableContext, CachedExpressionSupport cachedExpressionSupport) { try { var elExpression = cachedExpressionSupport.CachedExpression; if (elExpression == null) { lock (cachedExpressionSupport) { elExpression = cachedExpressionSupport.CachedExpression; if (elExpression == null) { elExpression = elProvider.CreateExpression(expressionText); cachedExpressionSupport.CachedExpression = elExpression; } } } return(elExpression.GetValue(variableContext)); } // yes, we catch all exceptions catch (System.Exception e) { throw Log.unableToEvaluateExpression(expressionText, expressionLanguage, e); } }
protected internal virtual IDictionary <string, IDmnEvaluatedOutput> EvaluateOutputEntries( IList <DmnDecisionTableOutputImpl> decisionTableOutputs, DmnDecisionTableRuleImpl matchingRule, IVariableContext variableContext) { IDictionary <string, IDmnEvaluatedOutput> outputEntries = new Dictionary <string, IDmnEvaluatedOutput>(); for (var outputIdx = 0; outputIdx < decisionTableOutputs.Count; outputIdx++) { // evaluate output entry, skip empty expressions var conclusion = matchingRule.Conclusions[outputIdx]; if (IsNonEmptyExpression(conclusion)) { var value = EvaluateOutputEntry(conclusion, variableContext); // transform to output type var decisionTableOutput = decisionTableOutputs[outputIdx]; var typedValue = decisionTableOutput.TypeDefinition.Transform(value); // set on result var evaluatedOutput = new DmnEvaluatedOutputImpl(decisionTableOutput, typedValue); outputEntries[decisionTableOutput.OutputName] = evaluatedOutput; } } return(outputEntries); }
/// <summary> /// Evaluate a decision with the given <seealso cref="IVariableContext" /> /// </summary> /// <param name="decision"> the decision to evaluate </param> /// <param name="variableContext"> the available variable context </param> /// <returns> the result of the decision evaluation </returns> public virtual IDmnDecisionResult evaluateDecision(IDmnDecision decision, IVariableContext variableContext) { if (ReferenceEquals(decision.Key, null)) { throw LOG.unableToFindAnyDecisionTable(); } var variableMap = buildVariableMapFromVariableContext(variableContext); IList <IDmnDecision> requiredDecisions = new List <IDmnDecision>(); buildDecisionTree(decision, requiredDecisions); IList <IDmnDecisionLogicEvaluationEvent> evaluatedEvents = new List <IDmnDecisionLogicEvaluationEvent>(); IDmnDecisionResult evaluatedResult = null; foreach (var evaluateDecision in requiredDecisions) { var handler = getDecisionEvaluationHandler(evaluateDecision); var evaluatedEvent = handler.Evaluate(evaluateDecision, variableMap.AsVariableContext()); evaluatedEvents.Add(evaluatedEvent); evaluatedResult = handler.GenerateDecisionResult(evaluatedEvent); if (decision != evaluateDecision) { addResultToVariableContext(evaluatedResult, variableMap, evaluateDecision); } } generateDecisionEvaluationEvent(evaluatedEvents); return(evaluatedResult); }
public void GivenThePerson(string firstName, string surname) { variables = variables.Enrich(new { firstName, surname }); }
public virtual ELContext CreateContext(ExpressionFactory expressionFactory, IVariableContext variableContext) { ELResolver elResolver = this.CreateElResolver(); FunctionMapper functionMapper = this.CreateFunctionMapper(); VariableMapper variableMapper = this.CreateVariableMapper(expressionFactory, variableContext); return(new FeelElContext(elResolver, functionMapper, variableMapper)); }
public virtual ELContext CreateElContext(IVariableContext variableContext) { var elResolver = CachedElResolver; var elContext = new ProcessEngineElContext(FunctionMappers, elResolver); elContext.PutContext(typeof(ExpressionFactory), expressionFactory); elContext.PutContext(typeof(IVariableContext), variableContext); return(elContext); }
protected internal virtual object EvaluateInputExpression(DmnExpressionImpl expression, IVariableContext variableContext) { var expressionLanguage = expression.ExpressionLanguage; if (ReferenceEquals(expressionLanguage, null)) { expressionLanguage = inputExpressionExpressionLanguage; } return(expressionEvaluationHandler.EvaluateExpression(expressionLanguage, expression, variableContext)); }
protected internal virtual IDmnEvaluatedDecisionRule EvaluateMatchingRule( IList <DmnDecisionTableOutputImpl> decisionTableOutputs, DmnDecisionTableRuleImpl matchingRule, IVariableContext variableContext) { var evaluatedDecisionRule = new DmnEvaluatedDecisionRuleImpl(matchingRule); var outputEntries = EvaluateOutputEntries(decisionTableOutputs, matchingRule, variableContext); evaluatedDecisionRule.OutputEntries = outputEntries; return(evaluatedDecisionRule); }
public virtual object GetValue(IVariableContext variableContext) { if (Context.CommandContext == null) { throw new ProcessEngineException( "Expression can only be evaluated inside the context of the process engine"); } var context = Context.ProcessEngineConfiguration.ExpressionManager.CreateElContext(variableContext); return(ValueExpression.GetValue(context)); }
public virtual IDmnDecisionResult EvaluateDecision(IDmnDecision decision, IVariableContext variableContext) { EnsureUtil.EnsureNotNull("decision", decision); EnsureUtil.EnsureNotNull("variableContext", variableContext); if (decision is DmnDecisionImpl) { var decisionContext = new DefaultDmnDecisionContext(dmnEngineConfiguration); return(decisionContext.evaluateDecision(decision, variableContext)); } throw LOG.decisionTypeNotSupported(decision); }
protected internal virtual object EvaluateOutputEntry(DmnExpressionImpl conclusion, IVariableContext variableContext) { var expressionLanguage = conclusion.ExpressionLanguage; if (ReferenceEquals(expressionLanguage, null)) { expressionLanguage = outputEntryExpressionLanguage; } return(expressionEvaluationHandler.EvaluateExpression(expressionLanguage, conclusion, variableContext)); //return null; }
public PostmanAutomationSteps(ApiFixture fixture, ITestOutputHelper output, ScenarioContext scenarioContext) { this.featureFolder = fixture.PostmanCollection(output).FindFolder("Features"); this.scenarioContext = scenarioContext; this.api = fixture.Api; variables = new ImmutableVariableContext(new { baseUrl = api.BaseAddress?.ToString().Trim('/') ?? "http://localhost:5042" }); }
protected internal virtual IVariableMap buildVariableMapFromVariableContext(IVariableContext variableContext) { var variableMap = Variables.CreateVariables(); var variables = variableContext.KeySet(); foreach (var variable in variables) { variableMap.PutValue(variable, variableContext.Resolve(variable)); } return(variableMap); }
public IntegrationTests(ApiFixture fixture, ITestOutputHelper output) { sut = fixture.PostmanCollection(output); api = fixture.Api; client = fixture.ApiClient; variables = new ImmutableVariableContext(new { baseUrl = api.BaseAddress?.ToString().Trim('/') ?? "http://localhost:5042" }); folder = sut.FindFolder("Tests"); }
public virtual IDmnDecisionResult EvaluateDecision(string decisionKey, IDmnModelInstance dmnModelInstance, IVariableContext variableContext) { EnsureUtil.EnsureNotNull("decisionKey", decisionKey); var decisions = ParseDecisions(dmnModelInstance); foreach (var decision in decisions) { if (decisionKey.Equals(decision.Key)) { return(EvaluateDecision(decision, variableContext)); } } throw LOG.unableToFindDecisionWithKey(decisionKey); }
public virtual IDmnDecisionTableResult EvaluateDecisionTable(string decisionKey, Stream inputStream, IVariableContext variableContext) { EnsureUtil.EnsureNotNull("decisionKey", decisionKey); var decisions = ParseDecisions(inputStream); foreach (var decision in decisions) { if (decisionKey.Equals(decision.Key)) { return(EvaluateDecisionTable(decision, variableContext)); } } throw LOG.unableToFindDecisionWithKey(decisionKey); }
public virtual IDmnDecisionTableResult EvaluateDecisionTable(IDmnDecision decision, IVariableContext variableContext) { EnsureUtil.EnsureNotNull("decision", decision); EnsureUtil.EnsureNotNull("variableContext", variableContext); if (decision is DmnDecisionImpl && decision.DecisionTable) { var decisionContext = new DefaultDmnDecisionContext(dmnEngineConfiguration); var decisionResult = decisionContext.evaluateDecision(decision, variableContext); return(DmnDecisionTableResultImpl.Wrap(decisionResult)); } throw LOG.decisionIsNotADecisionTable(decision); }
protected internal virtual IDmnEvaluatedInput EvaluateInput(DmnDecisionTableInputImpl input, IVariableContext variableContext) { var evaluatedInput = new DmnEvaluatedInputImpl(input); var expression = input.Expression; if (expression != null) { object value = EvaluateInputExpression(expression, variableContext); ITypedValue typedValue = expression.TypeDefinition.Transform(value); evaluatedInput.Value = typedValue; } else { evaluatedInput.Value = Variables.UntypedNullValue(); } return(evaluatedInput); }
private bool TryEnsureVariableSubstitution(IVariableContext context, out IEnumerable <string> missingVariables) { missingVariables = Enumerable.Empty <string>(); if (!context.RequiresFullSubstitution) { return(true); } var unsubstitutedVariables = new Regex("{{[a-zA-Z0-9_-]*}}"); var matches = unsubstitutedVariables.Matches(EnrichedContent).OfType <Match>(); if (matches.Any()) { missingVariables = matches.Select(x => x.Value).Distinct(); return(false); } return(true); }
protected internal virtual object EvaluateScriptExpression(string expressionLanguage, IVariableContext variableContext, string expressionText, ICachedCompiledScriptSupport cachedCompiledScriptSupport) { IScriptEngine scriptEngine = GetScriptEngineForName(expressionLanguage); // wrap script engine bindings + variable context and pass enhanced // bindings to the script engine. IBindings bindings = VariableContextScriptBindings.Wrap(scriptEngine.CreateBindings(), variableContext); bindings.Put("variableContext", variableContext); try { if (scriptEngine is ICompilable) { CompiledScript compiledScript = cachedCompiledScriptSupport.GetCachedCompiledScript(); if (compiledScript == null) { lock (cachedCompiledScriptSupport) { compiledScript = cachedCompiledScriptSupport.GetCachedCompiledScript(); if (compiledScript == null) { ICompilable compilableScriptEngine = (ICompilable)scriptEngine; compiledScript = compilableScriptEngine.Compile(expressionText); cachedCompiledScriptSupport.CacheCompiledScript(compiledScript); } } } return(compiledScript.Eval(bindings)); } return(scriptEngine.Eval(expressionText, bindings)); } catch (ScriptException e) { throw Log.unableToEvaluateExpression(expressionText, scriptEngine.GetFactory().LanguageName, e); } }
protected internal virtual void EvaluateDecisionTable(DmnDecisionTableImpl decisionTable, IVariableContext variableContext, DmnDecisionTableEvaluationEventImpl evaluationResult) { var inputSize = decisionTable.Inputs.Count; IList <DmnDecisionTableRuleImpl> matchingRules = new List <DmnDecisionTableRuleImpl>(decisionTable.Rules); for (var inputIdx = 0; inputIdx < inputSize; inputIdx++) { // evaluate input var input = decisionTable.Inputs[inputIdx]; var evaluatedInput = EvaluateInput(input, variableContext); evaluationResult.Inputs.Add(evaluatedInput); // compose local variable context out of global variable context enhanced with the value of the current input. var localVariableContext = GetLocalVariableContext(input, evaluatedInput, variableContext); // filter rules applicable with this input matchingRules = EvaluateInputForAvailableRules(inputIdx, input, matchingRules, localVariableContext); } SetEvaluationOutput(decisionTable, matchingRules, variableContext, evaluationResult); }
public virtual object EvaluateExpression(string expressionLanguage, DmnExpressionImpl expression, IVariableContext variableContext) { var expressionText = GetExpressionTextForLanguage(expression, expressionLanguage); if (!ReferenceEquals(expressionText, null)) { if (IsFeelExpressionLanguage(expressionLanguage)) { //TODO FeelSimpleExpression //throw new NotImplementedException("Feel 语法未实现"); return(EvaluateFeelSimpleExpression(expressionText, variableContext)); } if (IsElExpression(expressionLanguage))//juel { return(EvaluateElExpression(expressionLanguage, expressionText, variableContext, expression)); } //TODO ScriptExpression //throw new NotImplementedException("Script 语法未实现"); return(EvaluateScriptExpression(expressionLanguage, variableContext, expressionText, expression)); } return(null); }
public Field(IVariableContext parent, string id, ITypeItem type) : base(parent, id, type) { }
public virtual IDmnDecisionLogicEvaluationEvent Evaluate(IDmnDecision decision, IVariableContext variableContext) { var evaluationResult = new DmnDecisionTableEvaluationEventImpl(); evaluationResult.DecisionTable = decision; var decisionTable = (DmnDecisionTableImpl)decision.DecisionLogic; evaluationResult.ExecutedDecisionElements = CalculateExecutedDecisionElements(decisionTable); EvaluateDecisionTable(decisionTable, variableContext, evaluationResult); // apply hit policy decisionTable.HitPolicyHandler.apply(evaluationResult); // notify listeners foreach (var evaluationListener in EvaluationListeners) { evaluationListener.Notify(evaluationResult); } return(evaluationResult); }
protected internal virtual object EvaluateFeelSimpleUnaryTests(DmnDecisionTableInputImpl input, DmnExpressionImpl condition, IVariableContext variableContext) { //return new NotImplementedException(); var expressionText = condition.Expression; if (!ReferenceEquals(expressionText, null)) { return(feelEngine.EvaluateSimpleUnaryTests(expressionText, input.InputVariable, variableContext)); } return(null); }
protected internal virtual object EvaluateInputEntry(DmnDecisionTableInputImpl input, DmnExpressionImpl condition, IVariableContext variableContext) { if (IsNonEmptyExpression(condition)) { var expressionLanguage = condition.ExpressionLanguage; if (ReferenceEquals(expressionLanguage, null)) { expressionLanguage = inputEntryExpressionLanguage; } if (expressionEvaluationHandler.IsFeelExpressionLanguage(expressionLanguage)) { return(EvaluateFeelSimpleUnaryTests(input, condition, variableContext)); } return(expressionEvaluationHandler.EvaluateExpression(expressionLanguage, condition, variableContext)); } return(true); // input entries without expressions are true }
public Method(IVariableContext parent, string id, ITypeItem ltype) : base(parent, id, ltype) { }
protected internal virtual IVariableContext GetLocalVariableContext(DmnDecisionTableInputImpl input, IDmnEvaluatedInput evaluatedInput, IVariableContext variableContext) { if (IsNonEmptyExpression(input.Expression)) { var inputVariableName = evaluatedInput.InputVariable; return (CompositeVariableContext.Compose( Variables.CreateVariables() .PutValue("inputVariableName", inputVariableName) .PutValueTyped(inputVariableName, evaluatedInput.Value) .AsVariableContext(), variableContext)); } return(variableContext); }
private void ExtractBaseType() { var type = _rtype; var basetype = type.BaseType; if (null != basetype) { if (basetype == typeof(object) || basetype.IsValueType) { basetype = null; } } if (null != basetype) { _baseclass = ParentTypes.TranslateRType(basetype, TranslateOptions.Add); _lbase = _baseclass as IVariableContext; if (null == _lbase) { throw new Exception("base type [" + basetype.GetRName() + "] is not defined."); } AddDepdendency(_baseclass, DependencyLevel.Constructor); } }
protected internal virtual void SetEvaluationOutput(DmnDecisionTableImpl decisionTable, IList <DmnDecisionTableRuleImpl> matchingRules, IVariableContext variableContext, DmnDecisionTableEvaluationEventImpl evaluationResult) { var decisionTableOutputs = decisionTable.Outputs; IList <IDmnEvaluatedDecisionRule> evaluatedDecisionRules = new List <IDmnEvaluatedDecisionRule>(); foreach (var matchingRule in matchingRules) { var evaluatedRule = EvaluateMatchingRule(decisionTableOutputs, matchingRule, variableContext); evaluatedDecisionRules.Add(evaluatedRule); } evaluationResult.MatchingRules = evaluatedDecisionRules; }
public Property(IVariableContext parent, string id, ITypeItem type) : base(parent, id, type) { }
/// <summary> /// Creates an types item based on a variable context. /// </summary> /// <param name="parent">The variable context.</param> /// <param name="id">The identifier of the item.</param> /// <param name="type">The type of the item.</param> public ItemWithType(IVariableContext parent, string id, ITypeItem type) : base(parent.GetTypeDeclarationContext(), id) { _container = parent; _type = type; }
/// <summary> /// creates a new <see cref="ScriptContext"/> /// </summary> /// <param name="variables">global script variables</param> /// <param name="arguments">arguments provided at runtime</param> public ScriptContext(IVariableContext variables, IVariableProvider arguments) { Variables = variables; Arguments = arguments; }
/// <summary> /// creates a new <see cref="ScriptContext"/> /// </summary> /// <param name="variables">global script variables</param> /// <param name="arguments">arguments provided at runtime</param> /// <param name="cancellationToken">cancellation token used to abort script execution (optional)</param> public ScriptContext(IVariableContext variables, IVariableProvider arguments, CancellationToken cancellationToken) : this(variables, arguments) { CancellationToken = cancellationToken; }
public Variable(IVariableContext parent, string name, ITypeItem type) : base(parent, name, type) { }