private void ApplyAlias(IFieldQueryNode node, IQueryVisitorContext context)
{
if (node.Parent == null)
{
return;
}
var resolver = node.Parent.GetAliasResolver(context);
var result = resolver != null && node.Field != null?resolver(node.Field) : null;
if (result == null)
{
var groupNode = node as GroupNode;
if (groupNode != null)
{
node.SetAliasResolver(_useNestedResolvers ? GetScopedResolver(resolver, node.Field) : resolver);
}
return;
}
node.SetOriginalField(node.Field);
node.Field = result.Name;
if (node is GroupNode)
{
node.SetAliasResolver(_useNestedResolvers ? result.Resolver : resolver);
}
}
private void AddField(QueryValidationInfo validationInfo, IFieldQueryNode node, IQueryVisitorContext context)
{
if (!String.IsNullOrEmpty(node.Field))
{
if (!node.Field.StartsWith("@"))
{
validationInfo.ReferencedFields.Add(node.Field);
}
}
else
{
var fields = node.GetDefaultFields(context.DefaultFields);
if (fields == null || fields.Length == 0)
{
validationInfo.ReferencedFields.Add("");
}
else
{
foreach (string defaultField in fields)
{
validationInfo.ReferencedFields.Add(defaultField);
}
}
}
}
public static bool IsNodeOrGroupedParentNegated(this IFieldQueryNode node)
{
if (!String.IsNullOrEmpty(node.Prefix))
{
return(node.IsNodeNegated());
}
IQueryNode current = node;
do
{
var groupNode = current as GroupNode;
if (groupNode != null && !groupNode.HasParens)
{
current = current.Parent;
continue;
}
var fieldQueryNode = current as IFieldQueryNode;
if (fieldQueryNode != null &&
((fieldQueryNode.IsNegated.HasValue && fieldQueryNode.IsNegated.Value == true) ||
(!String.IsNullOrEmpty(fieldQueryNode.Prefix) && fieldQueryNode.Prefix == "-")))
{
return(true);
}
current = current.Parent;
} while (current.Parent != null);
return(false);
}
private void ResolveField(IFieldQueryNode node, IQueryVisitorContext context)
{
if (node.Parent == null || node.Field == null)
{
return;
}
var contextResolver = context.GetFieldResolver();
string resolvedField = node.Field;
if (_globalResolver != null)
{
resolvedField = _globalResolver(resolvedField) ?? resolvedField;
}
if (contextResolver != null)
{
resolvedField = contextResolver(resolvedField) ?? resolvedField;
}
if (resolvedField != null && !resolvedField.Equals(node.Field, StringComparison.OrdinalIgnoreCase))
{
node.SetOriginalField(node.Field);
node.Field = resolvedField;
}
}
public static string GetOriginalField(this IFieldQueryNode node)
{
if (!node.Data.TryGetValue(OriginalFieldKey, out var value))
{
return(node.Field);
}
return(value as string);
}
public static bool IsNodeOrGroupNegated(this IFieldQueryNode node)
{
if (node.IsRequired())
{
return(false);
}
return(node.IsExcluded() || node.GetGroupNode().IsExcluded());
}
public static bool IsRequired(this IFieldQueryNode node)
{
if (node == null)
{
return(false);
}
return(!String.IsNullOrEmpty(node.Prefix) && node.Prefix == "+");
}
private void AddField(IFieldQueryNode node)
{
string field = String.Equals(node.GetQueryType(), QueryType.Query) ? node.GetFullName() : node.Field;
if (!field.StartsWith("@"))
{
_fields.Add(field);
}
}
public static bool IsExcluded(this IFieldQueryNode node)
{
if (node == null)
{
return(false);
}
return((node.IsNegated.HasValue && node.IsNegated.Value == true) || (!String.IsNullOrEmpty(node.Prefix) && node.Prefix == "-"));
}
public static string GetTimeZone(this IFieldQueryNode node, string defaultTimeZone = null)
{
if (!node.Data.TryGetValue(TimeZoneKey, out var value))
{
return(defaultTimeZone);
}
return(value as string);
}
public static string GetFullName(this IFieldQueryNode node)
{
var parts = node.GetNameParts();
if (parts.Length == 0)
{
return(null);
}
return(String.Join(".", parts));
}
public static IFieldQueryNode[] GetFieldNodes(this IFieldQueryNode node)
{
var nodes = new List <IFieldQueryNode>();
var current = node;
while (current != null)
{
nodes.Add(current);
current = current.Parent as IFieldQueryNode;
}
nodes.Reverse();
return(nodes.ToArray());
}
public static IQueryNode GetScopedNode(this IFieldQueryNode node)
{
IQueryNode current = node;
do
{
var groupNode = current as GroupNode;
if (groupNode != null && groupNode.HasParens)
{
return(groupNode);
}
current = current.Parent;
} while (current.Parent != null);
return(current);
}
public static string[] GetNameParts(this IFieldQueryNode node)
{
var nameParts = new List <string>();
var current = node;
while (current != null)
{
string field = current.Field;
if (field != null)
{
nameParts.AddRange(field.Split('.').Reverse());
}
current = current.Parent as IFieldQueryNode;
}
nameParts.Reverse();
return(nameParts.ToArray());
}
private void AddField(IFieldQueryNode node, IQueryVisitorContext context)
{
string field = node.Field;
if (field != null)
{
_fields.Add(field);
}
else
{
var fields = node.GetDefaultFields(context.DefaultFields);
if (fields == null || fields.Length == 0)
{
_fields.Add("");
}
else
{
foreach (string defaultField in fields)
{
_fields.Add(defaultField);
}
}
}
}
public static string GetDefaultField(this IFieldQueryNode node, string defaultField)
{
string field = node.Field;
if (!String.IsNullOrEmpty(field))
{
return(field);
}
IQueryNode current = node;
while (current != null)
{
var groupNode = node as GroupNode;
if (groupNode != null && groupNode.HasParens && !String.IsNullOrEmpty(groupNode.Field))
{
return(groupNode.Field);
}
current = current.Parent;
}
return(defaultField);
}
public static void SetTimeZone(this IFieldQueryNode node, string timeZone)
{
node.Data[TimeZoneKey] = timeZone;
}
private IFieldQueryNode ApplyFilter(IFieldQueryNode node, IQueryVisitorContext context)
{
var parent = node.Parent as GroupNode;
if (QueryMode == EventStackFilterQueryMode.Stacks || QueryMode == EventStackFilterQueryMode.InvertedStacks)
{
// if we don't have a field name and it's a group node, leave it alone
if (node.Field == null && node is GroupNode)
{
return(node);
}
// if we have a field name and it's in the stack fields list, leave it alone
if (node.Field != null && _stackFields.Contains(node.Field))
{
if (_stackOnlyFields.Contains(node.Field))
{
HasStackSpecificCriteria = true;
}
return(node);
}
// check for special field names
if (node is TermNode termNode)
{
switch (node.Field?.ToLowerInvariant())
{
case EventIndex.Alias.StackId:
case "stack_id":
HasStackSpecificCriteria = true;
termNode.Field = "id";
return(node);
case "is_fixed":
case StackIndex.Alias.IsFixed:
HasStackSpecificCriteria = true;
bool isFixed = Boolean.TryParse(termNode.Term, out bool temp) && temp;
termNode.Field = "status";
termNode.Term = "fixed";
termNode.IsNegated = !isFixed;
return(node);
case "is_regressed":
case StackIndex.Alias.IsRegressed:
HasStackSpecificCriteria = true;
bool isRegressed = Boolean.TryParse(termNode.Term, out bool regressed) && regressed;
termNode.Field = "status";
termNode.Term = "regressed";
termNode.IsNegated = !isRegressed;
return(node);
case "is_hidden":
case StackIndex.Alias.IsHidden:
if (parent == null)
{
break;
}
HasStackSpecificCriteria = true;
bool isHidden = Boolean.TryParse(termNode.Term, out bool hidden) && hidden;
if (isHidden)
{
var isHiddenNode = new GroupNode {
HasParens = true,
IsNegated = true,
Operator = GroupOperator.And,
Left = new TermNode {
Field = "status", Term = "open"
},
Right = new TermNode {
Field = "status", Term = "regressed"
}
};
if (parent.Left == node)
{
parent.Left = isHiddenNode;
}
else if (parent.Right == node)
{
parent.Right = isHiddenNode;
}
return(isHiddenNode);
}
else
{
var notHiddenNode = new GroupNode {
HasParens = true,
Operator = GroupOperator.Or,
Left = new TermNode {
Field = "status", Term = "open"
},
Right = new TermNode {
Field = "status", Term = "regressed"
}
};
if (parent.Left == node)
{
parent.Left = notHiddenNode;
}
else if (parent.Right == node)
{
parent.Right = notHiddenNode;
}
return(notHiddenNode);
}
}
}
if (parent == null)
{
return(node);
}
if (parent.Left == node)
{
parent.Left = null;
}
else if (parent.Right == node)
{
parent.Right = null;
}
}
else
{
// don't remove terms without fields
if (String.IsNullOrEmpty(node.Field))
{
return(node);
}
if (_stackOnlyFields.Contains(node.Field) || _stackOnlySpecialFields.Contains(node.Field))
{
// remove criteria that is only for stacks
if (parent == null)
{
return(node);
}
if (parent.Left == node)
{
parent.Left = null;
}
else if (parent.Right == node)
{
parent.Right = null;
}
}
}
return(node);
}
public static string GetParentFullName(this IFieldQueryNode node)
{
var nameParts = node.GetNameParts();
return(String.Join(".", nameParts.Take(nameParts.Length - 1)));
}
public static void SetOriginalField(this IFieldQueryNode node, string field)
{
node.Data[OriginalFieldKey] = field;
}
