/// <summary>
/// Create a new UnaryOperatorQueryToken given the operator and operand
/// </summary>
/// <param name="operatorKind">The operator represented by this node.</param>
/// <param name="operand">The operand.</param>
public UnaryOperatorQueryToken(UnaryOperatorKind operatorKind, QueryToken operand)
{
ExceptionUtils.CheckArgumentNotNull(operand, "operand");
this.operatorKind = operatorKind;
this.operand = operand;
}
private static string ToString(QueryToken t)
{
if (t.Parts.Length == 1) { return t.Parts[0]; }
string str = "\"";
foreach (string part in t.Parts) { str += part + " "; }
return str.TrimEnd(' ') + "\"";
}
/// <summary>
/// Create a new OrderByQueryToken given the expression and direction
/// </summary>
/// <param name="expression">The expression according to which to order the results.</param>
/// <param name="direction">The direction of the ordering.</param>
public OrderByQueryToken(QueryToken expression, OrderByDirection direction)
{
ExceptionUtils.CheckArgumentNotNull(expression, "expression");
this.expression = expression;
this.direction = direction;
}
/// <summary>
/// Binds the given filter token.
/// </summary>
/// <param name="filter">The filter token to bind.</param>
/// <returns>A FilterNode with the given path linked to it (if provided).</returns>
internal FilterClause BindFilter(QueryToken filter)
{
ExceptionUtils.CheckArgumentNotNull(filter, "filter");
QueryNode expressionNode = this.bindMethod(filter);
SingleValueNode expressionResultNode = expressionNode as SingleValueNode;
if (expressionResultNode == null ||
(expressionResultNode.TypeReference != null && !expressionResultNode.TypeReference.IsODataPrimitiveTypeKind()))
{
throw new ODataException(ODataErrorStrings.MetadataBinder_FilterExpressionNotSingleValue);
}
// The type may be null here if the query statically represents the null literal or an open property.
IEdmTypeReference expressionResultType = expressionResultNode.TypeReference;
if (expressionResultType != null)
{
IEdmPrimitiveTypeReference primitiveExpressionResultType = expressionResultType.AsPrimitiveOrNull();
if (primitiveExpressionResultType == null ||
primitiveExpressionResultType.PrimitiveKind() != EdmPrimitiveTypeKind.Boolean)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_FilterExpressionNotSingleValue);
}
}
FilterClause filterNode = new FilterClause(expressionResultNode, this.state.ImplicitRangeVariable);
return filterNode;
}
/// <summary>
/// Create a PropertyAccessQueryToken given the name and the parent (if any)
/// </summary>
/// <param name="name">The name of the property to access.</param>
/// <param name="parent">The parent token to access the property on. Pass no if this property has no parent.</param>
public PropertyAccessQueryToken(string name, QueryToken parent)
{
ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name");
this.name = name;
this.parent = parent;
}
internal CountToken(QueryToken parent)
: base(parent)
{
if (parent == null)
throw new ArgumentNullException("parent");
}
private List<QueryToken> QueryTokenBuilder_SubTokensEvent(QueryToken arg)
{
if (SubTokensEvent == null)
throw new InvalidOperationException("SubTokensEvent not set");
return SubTokensEvent(arg);
}
private void UpdateTokenList(QueryToken queryToken)
{
if (queryToken == null)
tokens = new List<QueryToken>();
else
tokens = queryToken.Follow(a => a.Parent).Reverse().ToList();
UpdateCombo();
}
internal BagPropertyToken(QueryToken parent, PropertyInfo pi)
: base(parent)
{
if (pi == null)
throw new ArgumentNullException("pi");
this.PropertyInfo = pi;
}
internal HasValueToken(QueryToken parent)
: base(parent)
{
if (parent == null)
throw new ArgumentNullException("parent");
this.Priority = -1;
}
private List<QueryToken> QueryTokenBuilderOrders_SubTokensEvent(QueryToken token)
{
var cr = (UserChartEntity)DataContext;
if (cr == null || QueryDescription == null)
return new List<QueryToken>();
return token.SubTokens(QueryDescription, SubTokensOptions.CanElement | (cr.GroupResults ? SubTokensOptions.CanAggregate : 0));
}
internal CollectionElementToken(QueryToken parent, CollectionElementType type)
: base(parent)
{
elementType = parent.Type.ElementType();
if (elementType == null)
throw new InvalidOperationException("not a collection");
this.CollectionElementType = type;
}
internal EntityPropertyToken(QueryToken parent, PropertyInfo pi, PropertyRoute pr)
: base(parent)
{
if (pi == null)
throw new ArgumentNullException("pi");
this.PropertyInfo = pi;
this.PropertyRoute = pr;
}
/// <summary>
/// Create a new SegmentQueryToken given the name and parent and namedValues if any
/// </summary>
/// <param name="name">The name of the segment, the identifier.</param>
/// <param name="parent">The parent segment, or null if this is the root segment.</param>
/// <param name="namedValues">The named values in the key lookup for this segment.</param>
public NavigationPropertyToken(string name, QueryToken parent, IEnumerable<NamedValue> namedValues)
{
// We allow an "empty" name segment so we can create one for the case of a service-document URL (which has no path)
ExceptionUtils.CheckArgumentNotNull(name, "name");
this.name = name;
this.parent = parent;
this.namedValues = namedValues == null ? null : new ReadOnlyEnumerable<NamedValue>(namedValues);
}
/// <summary>
/// Create a new BinaryOperatorQueryToken given the operator, left and right query.
/// </summary>
/// <param name="operatorKind">The operator represented by this node.</param>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
public BinaryOperatorQueryToken(BinaryOperatorKind operatorKind, QueryToken left, QueryToken right)
{
ExceptionUtils.CheckArgumentNotNull(left, "left");
ExceptionUtils.CheckArgumentNotNull(right, "right");
this.operatorKind = operatorKind;
this.left = left;
this.right = right;
}
private List<QueryToken> token_SubTokensEvent(QueryToken token)
{
var ct = DataContext as ChartColumnEntity;
if (ct == null)
return new List<QueryToken>();
var desc = this.VisualParents().OfType<ChartBuilder>().First().Description;
return QueryUtils.SubTokens(token, desc, SubTokensOptions.CanElement | (ct.IsGroupKey == false ? SubTokensOptions.CanAggregate : 0));
}
static string CanAny(QueryToken token)
{
if (token == null)
return TemplateTokenMessage.NoColumnSelected.NiceToString();
if (token.HasAllOrAny())
return TemplateTokenMessage.YouCannotAddBlocksWithAllOrAny.NiceToString();
return null;
}
public AggregateToken(AggregateFunction function, QueryToken parent)
: base(parent)
{
if (function == AggregateFunction.Count)
throw new ArgumentException("function should not different than Count for this overload");
if (parent == null)
throw new ArgumentNullException("parent");
this.AggregateFunction = function;
}
/// <summary>
/// Binds the given filter token.
/// </summary>
/// <param name="search">The search token to bind.</param>
/// <returns>A SearchClause with for given Token.</returns>
internal SearchClause BindSearch(QueryToken search)
{
ExceptionUtils.CheckArgumentNotNull(search, "filter");
QueryNode expressionNode = this.bindMethod(search);
SingleValueNode expressionResultNode = expressionNode as SingleValueNode;
SearchClause searchClause = new SearchClause(expressionResultNode);
return searchClause;
}
public static bool IsChartColumnType(QueryToken token, ChartColumnType ct)
{
if (token == null)
return false;
var type = token.GetChartColumnType();
if(type == null)
return false;
return Flag(ct, type.Value);
}
internal AsTypeToken(QueryToken parent, Type type)
: base(parent)
{
if (parent == null)
throw new ArgumentNullException("parent");
if (type == null)
throw new ArgumentNullException("type");
this.entityType = type;
this.Priority = 8;
}
List<QueryToken> OnSubTokens(QueryToken token)
{
if (DesignerProperties.GetIsInDesignMode(this))
return new List<QueryToken>();
if (SubTokensEvent == null)
throw new InvalidOperationException("SubTokensEvent not set");
if (token != null && AllowSubTokens != null && !AllowSubTokens(token))
return new List<QueryToken>();
return SubTokensEvent(token);
}
static string CanIf(QueryToken token)
{
if (token == null)
return TemplateTokenMessage.NoColumnSelected.NiceToString();
if (token.Type != typeof(string) && token.Type != typeof(byte[]) && token.Type.ElementType() != null)
return TemplateTokenMessage.YouCannotAddIfBlocksOnCollectionFields.NiceToString();
if (token.HasAllOrAny())
return TemplateTokenMessage.YouCannotAddBlocksWithAllOrAny.NiceToString();
return null;
}
public static MvcHtmlString QueryTokenBuilder(this HtmlHelper helper, QueryToken queryToken, Context context, QueryTokenBuilderSettings settings)
{
HtmlStringBuilder sb = new HtmlStringBuilder();
using (sb.Surround(new HtmlTag("span").Id(context.Prefix).Class("token-builder")))
{
sb.Add(QueryTokenBuilderOptions(helper, queryToken, context, settings));
}
sb.Add(MvcHtmlString.Create("<script>" + new JsFunction(JsFunction.FinderModule, "QueryTokenBuilder.init", context.Prefix,
Navigator.ResolveWebQueryName(settings.QueryDescription.QueryName), settings.ControllerUrl, settings.RequestExtraJSonData).ToString()
+ "</script>"));
return sb.ToHtml();
}
public static void TemplatingDecorators(QueryToken qt, HtmlTag option)
{
string canIf = CanIf(qt);
if (canIf.HasText())
option.Attr("data-if", canIf);
string canForeach = CanForeach(qt);
if (canForeach.HasText())
option.Attr("data-foreach", canForeach);
string canAny = CanAny(qt);
if (canAny.HasText())
option.Attr("data-any", canAny);
}
internal NetPropertyToken(QueryToken parent, PropertyInfo pi, string displayName)
: base(parent)
{
if (parent == null)
throw new ArgumentNullException("parent");
if (pi == null)
throw new ArgumentNullException("pi");
if (displayName == null)
throw new ArgumentNullException("displayName");
this.DisplayName = displayName;
this.PropertyInfo = pi;
}
public static MvcHtmlString QueryTokenBuilderOptions(this HtmlHelper helper, QueryToken queryToken, Context context, QueryTokenBuilderSettings settings)
{
var tokenPath = queryToken.Follow(qt => qt.Parent).Reverse().NotNull().ToList();
HtmlStringBuilder sb = new HtmlStringBuilder();
for (int i = 0; i < tokenPath.Count; i++)
{
sb.AddLine(helper.QueryTokenCombo(i == 0 ? null : tokenPath[i - 1], tokenPath[i], i, context, settings));
}
sb.AddLine(helper.QueryTokenCombo(queryToken, null, tokenPath.Count, context, settings));
return sb.ToHtml();
}
static MvcHtmlString QueryTokenCombo(this HtmlHelper helper, QueryToken previous, QueryToken selected, int index, Context context, QueryTokenBuilderSettings settings)
{
if (previous != null && AllowSubTokens != null && !AllowSubTokens(previous))
return MvcHtmlString.Create("");
var queryTokens = previous.SubTokens(settings.QueryDescription, settings.CanAggregate);
if (queryTokens.IsEmpty())
return new HtmlTag("input")
.Attr("type", "hidden")
.IdName(context.Compose("ddlTokensEnd_" + index))
.Attr("disabled", "disabled")
.Attr("data-parenttoken", previous == null ? "" : previous.FullKey());
var options = new HtmlStringBuilder();
options.AddLine(new HtmlTag("option").Attr("value", "").SetInnerText("-").ToHtml());
foreach (var qt in queryTokens)
{
var option = new HtmlTag("option")
.Attr("value", previous == null ? qt.FullKey() : qt.Key)
.SetInnerText((previous == null && qt.Parent != null ? " - " : "") + qt.ToString());
if (selected != null && qt.Key == selected.Key)
option.Attr("selected", "selected");
option.Attr("title", qt.NiceTypeName);
option.Attr("style", "color:" + qt.TypeColor);
if (settings.Decorators != null)
settings.Decorators(qt, option);
options.AddLine(option.ToHtml());
}
HtmlTag dropdown = new HtmlTag("select")
.Class("form-control")
.IdName(context.Compose("ddlTokens_" + index))
.InnerHtml(options.ToHtml())
.Attr("data-parenttoken", previous == null ? "" : previous.FullKey());
if (selected != null)
{
dropdown.Attr("title", selected.NiceTypeName);
dropdown.Attr("style", "color:" + selected.TypeColor);
}
return dropdown.ToHtml();
}
static string CanForeach(QueryToken token)
{
if (token == null)
return TemplateTokenMessage.NoColumnSelected.NiceToString();
if (token.Type != typeof(string) && token.Type != typeof(byte[]) && token.Type.ElementType() != null)
return TemplateTokenMessage.YouHaveToAddTheElementTokenToUseForeachOnCollectionFields.NiceToString();
if (token.Key != "Element" || token.Parent == null || token.Parent.Type.ElementType() == null)
return TemplateTokenMessage.YouCanOnlyAddForeachBlocksWithCollectionFields.NiceToString();
if (token.HasAllOrAny())
return TemplateTokenMessage.YouCannotAddBlocksWithAllOrAny.NiceToString();
return null;
}
/// <summary>
/// Parses member access.
/// </summary>
/// <param name="instance">Instance being accessed.</param>
/// <returns>The lexical token representing the expression.</returns>
public QueryToken ParseMemberAccess(QueryToken instance)
{
if (this.lexer.CurrentToken.Text == UriQueryConstants.Star)
{
return this.ParseStarMemberAccess(instance);
}
string identifier = this.lexer.CurrentToken.GetIdentifier();
if (instance == null && this.parameters.Contains(identifier))
{
this.lexer.NextToken();
return new RangeVariableToken(identifier);
}
this.lexer.NextToken();
return new EndPathToken(identifier, instance);
}
/// <summary>
/// Create a AnyQueryToken given the expression, parameter, and parent
/// </summary>
/// <param name="expression">The associated expression.</param>
/// <param name="parameter">The parameter denoting source type.</param>
/// <param name="parent">The parent token. Pass null if this property has no parent.</param>
public AnyQueryToken(QueryToken expression, string parameter, QueryToken parent)
{
this.expression = expression;
this.parameter = parameter;
this.parent = parent;
}
public OrQuerySyntax(QuerySyntax left, QueryToken operatorToken, QuerySyntax right)
{
Left = left;
OperatorToken = operatorToken;
Right = right;
}
internal ModuloToken(QueryToken parent, int divisor)
{
this.parent = parent ?? throw new ArgumentNullException(nameof(parent));
this.Divisor = divisor;
}
private SingleValueNode BindMethodThatReturnsSingleValueExtensionQueryNode(QueryToken queryToken)
{
return(this.extensionSingleValueQueryNode);
}
static UserAssetTokenAction?SelectInteractive(ref QueryToken token, QueryDescription qd, SubTokensOptions options, string?remainingText, bool allowRemoveToken, bool allowReGenerate)
{
var top = Console.CursorTop;
try
{
if (Console.Out == null)
{
throw new InvalidOperationException("Unable to ask for renames to synchronize query tokens without interactive Console. Please use your Terminal application.");
}
var subTokens = token.SubTokens(qd, options).OrderBy(a => a.Parent != null).ThenByDescending(a => a.Priority).ThenBy(a => a.Key).ToList();
int startingIndex = 0;
SafeConsole.WriteColor(ConsoleColor.Cyan, " " + token?.FullKey());
if (remainingText.HasText())
{
Console.Write(" " + remainingText);
}
Console.WriteLine();
bool isRoot = token == null;
retry:
int maxElements = Console.LargestWindowHeight - 11;
subTokens.Skip(startingIndex).Take(maxElements)
.Select((s, i) => "- {1,2}: {2} ".FormatWith(i + " ", i + startingIndex, ((isRoot && s.Parent != null) ? "-" : "") + s.Key)).ToConsole();
Console.WriteLine();
int remaining = subTokens.Count - startingIndex - maxElements;
if (remaining > 0)
{
SafeConsole.WriteLineColor(ConsoleColor.White, "- +: Show more values ({0} remaining)", remaining);
}
if (token != null)
{
SafeConsole.WriteLineColor(ConsoleColor.White, "- b: Back");
SafeConsole.WriteLineColor(ConsoleColor.Green, "- c: Confirm");
}
SafeConsole.WriteLineColor(ConsoleColor.Yellow, "- s: Skip entity");
if (allowRemoveToken)
{
SafeConsole.WriteLineColor(ConsoleColor.DarkRed, "- r: Remove token");
}
if (allowReGenerate)
{
SafeConsole.WriteLineColor(ConsoleColor.Magenta, "- g: Generate from default template");
}
SafeConsole.WriteLineColor(ConsoleColor.Red, "- d: Delete entity");
while (true)
{
string answer = Console.ReadLine() !;
if (answer == null)
{
throw new InvalidOperationException("Impossible to synchronize interactively without Console");
}
answer = answer.ToLower();
if (answer == "+" && remaining > 0)
{
startingIndex += maxElements;
goto retry;
}
if (answer == "s")
{
return(UserAssetTokenAction.SkipEntity);
}
if (answer == "r" && allowRemoveToken)
{
return(UserAssetTokenAction.RemoveToken);
}
if (answer == "d")
{
return(UserAssetTokenAction.DeleteEntity);
}
if (answer == "g")
{
return(UserAssetTokenAction.ReGenerateEntity);
}
if (token != null)
{
if (answer == "c")
{
return(UserAssetTokenAction.Confirm);
}
if (answer == "b")
{
token = token.Parent !;
return(null);
}
}
if (int.TryParse(answer, out int option))
{
token = subTokens[option];
return(null);
}
Console.WriteLine("Error");
}
}
finally
{
Clean(top, Console.CursorTop);
}
}
protected internal virtual ExtensionToken CreateToken(QueryToken parent)
{
var info = metas.GetOrAdd(parent, qt =>
{
Expression e = MetadataVisitor.JustVisit(Lambda, MetaExpression.FromToken(qt, SourceType));
MetaExpression me;
if (this.IsProjection)
{
var mpe = e as MetaProjectorExpression;
if (mpe == null)
{
mpe = MetadataVisitor.AsProjection(e);
}
me = mpe == null ? null : mpe.Projector as MetaExpression;
}
else
{
me = e as MetaExpression;
}
CleanMeta cm = me == null ? null : me.Meta as CleanMeta;
var result = new ExtensionRouteInfo();
if (cm != null && cm.PropertyRoutes.Any())
{
var cleanType = me.Type.CleanType();
result.PropertyRoute = cm.PropertyRoutes.Only();
result.Implementations = me.Meta.Implementations;
result.Format = ColumnDescriptionFactory.GetFormat(cm.PropertyRoutes);
result.Unit = ColumnDescriptionFactory.GetUnit(cm.PropertyRoutes);
}
result.IsAllowed = () => (me == null || me.Meta == null) ? null : me.Meta.IsAllowed();
if (ForcePropertyRoute != null)
{
result.PropertyRoute = ForcePropertyRoute;
}
if (ForceImplementations != null)
{
result.Implementations = ForceImplementations;
}
if (ForceFormat != null)
{
result.Format = ForceFormat;
}
if (ForceUnit != null)
{
result.Unit = ForceUnit;
}
if (ForceIsAllowed != null)
{
result.IsAllowed = ForceIsAllowed;
}
return(result);
});
return(new ExtensionToken(parent, Key, Type, IsProjection, info.Unit, info.Format, info.Implementations, info.IsAllowed(), info.PropertyRoute)
{
DisplayName = NiceName()
});
}
public static Control GetValueControl(QueryToken token, string bindingPath)
{
Type type = token.Type;
if (type.IsLite())
{
Implementations implementations = token.GetImplementations().Value;
Type cleanType = Lite.Extract(type);
if (EntityKindCache.IsLowPopulation(cleanType) && !implementations.IsByAll)
{
EntityCombo ec = new EntityCombo
{
Type = type,
Implementations = implementations,
};
ec.SetBinding(EntityCombo.EntityProperty, new Binding
{
Path = new PropertyPath(bindingPath),
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true,
});
return(ec);
}
else
{
EntityLine el = new EntityLine
{
Type = type,
Create = false,
Implementations = implementations,
};
el.SetBinding(EntityLine.EntityProperty, new Binding
{
Path = new PropertyPath(bindingPath),
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true
});
return(el);
}
}
else if (type.IsEmbeddedEntity())
{
EntityLine el = new EntityLine
{
Type = type,
Create = false,
Autocomplete = false,
Find = false,
Implementations = null,
};
el.SetBinding(EntityLine.EntityProperty, new Binding
{
Path = new PropertyPath(bindingPath),
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true
});
return(el);
}
else
{
ValueLine vl = new ValueLine()
{
Type = type,
Format = token.Format,
UnitText = token.Unit,
};
if (type.UnNullify().IsEnum)
{
vl.ItemSource = EnumEntity.GetValues(type.UnNullify()).PreAndNull(type.IsNullable()).ToObservableCollection();
}
vl.SetBinding(ValueLine.ValueProperty, new Binding
{
Path = new PropertyPath(bindingPath), //odd
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true,
Converter = Reflector.IsNumber(type) ? Converters.Identity : null,
});
return(vl);
}
}
internal NetPropertyToken(QueryToken parent, Expression <Func <object> > pi, Func <string> displayName) :
this(parent, ReflectionTools.GetPropertyInfo(pi), displayName)
{
}
public Expression <Func <object, V> > GetLambdaExpression <V>(QueryToken token)
{
return(Expression.Lambda <Func <object, V> >(Expression.Convert(token.BuildExpression(Context), typeof(V)), Context.Parameter));
}
/// <summary>
/// Create a new FunctionCallToken using the given function name and parameter tokens.
/// </summary>
/// <param name="name">The name of the function to call.</param>
/// <param name="arguments">The arguments for the function.</param>
/// <param name="source">The syntactically bound parent of this function</param>
public FunctionCallToken(string name, IEnumerable<FunctionParameterToken> arguments, QueryToken source)
{
ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name");
this.name = name;
this.arguments = new ReadOnlyEnumerableForUriParser<FunctionParameterToken>(arguments ?? FunctionParameterToken.EmptyParameterList);
this.source = source;
}
void ParseInternal()
{
try
{
this.mainBlock = new BlockNode(null);
this.stack = new Stack <BlockNode>();
this.errors = new List <TemplateError>();
PushBlock(mainBlock);
var matches = TemplateUtils.KeywordsRegex.Matches(text);
if (matches.Count == 0)
{
stack.Peek().Nodes.Add(new LiteralNode(text));
stack.Pop();
return;
}
int index = 0;
foreach (Match match in matches.Cast <Match>())
{
if (index < match.Index)
{
stack.Peek().Nodes.Add(new LiteralNode(text.Substring(index, match.Index - index)));
}
var expr = match.Groups["expr"].Value;
var keyword = match.Groups["keyword"].Value;
var variable = match.Groups["dec"].Value;
switch (keyword)
{
case "":
case "raw":
var s = TemplateUtils.SplitToken(expr);
if (s == null)
{
AddError(true, "{0} has invalid format".FormatWith(expr));
}
else
{
var t = ValueProviderBase.TryParse(s.Value.Token, variable, this);
stack.Peek().Nodes.Add(new ValueNode(t, s.Value.Format, isRaw: keyword.Contains("raw")));
DeclareVariable(t);
}
break;
case "declare":
{
var t = ValueProviderBase.TryParse(expr, variable, this);
stack.Peek().Nodes.Add(new DeclareNode(t, this.AddError));
DeclareVariable(t);
}
break;
case "any":
{
ConditionBase cond = TemplateUtils.ParseCondition(expr, variable, this);
AnyNode any = new AnyNode(cond);
stack.Peek().Nodes.Add(any);
PushBlock(any.AnyBlock);
if (cond is ConditionCompare cc)
{
DeclareVariable(cc.ValueProvider);
}
break;
}
case "notany":
{
var an = (AnyNode?)PopBlock(typeof(AnyNode))?.owner;
if (an != null)
{
PushBlock(an.CreateNotAny());
}
break;
}
case "endany":
{
PopBlock(typeof(AnyNode));
break;
}
case "foreach":
{
ValueProviderBase?vp = ValueProviderBase.TryParse(expr, variable, this);
if (vp is TokenValueProvider tvp && tvp.ParsedToken.QueryToken != null && QueryToken.IsCollection(tvp.ParsedToken.QueryToken.Type))
{
AddError(false, $"@foreach[{expr}] is a collection, missing 'Element' token at the end");
}
var fn = new ForeachNode(vp);
stack.Peek().Nodes.Add(fn);
PushBlock(fn.Block);
if (vp != null)
{
vp.IsForeach = true;
}
DeclareVariable(vp);
break;
}
case "endforeach":
{
PopBlock(typeof(ForeachNode));
}
break;
case "if":
{
ConditionBase cond = TemplateUtils.ParseCondition(expr, variable, this);
IfNode ifn = new IfNode(cond, this);
stack.Peek().Nodes.Add(ifn);
PushBlock(ifn.IfBlock);
if (cond is ConditionCompare cc)
{
DeclareVariable(cc.ValueProvider);
}
break;
}
case "else":
{
var ifn = (IfNode?)PopBlock(typeof(IfNode))?.owner;
if (ifn != null)
{
PushBlock(ifn.CreateElse());
}
break;
}
case "endif":
{
PopBlock(typeof(IfNode));
break;
}
default:
AddError(true, "'{0}' is deprecated".FormatWith(keyword));
break;
}
index = match.Index + match.Length;
}
if (stack.Count != 1)
{
AddError(true, "Last block is not closed: {0}".FormatWith(stack.Peek()));
}
var lastM = matches.Cast <Match>().LastOrDefault();
if (lastM != null && lastM.Index + lastM.Length < text.Length)
{
stack.Peek().Nodes.Add(new LiteralNode(text.Substring(lastM.Index + lastM.Length)));
}
stack.Pop();
}
catch (Exception e)
{
AddError(true, e.Message);
}
}
/// <summary>
/// Create a new BinaryOperatorQueryToken given the operator, left and right query.
/// </summary>
/// <param name="operatorKind">The operator represented by this node.</param>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
public BinaryOperatorQueryToken(BinaryOperatorKind operatorKind, QueryToken left, QueryToken right)
{
ExceptionUtils.CheckArgumentNotNull(left, "left");
ExceptionUtils.CheckArgumentNotNull(right, "right");
this.operatorKind = operatorKind;
this.left = left;
this.right = right;
}
/// <summary>
/// Helper bind method that returns null. Parameter is unused.
/// </summary>
private QueryNode BindMethodReturnsNull(QueryToken token)
{
return(null);
}
/// <summary>
/// Create an expand term token
/// </summary>
/// <param name="pathToNavigationProp">the nav prop for this expand term</param>
/// <param name="filterOption">the filter option for this expand term</param>
/// <param name="orderByOptions">the orderby options for this expand term</param>
/// <param name="topOption">the top option for this expand term</param>
/// <param name="skipOption">the skip option for this expand term</param>
/// <param name="countQueryOption">the query count option for this expand term</param>
/// <param name="levelsOption">the levels option for this expand term</param>
/// <param name="searchOption">the search option for this expand term</param>
/// <param name="selectOption">the select option for this expand term</param>
/// <param name="expandOption">the expand option for this expand term</param>
public ExpandTermToken(PathSegmentToken pathToNavigationProp, QueryToken filterOption, IEnumerable <OrderByToken> orderByOptions, long?topOption, long?skipOption, bool?countQueryOption, long?levelsOption, QueryToken searchOption, SelectToken selectOption, ExpandToken expandOption)
: this(pathToNavigationProp, filterOption, orderByOptions, topOption, skipOption, countQueryOption, levelsOption, searchOption, selectOption, expandOption, null)
{
}
public UnaryOperatorToken(UnaryOperatorCategory operatorCategory, QueryToken operand)
{
OperatorCategory = operatorCategory;
Operand = operand;
}
/// <summary>
/// Create an expand term token
/// </summary>
/// <param name="pathToNavigationProp">the nav prop for this expand term</param>
/// <param name="filterOption">the filter option for this expand term</param>
/// <param name="orderByOptions">the orderby options for this expand term</param>
/// <param name="topOption">the top option for this expand term</param>
/// <param name="skipOption">the skip option for this expand term</param>
/// <param name="countQueryOption">the query count option for this expand term</param>
/// <param name="levelsOption">the levels option for this expand term</param>
/// <param name="searchOption">the search option for this expand term</param>
/// <param name="selectOption">the select option for this expand term</param>
/// <param name="expandOption">the expand option for this expand term</param>
public ExpandTermToken(PathSegmentToken pathToNavigationProp, QueryToken filterOption, IEnumerable <OrderByToken> orderByOptions, long?topOption, long?skipOption, bool?countQueryOption, long?levelsOption, QueryToken searchOption, SelectToken selectOption, ExpandToken expandOption)
{
ExceptionUtils.CheckArgumentNotNull(pathToNavigationProp, "property");
this.pathToNavigationProp = pathToNavigationProp;
this.filterOption = filterOption;
this.orderByOptions = orderByOptions;
this.topOption = topOption;
this.skipOption = skipOption;
this.countQueryOption = countQueryOption;
this.levelsOption = levelsOption;
this.searchOption = searchOption;
this.selectOption = selectOption;
this.expandOption = expandOption;
}
public override void RenderLines(DynamicQueryOmniboxResult result, InlineCollection lines)
{
lines.AddMatch(result.QueryNameMatch);
foreach (var item in result.Filters)
{
lines.Add(" ");
QueryToken last = null;
if (item.QueryTokenMatches != null)
{
foreach (var tokenMatch in item.QueryTokenMatches)
{
if (last != null)
{
lines.Add(".");
}
lines.AddMatch(tokenMatch);
last = (QueryToken)tokenMatch.Value;
}
}
if (item.QueryToken != last)
{
if (last != null)
{
lines.Add(".");
}
lines.Add(new Run(item.QueryToken.Key)
{
Foreground = Brushes.Gray
});
}
if (item.CanFilter.HasText())
{
lines.Add(new Run(item.CanFilter)
{
Foreground = Brushes.Red
});
}
else if (item.Operation != null)
{
lines.Add(new Bold(new Run(FilterValueConverter.ToStringOperation(item.Operation.Value))));
if ((item.Value as string) == DynamicQueryOmniboxResultGenerator.UnknownValue)
{
lines.Add(new Run(OmniboxMessage.Unknown.NiceToString())
{
Foreground = Brushes.Red
});
}
else if (item.ValueMatch != null)
{
lines.AddMatch(item.ValueMatch);
}
else if (item.Syntax != null && item.Syntax.Completion == FilterSyntaxCompletion.Complete)
{
lines.Add(new Bold(new Run(DynamicQueryOmniboxResultGenerator.ToStringValue(item.Value))));
}
else
{
lines.Add(new Run(DynamicQueryOmniboxResultGenerator.ToStringValue(item.Value))
{
Foreground = Brushes.Gray
});
}
}
}
}
private static SingleValueNode BindMethodReturnsBooleanPrimitive(QueryToken token)
{
return(_booleanPrimitiveNode);
}
internal static SubscriptionCreationOptions CreateSubscriptionOptionsFromGeneric <T>(
DocumentConventions conventions,
SubscriptionCreationOptions criteria,
Expression <Func <T, bool> > predicate,
Expression <Func <T, object> > project,
Action <ISubscriptionIncludeBuilder <T> > includes)
{
criteria ??= new SubscriptionCreationOptions();
var collectionName = conventions.GetCollectionName(typeof(T));
if (criteria.Query == null)
{
var tType = typeof(T);
var includeRevisions = tType.IsConstructedGenericType && tType.GetGenericTypeDefinition() == typeof(Revision <>);
if (includeRevisions)
{
collectionName = conventions.GetCollectionName(tType.GenericTypeArguments[0]);
}
var builder = new StringBuilder("from '");
StringExtensions.EscapeString(builder, collectionName);
builder.Append('\'');
if (includeRevisions)
{
builder.Append(" (Revisions = true)");
}
criteria.Query = builder.Append(" as doc").ToString();
}
if (predicate != null)
{
var script = predicate.CompileToJavascript(
new JavascriptCompilationOptions(
JsCompilationFlags.BodyOnly,
JavascriptConversionExtensions.MathSupport.Instance,
new JavascriptConversionExtensions.DictionarySupport(),
JavascriptConversionExtensions.LinqMethodsSupport.Instance,
new JavascriptConversionExtensions.SubscriptionsWrappedConstantSupport(conventions),
new JavascriptConversionExtensions.ConstSupport(conventions),
new JavascriptConversionExtensions.ReplaceParameterWithNewName(predicate.Parameters[0], "this"),
JavascriptConversionExtensions.ToStringSupport.Instance,
JavascriptConversionExtensions.DateTimeSupport.Instance,
JavascriptConversionExtensions.TimeSpanSupport.Instance,
JavascriptConversionExtensions.InvokeSupport.Instance,
JavascriptConversionExtensions.NullCoalescingSupport.Instance,
JavascriptConversionExtensions.NestedConditionalSupport.Instance,
JavascriptConversionExtensions.StringSupport.Instance
));
criteria.Query = $"declare function predicate() {{ return {script} }}{Environment.NewLine}" +
$"{criteria.Query}{Environment.NewLine}" +
"where predicate.call(doc)";
}
if (project != null)
{
var script = project.CompileToJavascript(
new JavascriptCompilationOptions(
JsCompilationFlags.BodyOnly,
JavascriptConversionExtensions.MathSupport.Instance,
new JavascriptConversionExtensions.DictionarySupport(),
JavascriptConversionExtensions.LinqMethodsSupport.Instance,
new JavascriptConversionExtensions.ConstSupport(conventions),
JavascriptConversionExtensions.ToStringSupport.Instance,
JavascriptConversionExtensions.DateTimeSupport.Instance,
JavascriptConversionExtensions.TimeSpanSupport.Instance,
JavascriptConversionExtensions.InvokeSupport.Instance,
JavascriptConversionExtensions.NullCoalescingSupport.Instance,
JavascriptConversionExtensions.StringSupport.Instance,
JavascriptConversionExtensions.NestedConditionalSupport.Instance,
new JavascriptConversionExtensions.ReplaceParameterWithNewName(project.Parameters[0], "doc"),
new JavascriptConversionExtensions.IdentityPropertySupport(conventions),
JavascriptConversionExtensions.CounterSupport.Instance,
JavascriptConversionExtensions.CompareExchangeSupport.Instance,
new JavascriptConversionExtensions.LoadSupport(),
JavascriptConversionExtensions.MemberInit.Instance
));
criteria.Query += Environment.NewLine + "select " + script;
}
if (includes != null)
{
var builder = new IncludeBuilder <T>(conventions);
includes(builder);
if (builder.DocumentsToInclude != null && builder.DocumentsToInclude.Count > 0)
{
criteria.Query += Environment.NewLine + "include ";
var first = true;
foreach (var inc in builder.DocumentsToInclude)
{
var include = "doc." + inc;
if (first == false)
{
criteria.Query += ",";
}
first = false;
if (IncludesUtil.RequiresQuotes(include, out var escapedInclude))
{
criteria.Query += $"'{escapedInclude}'";
}
else
{
criteria.Query += QueryToken.IsKeyword(include) ? $"'{include}'" : include;
}
}
}
}
return(criteria);
}
internal CountToken(QueryToken parent)
{
this.parent = parent ?? throw new ArgumentNullException(nameof(parent));
}
private CollectionNode BindMethodThatReturnsCollectionQueryNode(QueryToken queryToken)
{
return(null);
}
/// <summary>
/// Create a AnyAllQueryToken given the expression, parameter, and parent
/// </summary>
/// <param name="expression">The associated expression.</param>
/// <param name="parameter">The parameter denoting source type.</param>
/// <param name="parent">The parent token. Pass null if this property has no parent.</param>
protected LambdaToken(QueryToken expression, string parameter, QueryToken parent)
{
this.expression = expression;
this.parameter = parameter;
this.parent = parent;
}
/// <summary>
/// We substitute the following methods for the MetadataBinder.Bind method to keep the tests from growing too large in scope.
/// In practice this does the same thing.
/// </summary>
private SingleValueNode BindMethodThatReturnsSingleValueQueryNode(QueryToken queryToken)
{
return(this.parameterSingleValueQueryNode);
}
/// <summary>
/// Parses the <paramref name="queryUri"/> and returns a new instance of <see cref="QueryDescriptorQueryToken"/>
/// describing the query specified by the uri.
/// </summary>
/// <param name="queryUri">The absolute URI which holds the query to parse. This must be a path relative to the <paramref name="serviceBaseUri"/>.</param>
/// <param name="serviceBaseUri">The base URI of the service.</param>
/// <param name="maxDepth">The maximum depth of any single query part. Security setting to guard against DoS attacks causing stack overflows and such.</param>
/// <returns>A new instance of <see cref="QueryDescriptorQueryToken"/> which represents the query specified in the <paramref name="queryUri"/>.</returns>
public static QueryDescriptorQueryToken ParseUri(Uri queryUri, Uri serviceBaseUri, int maxDepth)
{
ExceptionUtils.CheckArgumentNotNull(queryUri, "queryUri");
if (!queryUri.IsAbsoluteUri)
{
throw new ArgumentException(Strings.QueryDescriptorQueryToken_UriMustBeAbsolute(queryUri), "queryUri");
}
ExceptionUtils.CheckArgumentNotNull(serviceBaseUri, "serviceBaseUri");
if (!serviceBaseUri.IsAbsoluteUri)
{
throw new ArgumentException(Strings.QueryDescriptorQueryToken_UriMustBeAbsolute(serviceBaseUri), "serviceBaseUri");
}
if (maxDepth <= 0)
{
throw new ArgumentException(Strings.QueryDescriptorQueryToken_MaxDepthInvalid, "maxDepth");
}
UriQueryPathParser pathParser = new UriQueryPathParser(maxDepth);
QueryToken path = pathParser.ParseUri(queryUri, serviceBaseUri);
List <QueryOptionQueryToken> queryOptions = UriUtils.ParseQueryOptions(queryUri);
QueryToken filter = null;
string filterQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.FilterQueryOption);
if (filterQuery != null)
{
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(maxDepth);
filter = expressionParser.ParseFilter(filterQuery);
}
IEnumerable <OrderByQueryToken> orderByTokens = null;
string orderByQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.OrderByQueryOption);
if (orderByQuery != null)
{
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(maxDepth);
orderByTokens = expressionParser.ParseOrderBy(orderByQuery);
}
SelectQueryToken select = null;
string selectQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.SelectQueryOption);
if (selectQuery != null)
{
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(maxDepth);
select = expressionParser.ParseSelect(selectQuery);
}
ExpandQueryToken expand = null;
string expandQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.ExpandQueryOption);
if (expandQuery != null)
{
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(maxDepth);
expand = expressionParser.ParseExpand(expandQuery);
}
int? skip = null;
string skipQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.SkipQueryOption);
if (skipQuery != null)
{
int skipValue;
if (!UriPrimitiveTypeParser.TryUriStringToNonNegativeInteger(skipQuery, out skipValue))
{
throw new ODataException(Strings.QueryDescriptorQueryToken_InvalidSkipQueryOptionValue(skipQuery));
}
skip = skipValue;
}
int? top = null;
string topQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.TopQueryOption);
if (topQuery != null)
{
int topValue;
if (!UriPrimitiveTypeParser.TryUriStringToNonNegativeInteger(topQuery, out topValue))
{
throw new ODataException(Strings.QueryDescriptorQueryToken_InvalidTopQueryOptionValue(topQuery));
}
top = topValue;
}
string inlineCountQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.InlineCountQueryOption);
InlineCountKind?inlineCount = QueryTokenUtils.ParseInlineCountKind(inlineCountQuery);
string format = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.FormatQueryOption);
return(new QueryDescriptorQueryToken(
path,
filter,
orderByTokens,
select,
expand,
skip,
top,
inlineCount,
format,
queryOptions.Count == 0 ? null : new ReadOnlyCollection <QueryOptionQueryToken>(queryOptions)));
}
/// <summary>
/// Create a AllToken given the expression, parameter, and parent
/// </summary>
/// <param name="expression">The associated expression.</param>
/// <param name="parameter">The parameter denoting source type.</param>
/// <param name="parent">The parent token. Pass null if this property has no parent.</param>
public AllToken(QueryToken expression, string parameter, QueryToken parent) : base(expression, parameter, parent)
{
}
public virtual List <QueryToken> ExternalQueryToken(QueryToken parent)
{
return(Return(MethodInfo.GetCurrentMethod(),
() => DynamicQueryManager.Current.GetExtensions(parent).ToList()));
}
/// <summary>
/// Parses the <paramref name="queryUri"/> and returns a new instance of <see cref="SyntacticTree"/>
/// describing the query specified by the uri.
/// </summary>
/// <param name="queryUri">The absolute URI which holds the query to parse. This must be a path relative to the <paramref name="serviceBaseUri"/>.</param>
/// <param name="serviceBaseUri">The base URI of the service.</param>
/// <param name="maxDepth">The maximum depth of any single query part. Security setting to guard against DoS attacks causing stack overflows and such.</param>
/// <returns>A new instance of <see cref="SyntacticTree"/> which represents the query specified in the <paramref name="queryUri"/>.</returns>
public static SyntacticTree ParseUri(Uri queryUri, Uri serviceBaseUri, int maxDepth)
{
ExceptionUtils.CheckArgumentNotNull(queryUri, "queryUri");
if (!queryUri.IsAbsoluteUri)
{
throw new ArgumentException(Strings.SyntacticTree_UriMustBeAbsolute(queryUri), "queryUri");
}
ExceptionUtils.CheckArgumentNotNull(serviceBaseUri, "serviceBaseUri");
if (!serviceBaseUri.IsAbsoluteUri)
{
throw new ArgumentException(Strings.SyntacticTree_UriMustBeAbsolute(serviceBaseUri), "serviceBaseUri");
}
if (maxDepth <= 0)
{
throw new ArgumentException(Strings.SyntacticTree_MaxDepthInvalid, "maxDepth");
}
UriPathParser pathParser = new UriPathParser(maxDepth);
var path = pathParser.ParsePathIntoSegments(queryUri, serviceBaseUri);
// COMPAT 32: Differencies in query options parsing in WCF DS
//
// We allow non-system $ query options in the lexical space.
// We allow multiple instances of a custom or non-system $ query option in the lexical space.
// TODO: we need to decide whether we want to allow multiple system $ query options with the same name (OIPI suggests that this is valid); we currently don't.
List <CustomQueryOptionToken> queryOptions = UriUtils.ParseQueryOptions(queryUri);
IDictionary <string, string> parameterAliases = queryOptions.GetParameterAliases();
QueryToken filter = null;
string filterQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.FilterQueryOption);
if (filterQuery != null)
{
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(maxDepth);
filter = expressionParser.ParseFilter(filterQuery);
}
IEnumerable <OrderByToken> orderByTokens = null;
string orderByQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.OrderByQueryOption);
if (orderByQuery != null)
{
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(maxDepth);
orderByTokens = expressionParser.ParseOrderBy(orderByQuery);
}
SelectToken select = null;
string selectQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.SelectQueryOption);
if (selectQuery != null)
{
SelectExpandParser selectParser = new SelectExpandParser(selectQuery, ODataUriParserSettings.DefaultSelectExpandLimit);
select = selectParser.ParseSelect();
}
ExpandToken expand = null;
string expandQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.ExpandQueryOption);
if (expandQuery != null)
{
SelectExpandParser expandParser = new SelectExpandParser(expandQuery, ODataUriParserSettings.DefaultSelectExpandLimit);
expand = expandParser.ParseExpand();
}
int? skip = null;
string skipQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.SkipQueryOption);
if (skipQuery != null)
{
int skipValue;
if (!UriPrimitiveTypeParser.TryUriStringToNonNegativeInteger(skipQuery, out skipValue))
{
throw new ODataException(Strings.SyntacticTree_InvalidSkipQueryOptionValue(skipQuery));
}
skip = skipValue;
}
int? top = null;
string topQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.TopQueryOption);
if (topQuery != null)
{
int topValue;
if (!UriPrimitiveTypeParser.TryUriStringToNonNegativeInteger(topQuery, out topValue))
{
throw new ODataException(Strings.SyntacticTree_InvalidTopQueryOptionValue(topQuery));
}
top = topValue;
}
string countQuery = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.CountQueryOption);
bool? count = ParseQueryCount(countQuery);
string format = queryOptions.GetQueryOptionValueAndRemove(UriQueryConstants.FormatQueryOption);
return(new SyntacticTree(
parameterAliases,
path,
filter,
orderByTokens,
select,
expand,
skip,
top,
count,
format,
queryOptions.Count == 0 ? null : new ReadOnlyCollection <CustomQueryOptionToken>(queryOptions)));
}
internal DatePartStartToken(QueryToken parent, QueryTokenMessage name)
{
this.Name = name;
this.parent = parent ?? throw new ArgumentNullException(nameof(parent));
}
internal static SubscriptionCreationOptions CreateSubscriptionOptionsFromGeneric <T>(
DocumentConventions conventions,
SubscriptionCreationOptions criteria,
Expression <Func <T, bool> > predicate,
Expression <Func <T, object> > project,
Action <ISubscriptionIncludeBuilder <T> > includes)
{
criteria ??= new SubscriptionCreationOptions();
var collectionName = conventions.GetCollectionName(typeof(T));
StringBuilder queryBuilder;
if (criteria.Query != null)
{
queryBuilder = new StringBuilder(criteria.Query);
}
else
{
queryBuilder = new StringBuilder();
var tType = typeof(T);
var includeRevisions = tType.IsConstructedGenericType && tType.GetGenericTypeDefinition() == typeof(Revision <>);
if (includeRevisions)
{
collectionName = conventions.GetCollectionName(tType.GenericTypeArguments[0]);
}
queryBuilder.Append("from '");
StringExtensions.EscapeString(queryBuilder, collectionName);
queryBuilder.Append('\'');
if (includeRevisions)
{
queryBuilder.Append(" (Revisions = true)");
}
criteria.Query = queryBuilder.Append(" as doc").ToString();
}
if (predicate != null)
{
var script = predicate.CompileToJavascript(
new JavascriptCompilationOptions(
JsCompilationFlags.BodyOnly,
JavascriptConversionExtensions.MathSupport.Instance,
new JavascriptConversionExtensions.DictionarySupport(),
JavascriptConversionExtensions.LinqMethodsSupport.Instance,
new JavascriptConversionExtensions.SubscriptionsWrappedConstantSupport(conventions),
new JavascriptConversionExtensions.ConstSupport(conventions),
new JavascriptConversionExtensions.ReplaceParameterWithNewName(predicate.Parameters[0], "this"),
JavascriptConversionExtensions.ToStringSupport.Instance,
JavascriptConversionExtensions.DateTimeSupport.Instance,
JavascriptConversionExtensions.TimeSpanSupport.Instance,
JavascriptConversionExtensions.InvokeSupport.Instance,
JavascriptConversionExtensions.NullCoalescingSupport.Instance,
JavascriptConversionExtensions.NestedConditionalSupport.Instance,
JavascriptConversionExtensions.StringSupport.Instance,
new JavascriptConversionExtensions.IdentityPropertySupport(conventions)
));
queryBuilder
.Insert(0, $"declare function predicate() {{ return {script} }}{Environment.NewLine}")
.AppendLine()
.Append("where predicate.call(doc)");
}
if (project != null)
{
var script = project.CompileToJavascript(
new JavascriptCompilationOptions(
JsCompilationFlags.BodyOnly,
JavascriptConversionExtensions.MathSupport.Instance,
new JavascriptConversionExtensions.DictionarySupport(),
JavascriptConversionExtensions.LinqMethodsSupport.Instance,
new JavascriptConversionExtensions.ConstSupport(conventions),
JavascriptConversionExtensions.ToStringSupport.Instance,
JavascriptConversionExtensions.DateTimeSupport.Instance,
JavascriptConversionExtensions.TimeSpanSupport.Instance,
JavascriptConversionExtensions.InvokeSupport.Instance,
JavascriptConversionExtensions.NullCoalescingSupport.Instance,
JavascriptConversionExtensions.StringSupport.Instance,
JavascriptConversionExtensions.NestedConditionalSupport.Instance,
new JavascriptConversionExtensions.ReplaceParameterWithNewName(project.Parameters[0], "doc"),
new JavascriptConversionExtensions.IdentityPropertySupport(conventions),
JavascriptConversionExtensions.CounterSupport.Instance,
JavascriptConversionExtensions.CompareExchangeSupport.Instance,
new JavascriptConversionExtensions.LoadSupport(),
JavascriptConversionExtensions.MemberInit.Instance
));
queryBuilder
.AppendLine()
.Append("select ")
.Append(script);
}
if (includes != null)
{
var builder = new IncludeBuilder <T>(conventions);
includes(builder);
var numberOfIncludesAdded = 0;
if (builder.DocumentsToInclude?.Count > 0)
{
queryBuilder
.AppendLine()
.Append("include ");
foreach (var inc in builder.DocumentsToInclude)
{
var include = "doc." + inc;
if (numberOfIncludesAdded > 0)
{
queryBuilder.Append(",");
}
if (IncludesUtil.RequiresQuotes(include, out var escapedInclude))
{
queryBuilder
.Append("'")
.Append(escapedInclude)
.Append("'");
}
else
{
queryBuilder.Append(QueryToken.IsKeyword(include) ? $"'{include}'" : include);
}
numberOfIncludesAdded++;
}
}
if (builder.AllCounters)
{
if (numberOfIncludesAdded == 0)
{
queryBuilder
.AppendLine()
.Append("include ");
}
var token = CounterIncludesToken.All(string.Empty);
token.WriteTo(queryBuilder);
numberOfIncludesAdded++;
}
else if (builder.CountersToInclude?.Count > 0)
{
if (numberOfIncludesAdded == 0)
{
queryBuilder
.AppendLine()
.Append("include ");
}
foreach (var counterName in builder.CountersToInclude)
{
if (numberOfIncludesAdded > 0)
{
queryBuilder.Append(",");
}
var token = CounterIncludesToken.Create(string.Empty, counterName);
token.WriteTo(queryBuilder);
numberOfIncludesAdded++;
}
}
if (builder.TimeSeriesToInclude != null)
{
foreach (var timeSeriesRange in builder.TimeSeriesToInclude)
{
if (numberOfIncludesAdded == 0)
{
queryBuilder
.AppendLine()
.Append("include ");
}
if (numberOfIncludesAdded > 0)
{
queryBuilder.Append(",");
}
var token = TimeSeriesIncludesToken.Create(string.Empty, timeSeriesRange);
token.WriteTo(queryBuilder);
numberOfIncludesAdded++;
}
}
}
criteria.Query = queryBuilder.ToString();
return(criteria);
}
/// <summary>
/// Creates a FunctionParameterToken
/// </summary>
/// <param name="parameterName">the name of this parameter</param>
/// <param name="valueToken">the syntactically parsed value</param>
public FunctionParameterToken(string parameterName, QueryToken valueToken)
{
this.parameterName = parameterName;
this.valueToken = valueToken;
}
