public override void Format(NodeExpression finalExpression, IQueryMapping mapping)
{
MethodCallNode methodCallNode = (MethodCallNode)binary.LeftNode;
ConstantNode methodCallArg = (ConstantNode)binary.RightNode;
if (!mapping.Mappings.TryGetValue(methodCallNode.MemberName, out var identifier))
{
identifier = methodCallNode.MemberName;
}
finalExpression.Append('(');
finalExpression.Append(identifier);
finalExpression.Append(' ');
finalExpression.Append(OperationAsString(binary.Operation));
finalExpression.Append(' ');
var parameterName = methodCallNode.MemberName.Replace(".", "");
var type = methodCallArg.ParameterType;
if (type != typeof(string) && (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type)))
{
parameterName += "Collection";
}
finalExpression.Append(methodCallNode.Formatter($"@{parameterName}"));
finalExpression.Parameters.Add(new NodeParameter(parameterName, methodCallArg.Value));
finalExpression.Append(')');
}
private NodeExpression ParseLoopStatement()
{
EatToken(TokenType.KeywordLoop);
NodeExpression body = ParseStatement();
return(new LoopStatement(body));
}
public void CreateBranched()
{
var paragraphOne = Generate("p", "one");
var paragraphTwo = Generate("p", "two");
var div = Generate("div", "one\n\ntwo", new[]
{
paragraphOne,
paragraphTwo
});
var body = Generate("body", "one\n\ntwo", new[] { div });
var document = A.Fake <IDocument>();
A.CallTo(() => document.Body).Returns(body);
var result = NodeExpression.Generate(document, new TextIndexer());
var divExpression = result.Children[0];
var paragraphOneExpression = divExpression.Children[0];
var paragraphTwoExpression = divExpression.Children[1];
result.Children.Count.ShouldBe(1);
divExpression.Children.Count.ShouldBe(2);
result.Content.ShouldBe(divExpression.Content);
result.NodeType.ShouldNotBe(divExpression.NodeType);
paragraphOneExpression.NodeType.ShouldBe(paragraphTwoExpression.NodeType);
paragraphOneExpression.Content.ShouldNotBe(paragraphTwoExpression.NodeType);
}
private void FormatValueExpression(MemberAccessNode me, ConstantNode ce, NodeExpression finalExpression)
{
if (ce.Value is null && !ce.ForceParameter)
{
return;
}
finalExpression.Append(' ');
var memberName = me.Parent != null ? $"{me.Parent.MemberName}.{me.MemberName}" : me.MemberName;
var parameterName = memberName.Replace(".", "");
var type = ce.ParameterType;
if (type != typeof(string) && (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type)))
{
parameterName += "Collection";
}
if (me.Formatter != null)
{
finalExpression.Append(me.Formatter($"@{parameterName}"));
}
else
{
finalExpression.Append($"@{parameterName}");
}
finalExpression.Parameters.Add(new NodeParameter(parameterName, ce.Value));
}
private NodeExpression FinishAssignment(NodeExpression left)
{
EatToken(TokenType.Equal);
var right = ParseExpression();
return(new AssignmentExpression(left, right));
}
private void FormatMemberExpression(MemberAccessNode me, ConstantNode ce, NodeExpression finalExpression, IQueryMapping mapping)
{
var memberName = me.Parent != null ? $"{me.Parent.MemberName}.{me.MemberName}" : me.MemberName;
if (me.MemberName.StartsWith('@'))
{
var parameterName = (me.Parent != null ? $"{me.Parent.MemberName}{me.MemberName}" : me.MemberName)
.Replace(".", "")
.Replace("@", "");
var type = ce.ParameterType;
if (type != typeof(string) && (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type)))
{
parameterName += "Collection";
}
finalExpression.Append('@');
finalExpression.Append(parameterName);
}
else
{
if (!mapping.Mappings.TryGetValue(memberName, out var identifier))
{
identifier = memberName;
}
finalExpression.Append(identifier);
}
}
/// <summary>
/// Adds a node with the specified name to the graph.
/// </summary>
/// <param name="name">The name of the node to create.</param>
/// <returns>
/// A node expression for configuring the node.
/// </returns>
public INodeExpression WithName(string name) {
var node = new GraphNode(name);
graph.AddNode(node);
var expression = new NodeExpression(node);
return expression;
}
private NodeExpression FinishIndex(NodeExpression target)
{
EatToken(TokenType.OpenBracket);
NodeExpression index = ParseExpression();
EatToken(TokenType.CloseBracket);
return(new IndexExpression(target, index));
}
public void WithTag_Should_Set_Tag_On_Node()
{
var node = new GraphNode("gg");
var expression = new NodeExpression(node);
expression.WithTag(5);
Assert.AreEqual(node.Tag, 5);
}
NodeExpression ParseMemberExpression(Boolean isNewExpression = false)
{
NodeExpression expression = ParsePrimaryExpression();
while (PeekToken().Type == TokenType.Dot)
{
expression = ParseMember(expression, isNewExpression);
}
return(expression);
}
public void ContainsScaledImage_Should_Add_Image_And_Scaled_Attribute()
{
var node = new GraphNode("gg");
var expression = new NodeExpression(node);
expression.ContainsScaledImage("FluentDot.Tests.dll");
Assert.AreEqual(node.Attributes.CurrentAttributes.Count, 2);
AssertAttributeAdded(node.Attributes.CurrentAttributes[0], typeof(ImageAttribute), Path.GetFullPath("FluentDot.Tests.dll"));
AssertAttributeAdded(node.Attributes.CurrentAttributes[1], typeof(ImageScaleAttribute), new BooleanValue(true));
}
private NodeExpression ParseMember(NodeExpression expr, Boolean isNewExpression = false)
{
EatToken(TokenType.Dot);
Token name = ParseId();
if (!isNewExpression && PeekToken().Type == TokenType.OpenParen)
{
return(new MemberExpression(expr, name.Value, MemberType.MethodCall));
}
return(new MemberExpression(expr, name.Value, MemberType.Member));
}
public override void Format(NodeExpression finalExpression, IQueryMapping mapping)
{
ConstantNode c1 = (ConstantNode)binary.LeftNode;
ConstantNode c2 = (ConstantNode)binary.RightNode;
finalExpression.Append('(');
finalExpression.Append(c1.Value);
finalExpression.Append(' ');
finalExpression.Append(OperationAsString(binary.Operation));
finalExpression.Append(' ');
finalExpression.Append(c2.Value);
finalExpression.Append(')');
}
private NodeExpression ParseBreakStatement()
{
NodeExpression expr = null;
EatToken(TokenType.KeywordBreak);
if (MaybeEatToken(TokenType.OpenParen))
{
expr = ParseExpression();
EatToken(TokenType.CloseParen);
}
MaybeEatToken(TokenType.SemiColon);
return(new BreakExpression(expr));
}
private void HandleNode(Token token, Stack <IContextExpression> stack, NodeExpression node)
{
if (!stack.Any())
{
throw new ExpressionParseException(string.Format(
"AND without expression to left, position {0}",
token.Position));
}
node.LeftChild = stack.Pop();
stack.Push(node);
}
public override void Format(NodeExpression finalExpression, IQueryMapping mapping)
{
finalExpression.Append('(');
GetForNode(binary.LeftNode).Format(finalExpression, mapping);
finalExpression.Append(' ');
finalExpression.Append(OperationAsString(binary.Operation));
finalExpression.Append(' ');
GetForNode(binary.RightNode).Format(finalExpression, mapping);
finalExpression.Append(')');
}
private NodeExpression FinishCall(NodeExpression target)
{
EatToken(TokenType.OpenParen);
var args = new List <NodeExpression>();
if (PeekToken().Type != TokenType.CloseParen)
{
args.Add(ParseExpression());
while (MaybeEatToken(TokenType.Comma))
{
args.Add(ParseExpression());
}
}
EatToken(TokenType.CloseParen);
return(new FunctionCallExpression(target, args.ToArray()));
}
public override void Format(NodeExpression finalExpression, IQueryMapping mapping)
{
var me = (MemberAccessNode)binary.LeftNode;
var ce = (ConstantNode)binary.RightNode;
finalExpression.Append('(');
FormatMemberExpression(me, ce, finalExpression, mapping);
finalExpression.Append(' ');
finalExpression.Append((ce.Value is null && !ce.ForceParameter)
? (binary.Operation == Operation.Equal ? "IS NULL" : "IS NOT NULL")
:
OperationAsString(binary.Operation));
FormatValueExpression(me, ce, finalExpression);
finalExpression.Append(')');
}
public void CreateLinear()
{
var paragraph = Generate("p", "big");
var div = Generate("div", "big", new[] { paragraph });
var body = Generate("body", "big testing", new[] { div });
var document = A.Fake <IDocument>();
A.CallTo(() => document.Body).Returns(body);
var result = NodeExpression.Generate(document, new TextIndexer());
var divExpression = result.Children[0];
var paragraphExpression = divExpression.Children[0];
paragraphExpression.Children.ShouldBeEmpty();
paragraphExpression.Content.ShouldBe(divExpression.Content);
paragraphExpression.NodeType.ShouldNotBe(divExpression.NodeType);
divExpression.Children.Count.ShouldBe(1);
result.Content.ShouldNotBe(divExpression.Content);
}
/// <summary>
/// if (a) then
/// # do something
/// elseif (b) then
/// # do something else
/// else
/// # or do this
/// end
/// </summary>
/// <returns></returns>
private NodeExpression ParseIfStatement()
{
EatToken(TokenType.KeywordIf);
var ifStatements = new List <IfStatementTest> {
ParseIfStatementTest()
};
while (MaybeEatToken(TokenType.KeywordElseIf))
{
ifStatements.Add(ParseIfStatementTest());
}
NodeExpression elseStatement = null;
if (MaybeEatToken(TokenType.KeywordElse))
{
elseStatement = ParseStatement();
}
return(new IfStatement(ifStatements, elseStatement));
}
private NodeExpression ParseNew()
{
NodeExpression constructor = ParseMemberExpression(true);
EatToken(TokenType.OpenParen);
var arguments = new List <NodeExpression>();
for (; ;)
{
Token end = PeekToken();
if (end.Type == TokenType.CloseParen)
{
NextToken();
break;
}
arguments.Add(ParseExpression());
}
return(new NewExpression(constructor, arguments.ToArray()));
}
private NodeExpression FinishExpressionTerminal(NodeExpression expr)
{
for (; ;)
{
Token tok = PeekToken();
switch (tok.Type)
{
case TokenType.Dot:
expr = ParseMember(expr);
break;
case TokenType.OpenParen:
expr = FinishCall(expr);
break;
case TokenType.OpenBracket:
expr = FinishIndex(expr);
break;
default:
return(expr);
}
}
}
public ExprSub(NodeTask task, NodeExpression a0, NodeExpression a1)
: base(task, a0, a1)
{
}
protected BoolBinExpression(NodeTask task, NodeExpression a0, NodeExpression a1)
: base(task, a0, a1)
{
}
/// <summary>
/// Populates the analyser type for column.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="entityType">The resource type returned if the analyser refers to a resource expression.</param>
/// <param name="reportExpression">The report expression.</param>
/// <param name="reportAnalyserColumn">The report analyser column.</param>
private static void PopulateAnalyserTypeForColumn(Report report, EntityType entityType, ReportExpression reportExpression, ReportAnalyserColumn reportAnalyserColumn)
{
reportAnalyserColumn.AnalyserType = reportAnalyserColumn.Type.GetDisplayName();
if (reportExpression.Is <StructureViewExpression>())
{
reportAnalyserColumn.AnalyserType = StructureLevelsType.DisplayName;
reportAnalyserColumn.DefaultOperator = Structured.ConditionType.AnyBelowStructureLevel;
var expression = reportExpression.As <StructureViewExpression>();
var resReportNode = expression.StructureViewExpressionSourceNode.As <ResourceReportNode>();
var eType = resReportNode.ResourceReportNodeType;
reportAnalyserColumn.TypeId = eType.Id;
return;
}
if (!reportExpression.Is <NodeExpression>())
{
return;
}
NodeExpression nodeExpression = reportExpression.As <NodeExpression>();
if (!nodeExpression.SourceNode.Is <ResourceReportNode>())
{
return;
}
bool isNameColumnForType = false;
if (reportExpression.Is <FieldExpression>())
{
var fieldExpression = reportExpression.As <FieldExpression>();
if (fieldExpression.FieldExpressionField.Alias != "core:name")
{
return;
}
long sourceId = fieldExpression.SourceNode != null ? fieldExpression.SourceNode.Id : 0;
long rootId = report.RootNode != null ? report.RootNode.Id : 0;
isNameColumnForType = (sourceId == rootId) && (sourceId != 0);
}
reportAnalyserColumn.IsNameColumnForType = isNameColumnForType;
ResourceReportNode resourceReportNode = nodeExpression.SourceNode.As <ResourceReportNode>( );
RelationshipReportNode relationshipReportNode = nodeExpression.SourceNode.As <RelationshipReportNode>( );
if (entityType == null)
{
// Need to be able accept entityType as an argument, e.g. if it is from a script column
// But also need to be able to read it from the node, e.g. if it is the root name column. Messed up.
entityType = resourceReportNode.ResourceReportNodeType;
if (entityType == null)
{
return;
}
}
ResourceExpression resourceExpression = reportExpression.As <ResourceExpression>();
// Handle "Type" types
//if the resource type is "Type", add current parent node type and descendant types' id as filtered entity ids (bug 24859)
//Update: only the forward relationship is "isOfType", the "type" list will be restricted. (bug 27862)
if (entityType.Alias == "core:type" &&
relationshipReportNode?.FollowRelationship?.Alias == "core:isOfType"
)
{
AggregateReportNode parentAggregatedNode = resourceReportNode.ParentAggregatedNode;
ReportNode parentReportNode = parentAggregatedNode != null ? parentAggregatedNode.GroupedNode : resourceReportNode.ParentReportNode;
ResourceReportNode parentResourceReportNode = parentReportNode != null?parentReportNode.As <ResourceReportNode>() : null;
if (parentResourceReportNode != null && parentResourceReportNode.ResourceReportNodeType != null)
{
reportAnalyserColumn.FilteredEntityIds = PerTenantEntityTypeCache.Instance.GetDescendantsAndSelf(
parentResourceReportNode.ResourceReportNodeType.Id).ToArray();
}
}
// Handle "User" and "Person" types
if (PerTenantEntityTypeCache.Instance.IsDerivedFrom(entityType.Id, "core:person") ||
PerTenantEntityTypeCache.Instance.IsDerivedFrom(entityType.Id, "core:userAccount"))
{
// If this is a relationship or calc then make it as a user inline relationship otherwise a simple user string.
reportAnalyserColumn.AnalyserType = nodeExpression.SourceNode.Is <FieldExpression>( ) ? "UserString" : "UserInlineRelationship";
return;
}
// Treat the root 'Name' column like a lookup, so we get the 'Any Of', 'Any Except' options.
if (isNameColumnForType)
{
reportAnalyserColumn.AnalyserType = "InlineRelationship";
reportAnalyserColumn.TypeId = entityType.Id;
}
}
NodeExpression ParsePostfixExpression()
{
NodeExpression expr = ParsePrimaryExpression();
return(FinishExpressionTerminal(expr));
}
private static void AssertAttributeAdded(Action<INodeExpression> action, Type attributeType, object attributeValue, Action<IGraphNode> customAsserts)
{
var node = new GraphNode("gg");
var expression = new NodeExpression(node);
action(expression);
Assert.AreEqual(node.Attributes.CurrentAttributes.Count, 1);
AssertAttributeAdded(node.Attributes.CurrentAttributes[0], attributeType, attributeValue);
if (customAsserts != null)
{
customAsserts(node);
}
}
/// <summary>
/// Builds the expression.
/// </summary>
/// <param name="reportExpression">The report expression.</param>
/// <param name="context">The context.</param>
/// <returns>ScalarExpression.</returns>
internal static ScalarExpression BuildExpression(ReportExpression reportExpression, FromEntityContext context)
{
if (reportExpression == null)
{
EventLog.Application.WriteWarning(context.DebugInfo + "reportExpression was null");
return(null);
}
// Verify that there is a valid node - prior to converting expressions (invalid nodes may be only partially loaded)
// Update the reference table for expressions of interest ignoring anything that is a column expression
long nodeId = 0;
NodeExpression nodeExpression = reportExpression.As <NodeExpression>( );
if (nodeExpression != null)
{
nodeId = nodeExpression.SourceNode.Id;
// Check that we have a valid node for it
if (!context.ReportNodeToEntityMap.ContainsKey(nodeId))
{
EventLog.Application.WriteWarning(context.DebugInfo + "expression node could not be found");
return(null);
}
}
// Convert specific expression types
ScalarExpression scalarExpression;
if (context.InstanceExpressionMap.TryGetValue(reportExpression.Id, out scalarExpression))
{
return(scalarExpression);
}
if (reportExpression.Is <Model.IdExpression>())
{
scalarExpression = BuildIdExpression(reportExpression.As <Model.IdExpression>());
}
else if (reportExpression.Is <Model.ResourceExpression>())
{
scalarExpression = BuildResourceExpression(reportExpression.As <Model.ResourceExpression>(), context);
}
else if (reportExpression.Is <Model.FieldExpression>())
{
scalarExpression = BuildFieldExpression(reportExpression.As <Model.FieldExpression>(), context);
}
else if (reportExpression.Is <Model.ScriptExpression>())
{
scalarExpression = BuildScriptExpression(reportExpression.As <Model.ScriptExpression>());
}
else if (reportExpression.Is <Model.AggregateExpression>())
{
return(BuildAggregateExpression(reportExpression.As <Model.AggregateExpression>(), context));
}
else if (reportExpression.Is <Model.ColumnReferenceExpression>())
{
return(BuildColumnReferenceExpression(reportExpression.As <ColumnReferenceExpression>(), context));
}
else if (reportExpression.Is <Model.StructureViewExpression>())
{
return(BuildStructureViewExpression(reportExpression.As <Model.StructureViewExpression>(), context));
}
// Final book keeping
if (scalarExpression != null)
{
if (nodeExpression != null)
{
Guid key = Guid.NewGuid( );
context.ReportExpressionMap[key] = nodeId;
scalarExpression.ExpressionId = key;
scalarExpression.EntityId = nodeExpression.Id;
}
context.InstanceExpressionMap[reportExpression.Id] = scalarExpression;
}
ApplyExpressionClustering(scalarExpression, reportExpression, context);
return(scalarExpression);
}
protected CmpExpression(NodeTask task, NodeExpression a0, NodeExpression a1)
: base(task, a0, a1)
{
}
