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)
{
}
