public object Execute(VariableContext context = null)
{
var funcName = _function.Execute(context);
if (funcName is Variable outFuncVar && outFuncVar.ValueType == DataTypeEnum.Function)
{
if (_parameters is PositionalParameters)
{
var lVars = RetrieveListOfParameters(context);
return(outFuncVar.UserFunction.Execute(lVars, context));
}
if (_parameters is NamedParameters nParams)
{
return(outFuncVar.UserFunction.Execute(null, context, nParams));
}
}
if (funcName is Variable outFuncName && outFuncName.ValueType == DataTypeEnum.String)
{
List <Variable> lVars = new List <Variable> ();
if (_parameters is PositionalParameters)
{
lVars = RetrieveListOfParameters(context);
if (VariableContextHelper.RetrieveBkm(outFuncName, context, out var bkmMeta))
{
return(DMNDoerHelper.EvalBkm(bkmMeta.BKMModel, context, lVars));
}
if (context.DecisionServiceMetaByName.TryGetValue(outFuncName, out var decisionService))
{
return(DMNDoerHelper.EvalDecisionService(decisionService, context, lVars));
}
}
if (_parameters is NamedParameters namedParam)
{
if (VariableContextHelper.RetrieveBkm(outFuncName, context, out var bkmMeta))
{
lVars = BKMConvertNamedParameter(namedParam, bkmMeta.BKMModel, context);
return(DMNDoerHelper.EvalBkm(bkmMeta.BKMModel, context, lVars));
}
if (context.DecisionServiceMetaByName.TryGetValue(outFuncName, out var decisionService))
{
lVars = DecisionServiceConvertNamedParameter(namedParam, decisionService, context);
return(DMNDoerHelper.EvalDecisionService(decisionService, context, lVars));
}
}
var funcMeta = BuiltInFactory.GetFunc(outFuncName);
if (_parameters is NamedParameters nParam)
{
lVars = BuiltInFactory.ConvertNamedParameter(nParam, funcMeta.Item2, context);
}
return(funcMeta.Item1.Execute(lVars));
}
throw new FEELException("Function name is not a variable of string type");
}
public object Execute(VariableContext context = null)
{
if (context != null)
{
var ctxVar = VariableContextHelper.RetrieveLocaContext(context, _nameInput, false);
if (ctxVar != null)
{
return(ctxVar);
}
var funcVar = VariableContextHelper.RetrieveFunctionInput(context, _nameInput, false);
if (funcVar != null)
{
return(funcVar);
}
//get the input variables first before decision names if there is overlapping name conflicts
var outVar = VariableContextHelper.RetrieveInputVariable(context, _nameInput, false);
if (outVar != null)
{
return(outVar);
}
var decisionVar = DMNDoerHelper.EvaluateDecisionByName(context, _nameInput);
if (decisionVar != null)
{
//all the values that override is always string variable
var overrideVar = VariableContextHelper.RetrieveInputVariable(context, _nameInput, false);
if (overrideVar != null)
{
return(VariableHelper.MakeVariable(overrideVar.StringVal, decisionVar.ValueType));
}
return(decisionVar);
}
}
return(new Variable(_nameInput));
}
public object Execute(VariableContext context = null, string inputName = null)
{
if (Operator == OperatorEnum.NF && inputName is null)
{
return(Right.Execute(context));
}
var inputVariable = VariableContextHelper.RetrieveInputVariable(context, inputName);
var rightVar = (Variable)Right.Execute(context);
if (inputVariable.ValueType != rightVar.ValueType)
{
throw new FEELException($"Left value {inputVariable.ValueType} and right {rightVar.ValueType} are not the same for comparison");
}
switch (Operator)
{
case OperatorEnum.GT:
return(new Variable(inputVariable > rightVar));
case OperatorEnum.GE:
return(new Variable(inputVariable >= rightVar));
case OperatorEnum.LT:
return(new Variable(inputVariable < rightVar));
case OperatorEnum.LE:
return(new Variable(inputVariable <= rightVar));
case OperatorEnum.NF:
return(new Variable(inputVariable.Equals(rightVar)));
default:
throw new FEELException($"The following operator {Operator} is not supported");
}
}
public object Execute(VariableContext context = null, string inputName = null)
{
if (Expression is TestWrapper testwrap)
{
testwrap.InputDataName = inputName;
return(testwrap.Execute(context));
}
if (Expression is IExpression expr)
{
var inputVariable = VariableContextHelper.RetrieveInputVariable(context, inputName);
if (Expression is ListLiteral lt)
{
foreach (var listExpr in lt.Expressions)
{
if (listExpr is TestWrapper tW)
{
tW.InputDataName = inputName;
Variable twBool = null;
try {
twBool = (Variable)tW.Execute(context);
if (twBool.ValueType == DataTypeEnum.Boolean)
{
if (twBool.BoolVal)
{
return(new Variable(true));
}
}
else
{
throw new ArgumentException($"Expected a test condition result of boolean not:{twBool.ValueType}");
}
} catch (FEELException) {
//do nothing skip not matching types
} catch (Exception ex) {
throw ex;
}
}
else if (listExpr is IExpression regExpr)
{
var regVar = (Variable)regExpr.Execute(context);
if (regVar.Equals(inputVariable))
{
return(new Variable(true));
}
}
}
return(new Variable(false));
}
var exprVar = (Variable)expr.Execute(context);
if (exprVar.IsListType())
{
foreach (var item in exprVar.ListVal)
{
if (inputVariable.Equals(item))
{
return(new Variable(true));
}
}
}
if (inputVariable.ValueType != exprVar.ValueType)
{
throw new FEELException($"Left value {inputVariable.ValueType} and right {exprVar.ValueType} are not the same for comparison");
}
return(new Variable(inputVariable.Equals(exprVar)));
}
if (Expression is ITestExpression texpr)
{
return(texpr.Execute(context, inputName));
}
throw new FEELException("Unexepected type of expression for positive unary test");
}
public object Execute(VariableContext context = null)
{
if (Names.Count == 1)
{
var funcVar = VariableContextHelper.RetrieveFunctionInput(context, Names[0], false);
if (funcVar != null)
{
return(funcVar);
}
var outVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (outVar != null)
{
return(outVar);
}
outVar = VariableContextHelper.RetrieveGlobalVariable(context, Names[0], false);
if (outVar != null)
{
return(outVar);
}
var decisionVar = DMNDoerHelper.EvaluateDecisionByName(context, Names[0]);
if (decisionVar != null)
{
//all the values that override is always string variable
var overrideVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (overrideVar != null)
{
return(VariableHelper.MakeVariable(overrideVar.StringVal, decisionVar.ValueType));
}
return(decisionVar);
}
return(new Variable(Names[0]));
}
//Context parent child layers
var ctxVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (ctxVar == null)
{
ctxVar = VariableContextHelper.RetrieveGlobalVariable(context, Names[0], false);
}
if (ctxVar == null)
{
ctxVar = DMNDoerHelper.EvaluateDecisionByName(context, Names[0]);
//all the values that override is always string variable
var overrideVar = VariableContextHelper.RetrieveInputVariable(context, Names[0], false);
if (overrideVar != null)
{
var overrideTyped = VariableHelper.MakeVariable(overrideVar.StringVal, ctxVar.ValueType);
ctxVar = overrideTyped;
}
}
if (ctxVar == null && ctxVar.ValueType != DataTypeEnum.Context)
{
throw new FEELException("Failed finding a context variable");
}
for (int i = 1; i < Names.Count; i++)
{
switch (ctxVar.ValueType)
{
case DataTypeEnum.Context:
ctxVar = FindContextVariable(Names[i], ctxVar);
break;
case DataTypeEnum.Date:
return(DateAndTimeHelper.DatePropEvals(ctxVar, Names[i]));
case DataTypeEnum.DateTime:
return(DateAndTimeHelper.DateTimePropEvals(ctxVar, Names[i]));
case DataTypeEnum.Time:
return(DateAndTimeHelper.TimePropEvals(ctxVar, Names[i]));
case DataTypeEnum.YearMonthDuration:
case DataTypeEnum.DayTimeDuration:
return(DateAndTimeHelper.DurationPropEvals(ctxVar, Names[i]));
default:
throw new FEELException($"Path expression for {ctxVar.ValueType} is not supported");
}
}
return(ctxVar);
}
public object Execute(VariableContext context = null, string inputName = null)
{
var leftVar = (Variable)LeftExpression.Execute(context);
var rightVar = (Variable)RightExpression.Execute(context);
// this is not a test due to missing input therefore return a list
if (inputName == null)
{
leftVar.ExpectedDataType(DataTypeEnum.Decimal);
rightVar.ExpectedDataType(DataTypeEnum.Decimal);
var range = RangeHelper.Decimal(leftVar, rightVar).ToList();
return(Variable.ListType(range, DataTypeEnum.ListDecimal));
}
var inputVariable = VariableContextHelper.RetrieveInputVariable(context, inputName);
if (inputVariable.ValueType != rightVar.ValueType)
{
throw new FEELException($"Right value {inputVariable.ValueType} and right {rightVar.ValueType} are not the same for comparison");
}
if (inputVariable.ValueType != leftVar.ValueType)
{
throw new FEELException($"Left value {inputVariable.ValueType} and right {leftVar.ValueType} are not the same for comparison");
}
if (leftVar > rightVar)
{
throw new FEELException($"Left value {leftVar} cannot be greater than right value {rightVar}");
}
var leftBool = false;
var rightBool = false;
// is in the interval (e1..e2), also notated ]e1..e2[, if and only if o > e1 and o < e1
// is in the interval (e1..e2], also notated ]e1..e2], if and only if o > e1 and o ≤ e2
// is in the interval [e1..e2] if and only if o ≥ e1 and o ≤ e2
// is in the interval [e1..e2), also notated [e1..e2[, if and only if o ≥ e1 and o < e2
switch (Start)
{
case "(":
case "]":
leftBool = inputVariable > leftVar;
break;
case "[":
leftBool = inputVariable >= leftVar;
break;
default:
throw new FEELException($"Incorrect start {Start} interval character");
}
switch (End)
{
case ")":
case "[":
rightBool = inputVariable < rightVar;
break;
case "]":
rightBool = inputVariable <= rightVar;
break;
default:
throw new FEELException($"Incorrect end {End} interval character");
}
return(new Variable(leftBool && rightBool));
}
