/// <summary>
/// Initializes a new instance of <see cref="SixParamsFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
/// <param name="parameter1">The function first parameter value.</param>
/// <param name="parameter2">The function second parameter value.</param>
/// <param name="parameter3">The function third parameter value.</param>
/// <param name="parameter4">The function fourth parameter value.</param>
/// <param name="parameter5">The function fifth parameter value.</param>
/// <param name="parameter6">The function sixth parameter value.</param>
protected SixParamsFunctionNode(ExpressionNodeType nodeType, ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3, ExpressionNode parameter4, ExpressionNode parameter5, ExpressionNode parameter6)
: this(nodeType)
{
if (parameter1 == null)
throw new ArgumentException("Parameter 'parameter1' should contain a value.", "parameter1");
if (parameter2 == null)
throw new ArgumentException("Parameter 'parameter2' should contain a value.", "parameter2");
if (parameter3 == null)
throw new ArgumentException("Parameter 'parameter3' should contain a value.", "parameter3");
if (parameter4 == null)
throw new ArgumentException("Parameter 'parameter4' should contain a value.", "parameter4");
if (parameter5 == null)
throw new ArgumentException("Parameter 'parameter5' should contain a value.", "parameter5");
if (parameter6 == null)
throw new ArgumentException("Parameter 'parameter6' should contain a value.", "parameter6");
Parameter1 = parameter1;
Parameter2 = parameter2;
Parameter3 = parameter3;
Parameter4 = parameter4;
Parameter5 = parameter5;
Parameter6 = parameter6;
}
/// <summary>
/// Initializes a new instance of <see cref="SingleParamFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
/// <param name="parameter">The function parameter value.</param>
/// <exception cref="System.ArgumentException">Parameter 'parameter' should contain a value.;parameter</exception>
public SingleParamFunctionNode(ExpressionNodeType nodeType, ExpressionNode parameter)
: this(nodeType)
{
if (parameter == null)
throw new ArgumentException("Parameter 'parameter' should contain a value.", "parameter");
Parameter = parameter;
}
/// <summary>
/// Initializes a new instance of <see cref="ResultNode"/> class.
/// </summary>
/// <param name="fieldName">Name of the field.</param>
/// <param name="expression">The result expression.</param>
public ResultNode(string fieldName, ExpressionNode expression) : base(ExpressionNodeType.Result)
{
if (String.IsNullOrEmpty(fieldName))
throw new ArgumentException("Parameter 'fieldName' should contain a value.", "fieldName");
if (expression == null)
throw new ArgumentException("Parameter 'expression' should contain a value.", "expression");
FieldName = fieldName;
Expression = expression;
}
/// <summary>
/// Initializes a new instance of <see cref="SingleParamFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
/// <param name="parameter1">The function first parameter value.</param>
/// <param name="parameter2">The function second parameter value.</param>
protected TwoParamsFunctionNode(ExpressionNodeType nodeType, ExpressionNode parameter1, ExpressionNode parameter2)
: this(nodeType)
{
if (parameter1 == null)
throw new ArgumentException("Parameter 'parameter1' should contain a value.", "parameter1");
if (parameter2 == null)
throw new ArgumentException("Parameter 'parameter2' should contain a value.", "parameter2");
Parameter1 = parameter1;
Parameter2 = parameter2;
}
/// <summary>
/// Initializes a new instance of <see cref="IfStatementNode"/> class.
/// </summary>
/// <param name="conditionNode">Condition to check.</param>
/// <param name="trueNode">true node result.</param>
/// <param name="falseNode">false node result.</param>
public IfStatementNode(ExpressionNode conditionNode, ExpressionNode trueNode, ExpressionNode falseNode)
:base(ExpressionNodeType.If)
{
if (conditionNode == null)
throw new ArgumentException("Parameter 'conditionNode' should contain a value.", "conditionNode");
if (trueNode == null)
throw new ArgumentException("Parameter 'trueNode' should contain a value.", "trueNode");
if (falseNode == null)
throw new ArgumentException("Parameter 'falseNode' should contain a value.", "falseNode");
ConditionNode = conditionNode;
TrueNode = trueNode;
FalseNode = falseNode;
}
/// <summary>
/// Initializes a new instance of the <see cref="SetChecklistDataFunctionNode"/> class.
/// </summary>
/// <param name="parameter">
/// The parameter.
/// </param>
/// <param name="id">
/// The node id.
/// </param>
public SetChecklistDataFunctionNode(ExpressionNode parameter, Guid id)
: base(ExpressionNodeType.SetChecklistData, parameter)
{
Id = id;
}
private ExpressionFunction ConvertNode(ExpressionNode node)
{
var result = new ExpressionFunction();
var sourceFieldNode = node as SourceFieldNode;
if (sourceFieldNode != null)
{
result.FunctionType = "source";
result.Definition = new ExpressionSourceFunctionDefinition
{
Key = GetSourceFieldName(sourceFieldNode),
SetName = sourceFieldNode.SetName
};
return result;
}
var constantNode = node as ConstantNode;
if (constantNode != null)
{
result.FunctionType = "constant";
result.Definition = new ExpressionConstantFunctionDefinition { Value = constantNode.Value };
return result;
}
var isNullNode = node as IsNullFunctionNode;
if (isNullNode != null)
{
result.FunctionType = isNullNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(isNullNode.Parameter)
};
return result;
}
var notNode = node as NotFunctionNode;
if (notNode != null)
{
result.FunctionType = notNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(notNode.Parameter)
};
return result;
}
var toUpperNode = node as ToUpperFunctionNode;
if (toUpperNode != null)
{
result.FunctionType = toUpperNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(toUpperNode.Parameter)
};
return result;
}
var toLowerNode = node as ToLowerFunctionNode;
if (toLowerNode != null)
{
result.FunctionType = toLowerNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(toLowerNode.Parameter)
};
return result;
}
var trimNode = node as TrimFunctionNode;
if (trimNode != null)
{
result.FunctionType = trimNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(trimNode.Parameter)
};
return result;
}
var twoParamsNode = node as TwoParamsFunctionNode;
if (twoParamsNode != null)
{
result.FunctionType = twoParamsNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionTwoInputFunctionDefinition
{
In1 = ConvertNode(twoParamsNode.Parameter1),
In2 = ConvertNode(twoParamsNode.Parameter2)
};
return result;
}
var threeParamsNode = node as ThreeParamsFunctionNode;
if (threeParamsNode != null)
{
result.FunctionType = threeParamsNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionThreeInputFunctionDefinition
{
In1 = ConvertNode(threeParamsNode.Parameter1),
In2 = ConvertNode(threeParamsNode.Parameter2),
In3 = ConvertNode(threeParamsNode.Parameter3)
};
return result;
}
var ifFunctionNode = node as IfStatementNode;
if (ifFunctionNode != null)
{
result.FunctionType = ifFunctionNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionThreeInputFunctionDefinition
{
In1 = ConvertNode(ifFunctionNode.ConditionNode),
In2 = ConvertNode(ifFunctionNode.TrueNode),
In3 = ConvertNode(ifFunctionNode.FalseNode)
};
return result;
}
var dateDayNode = node as DateDayFunctionNode;
if (dateDayNode != null)
{
result.FunctionType = dateDayNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateDayNode.Parameter)
};
return result;
}
var dateNode = node as DateFunctionNode;
if (dateNode != null)
{
result.FunctionType = dateNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateNode.Parameter)
};
return result;
}
var dateMonthNode = node as DateMonthFunctionNode;
if (dateMonthNode != null)
{
result.FunctionType = dateMonthNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateMonthNode.Parameter)
};
return result;
}
var dateMonthNameNode = node as DateMonthNameFunctionNode;
if (dateMonthNameNode != null)
{
result.FunctionType = dateMonthNameNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateMonthNameNode.Parameter)
};
return result;
}
var dateQuarterNode = node as DateQuarterFunctionNode;
if (dateQuarterNode != null)
{
result.FunctionType = dateQuarterNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateQuarterNode.Parameter)
};
return result;
}
var dateWeekNode = node as DateWeekFunctionNode;
if (dateWeekNode != null)
{
result.FunctionType = dateWeekNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateWeekNode.Parameter)
};
return result;
}
var dateYearNode = node as DateYearFunctionNode;
if (dateYearNode != null)
{
result.FunctionType = dateYearNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(dateYearNode.Parameter)
};
return result;
}
var countNode = node as CountFunctionNode;
if (countNode != null)
{
result.FunctionType = countNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(countNode.Parameter)
};
return result;
}
var lengthNode = node as LengthFunctionNode;
if (lengthNode != null)
{
result.FunctionType = lengthNode.NodeType.ToString().ToLowerInvariant();
result.Definition = new ExpressionOneInputFunctionDefinition
{
In1 = ConvertNode(lengthNode.Parameter)
};
return result;
}
return result;
}