protected internal virtual bool IsConditionApplicable(DmnDecisionTableInputImpl input,
DmnExpressionImpl condition, IVariableContext variableContext)
{
var result = EvaluateInputEntry(input, condition, variableContext);
return((result != null) && result.Equals(true));
}
protected internal virtual void NotifyTransformListeners(IInput input, DmnDecisionTableInputImpl dmnInput)
{
foreach (var transformListener in transformListeners)
{
transformListener.transformDecisionTableInput(input, dmnInput);
}
}
public virtual DmnTransformException DecisionTableInputIdIsMissing(IDmnDecision dmnDecision,
DmnDecisionTableInputImpl dmnDecisionTableInput)
{
return
(new DmnTransformException(ExceptionMessage("011",
string.Format("The decision table input '{0}' of decision '{1}' must have a 'id' attribute set.",
dmnDecisionTableInput, dmnDecision))));
}
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 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);
}
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
}
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);
}
protected internal virtual IList <DmnDecisionTableRuleImpl> EvaluateInputForAvailableRules(int conditionIdx,
DmnDecisionTableInputImpl input, IList <DmnDecisionTableRuleImpl> availableRules,
IVariableContext variableContext)
{
IList <DmnDecisionTableRuleImpl> matchingRules = new List <DmnDecisionTableRuleImpl>();
foreach (var availableRule in availableRules)
{
var condition = availableRule.Conditions[conditionIdx];
if (IsConditionApplicable(input, condition, variableContext))
{
matchingRules.Add(availableRule);
}
}
return(matchingRules);
}
public DmnEvaluatedInputImpl(DmnDecisionTableInputImpl input)
{
id = input.Id;
name = input.Name;
inputVariable = input.InputVariable;
}
