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 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 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 EvaluateOutputEntry(DmnExpressionImpl conclusion,
IVariableContext variableContext)
{
var expressionLanguage = conclusion.ExpressionLanguage;
if (ReferenceEquals(expressionLanguage, null))
{
expressionLanguage = outputEntryExpressionLanguage;
}
return(expressionEvaluationHandler.EvaluateExpression(expressionLanguage, conclusion, variableContext));
//return null;
}
// helper ///////////////////////////////////////////////////////////////////
protected internal virtual string GetExpressionTextForLanguage(DmnExpressionImpl expression,
string expressionLanguage)
{
var expressionText = expression.Expression;
if (!ReferenceEquals(expressionText, null))
{
if (IsJuelExpression(expressionLanguage) && !Common.Utils.StringUtil.IsExpression(expressionText))
{
return("${" + expressionText + "}");
}
return(expressionText);
}
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 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);
}
protected internal virtual bool IsNonEmptyExpression(DmnExpressionImpl expression)
{
return((expression != null) && !ReferenceEquals(expression.Expression, null) &&
(expression.Expression.Trim().Length > 0));
}
