/// <summary>
/// Build an ODataUriParser
/// </summary>
/// <param name="model">Model to use for metadata binding.</param>
/// <param name="serviceRoot">Absolute URI of the service root.</param>
/// <param name="fullUri">full Uri to be parsed</param>
public ODataUriParser(IEdmModel model, Uri serviceRoot, Uri fullUri)
{
ExceptionUtils.CheckArgumentNotNull(fullUri, "fullUri");
if (serviceRoot == null)
{
throw new ODataException(ODataErrorStrings.UriParser_NeedServiceRootForThisOverload);
}
if (!serviceRoot.IsAbsoluteUri)
{
throw new ODataException(ODataErrorStrings.UriParser_UriMustBeAbsolute(serviceRoot));
}
this.configuration = new ODataUriParserConfiguration(model);
this.serviceRoot = Core.UriUtils.EnsureTaillingSlash(serviceRoot);
this.fullUri = fullUri.IsAbsoluteUri ? fullUri : Core.UriUtils.UriToAbsoluteUri(this.ServiceRoot, fullUri);
this.queryOptions = UriUtils.ParseQueryOptions(this.fullUri);
}
/// <summary>
/// Build an ODataUriParser
/// </summary>
/// <param name="model">Model to use for metadata binding.</param>
/// <param name="serviceRoot">Absolute URI of the service root.</param>
/// <param name="fullUri">full Uri to be parsed</param>
public ODataUriParser(IEdmModel model, Uri serviceRoot, Uri fullUri)
{
ExceptionUtils.CheckArgumentNotNull(fullUri, "fullUri");
if (serviceRoot == null)
{
throw new ODataException(ODataErrorStrings.UriParser_NeedServiceRootForThisOverload);
}
if (!serviceRoot.IsAbsoluteUri)
{
throw new ODataException(ODataErrorStrings.UriParser_UriMustBeAbsolute(serviceRoot));
}
this.configuration = new ODataUriParserConfiguration(model);
this.serviceRoot = Core.UriUtils.EnsureTaillingSlash(serviceRoot);
this.fullUri = fullUri.IsAbsoluteUri ? fullUri : Core.UriUtils.UriToAbsoluteUri(this.ServiceRoot, fullUri);
this.queryOptions = UriUtils.ParseQueryOptions(this.fullUri);
}
/// <summary>
/// Parses a <paramref name="filter"/> clause on the given <paramref name="elementType"/>, binding
/// the text into semantic nodes using the provided model.
/// </summary>
/// <param name="filter">String representation of the filter expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the filter clause refers to.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="FilterClause"/> representing the metadata bound filter expression.</returns>
private static FilterClause ParseFilterImplementation(string filter, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(filter, "filter");
// Get the syntactic representation of the filter expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.FilterLimit, configuration.EnableCaseInsensitiveBuiltinIdentifier);
QueryToken filterToken = expressionParser.ParseFilter(filter);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
MetadataBinder binder = new MetadataBinder(state);
FilterBinder filterBinder = new FilterBinder(binder.Bind, state);
FilterClause boundNode = filterBinder.BindFilter(filterToken);
return(boundNode);
}
/// <summary>
/// Parses a <paramref name="query"/> clause on the given <paramref name="elementType"/>, binding
/// the text into semantic nodes using the provided model.
/// </summary>
/// <param name="query">String representation of the filter expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the filter clause refers to.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="FilterClause"/> representing the metadata bound filter expression.</returns>
internal static ExpressionClause ParseExpressionImplementation(string query, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(query, "query");
// Get the syntactic representation of the filter expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.FilterLimit);
QueryToken expressionToken = expressionParser.ParseFilter(query);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
MetadataBinder binder = new MetadataBinder(state);
FilterBinder filterBinder = new FilterBinder(binder.Bind, state);
ExpressionClause boundNode = filterBinder.BindProperyExpression(expressionToken);
return(boundNode);
}
/// <summary>
/// Parses an <paramref name="apply"/> clause on the given <paramref name="elementType"/>, binding
/// the text into a metadata-bound or dynamic properties to be applied using the provided model.
/// </summary>
/// <param name="apply">String representation of the apply expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the apply clause refers to.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="ApplyClause"/> representing the metadata bound apply expression.</returns>
private static ApplyClause ParseApplyImplementation(string apply, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(apply, "apply");
// Get the syntactic representation of the apply expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.FilterLimit, configuration.EnableCaseInsensitiveUriFunctionIdentifier);
var applyTokens = expressionParser.ParseApply(apply);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
MetadataBinder binder = new MetadataBinder(state);
ApplyBinder applyBinder = new ApplyBinder(binder.Bind, state);
ApplyClause boundNode = applyBinder.BindApply(applyTokens);
return(boundNode);
}
/// <summary>
/// Parses an <paramref name="orderBy "/> clause on the given <paramref name="elementType"/>, binding
/// the text into semantic nodes using the provided model.
/// </summary>
/// <param name="orderBy">String representation of the orderby expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the orderby clause refers to.</param>
/// <param name="navigationSource">NavigationSource that the elements are from.</param>
/// <returns>An <see cref="OrderByClause"/> representing the metadata bound orderby expression.</returns>
private static OrderByClause ParseOrderByImplementation(string orderBy, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(configuration.Model, "model");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(orderBy, "orderBy");
// Get the syntactic representation of the orderby expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.OrderByLimit, configuration.EnableCaseInsensitiveBuiltinIdentifier);
var orderByQueryTokens = expressionParser.ParseOrderBy(orderBy);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
MetadataBinder binder = new MetadataBinder(state);
OrderByBinder orderByBinder = new OrderByBinder(binder.Bind);
OrderByClause orderByClause = orderByBinder.BindOrderBy(state, orderByQueryTokens);
return(orderByClause);
}
private static bool TryParseOperationParameters(string functionName, string parenthesisExpression, IEdmOperation operation, out ICollection<OperationSegmentParameter> parsedSegementParameters, bool enableUriTemplateParsing = false)
{
ICollection<FunctionParameterToken> splitParameters;
parsedSegementParameters = null;
ODataUriParserConfiguration configuration = new ODataUriParserConfiguration(HardCodedTestModel.TestModel) { EnableUriTemplateParsing = enableUriTemplateParsing };
if (FunctionParameterParser.TrySplitOperationParameters(parenthesisExpression, configuration, out splitParameters))
{
parsedSegementParameters = FunctionCallBinder.BindSegmentParameters(configuration, operation, splitParameters);
return true;
}
return false;
}
private static bool TryParseOperationParameters(string functionName, string parenthesisExpression, ParameterAliasValueAccessor paramAliasAccessor, IEdmOperation operation, out ICollection<OperationSegmentParameter> parsedSegementParameters)
{
ICollection<FunctionParameterToken> splitParameters;
parsedSegementParameters = null;
ODataUriParserConfiguration configuration = new ODataUriParserConfiguration(HardCodedTestModel.TestModel) { ParameterAliasValueAccessor = paramAliasAccessor };
if (FunctionParameterParser.TrySplitOperationParameters(parenthesisExpression, configuration, out splitParameters))
{
parsedSegementParameters = FunctionCallBinder.BindSegmentParameters(configuration, operation, splitParameters);
return true;
}
return false;
}
/// <summary>
/// Parses the <paramref name="select"/> and <paramref name="expand"/> clauses on the given <paramref name="elementType"/>, binding
/// the text into a metadata-bound list of properties to be selected using the provided model.
/// </summary>
/// <param name="select">String representation of the select expression from the URI.</param>
/// <param name="expand">String representation of the expand expression from the URI.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the select and expand clauses are projecting.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="SelectExpandClause"/> representing the metadata bound select and expand expression.</returns>
private static SelectExpandClause ParseSelectAndExpandImplementation(string select, string expand, ODataUriParserConfiguration configuration, IEdmStructuredType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(configuration.Model, "model");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExpandToken expandTree;
SelectToken selectTree;
// syntactic pass
SelectExpandSyntacticParser.Parse(select, expand, configuration, out expandTree, out selectTree);
// semantic pass
SelectExpandSemanticBinder binder = new SelectExpandSemanticBinder();
return binder.Bind(elementType, navigationSource, expandTree, selectTree, configuration);
}
/// <summary>
/// Parses the <paramref name="select"/> and <paramref name="expand"/> clauses on the given <paramref name="elementType"/>, binding
/// the text into a metadata-bound list of properties to be selected using the provided model.
/// </summary>
/// <param name="select">String representation of the select expression from the URI.</param>
/// <param name="expand">String representation of the expand expression from the URI.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the select and expand clauses are projecting.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="SelectExpandClause"/> representing the metadata bound select and expand expression.</returns>
private static SelectExpandClause ParseSelectAndExpandImplementation(string select, string expand, ODataUriParserConfiguration configuration, IEdmStructuredType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(configuration.Model, "model");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExpandToken expandTree;
SelectToken selectTree;
// syntactic pass , pass in the expand parent entity type name, in case expand option contains star, will get all the parent entity navigation properties (both declared and dynamical).
SelectExpandSyntacticParser.Parse(select, expand, elementType, configuration, out expandTree, out selectTree);
// semantic pass
SelectExpandSemanticBinder binder = new SelectExpandSemanticBinder();
return(binder.Bind(elementType, navigationSource, expandTree, selectTree, configuration));
}
/// <summary>
/// Parses an <paramref name="orderBy "/> clause on the given <paramref name="elementType"/>, binding
/// the text into semantic nodes using the provided model.
/// </summary>
/// <param name="orderBy">String representation of the orderby expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the orderby clause refers to.</param>
/// <param name="navigationSource">NavigationSource that the elements are from.</param>
/// <returns>An <see cref="OrderByClause"/> representing the metadata bound orderby expression.</returns>
private OrderByClause ParseOrderByImplementation(string orderBy, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(configuration.Model, "model");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(orderBy, "orderBy");
// Get the syntactic representation of the orderby expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.OrderByLimit, configuration.EnableCaseInsensitiveUriFunctionIdentifier);
var orderByQueryTokens = expressionParser.ParseOrderBy(orderBy);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
if (applyClause != null)
{
state.AggregatedPropertyNames = applyClause.GetLastAggregatedPropertyNames();
}
MetadataBinder binder = new MetadataBinder(state);
OrderByBinder orderByBinder = new OrderByBinder(binder.Bind);
OrderByClause orderByClause = orderByBinder.BindOrderBy(state, orderByQueryTokens);
return orderByClause;
}
/// <summary>
/// Parses an <paramref name="apply"/> clause on the given <paramref name="elementType"/>, binding
/// the text into a metadata-bound or dynamic properties to be applied using the provided model.
/// </summary>
/// <param name="apply">String representation of the apply expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the apply clause refers to.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="ApplyClause"/> representing the metadata bound apply expression.</returns>
private static ApplyClause ParseApplyImplementation(string apply, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(apply, "apply");
// Get the syntactic representation of the apply expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.FilterLimit, configuration.EnableCaseInsensitiveUriFunctionIdentifier);
var applyTokens = expressionParser.ParseApply(apply);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
MetadataBinder binder = new MetadataBinder(state);
ApplyBinder applyBinder = new ApplyBinder(binder.Bind, state);
ApplyClause boundNode = applyBinder.BindApply(applyTokens);
return boundNode;
}
/// <summary>
/// Build an ODataUriParser
/// </summary>
/// <param name="model">Model to use for metadata binding.</param>
/// <param name="fullUri">full Uri to be parsed, it should be a relative Uri.</param>
public ODataUriParser(IEdmModel model, Uri fullUri)
{
ExceptionUtils.CheckArgumentNotNull(fullUri, "fullUri");
if (fullUri.IsAbsoluteUri)
{
throw new ODataException(Strings.UriParser_FullUriMustBeRelative);
}
this.configuration = new ODataUriParserConfiguration(model);
this.fullUri = fullUri;
this.queryOptions = UriUtils.ParseQueryOptions(UriUtils.CreateMockAbsoluteUri(this.fullUri));
}
/// <summary>
/// Parses the <paramref name="select"/> and <paramref name="expand"/> clauses on the given <paramref name="elementType"/>, binding
/// the text into a metadata-bound list of properties to be selected using the provided model.
/// </summary>
/// <param name="select">String representation of the select expression from the URI.</param>
/// <param name="expand">String representation of the expand expression from the URI.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the select and expand clauses are projecting.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="SelectExpandClause"/> representing the metadata bound select and expand expression.</returns>
private static SelectExpandClause ParseSelectAndExpandImplementation(string select, string expand, ODataUriParserConfiguration configuration, IEdmStructuredType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(configuration.Model, "model");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExpandToken expandTree;
SelectToken selectTree;
// syntactic pass
SelectExpandSyntacticParser.Parse(select, expand, configuration, out expandTree, out selectTree);
// semantic pass
SelectExpandSemanticBinder binder = new SelectExpandSemanticBinder();
return(binder.Bind(elementType, navigationSource, expandTree, selectTree, configuration));
}
public void FunctionParameterParserShouldFailIfAnExtraClosingParenthesisIsFoundInPath()
{
ICollection<FunctionParameterToken> splitParameters;
ODataUriParserConfiguration configuration = new ODataUriParserConfiguration(HardCodedTestModel.TestModel) { ParameterAliasValueAccessor = null };
Action parse = () => FunctionParameterParser.TrySplitOperationParameters(/*"fakeFunc", */ "a=1)", configuration, out splitParameters);
parse.ShouldThrow<ODataException>().WithMessage(ODataErrorStrings.ExpressionLexer_SyntaxError(4, "a=1)"));
}
/// <summary>
/// Parses a <paramref name="filter"/> clause on the given <paramref name="elementType"/>, binding
/// the text into semantic nodes using the provided model.
/// </summary>
/// <param name="filter">String representation of the filter expression.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the filter clause refers to.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="FilterClause"/> representing the metadata bound filter expression.</returns>
private FilterClause ParseFilterImplementation(string filter, ODataUriParserConfiguration configuration, IEdmType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExceptionUtils.CheckArgumentNotNull(filter, "filter");
// Get the syntactic representation of the filter expression
UriQueryExpressionParser expressionParser = new UriQueryExpressionParser(configuration.Settings.FilterLimit, configuration.EnableCaseInsensitiveUriFunctionIdentifier);
QueryToken filterToken = expressionParser.ParseFilter(filter);
// Bind it to metadata
BindingState state = new BindingState(configuration);
state.ImplicitRangeVariable = NodeFactory.CreateImplicitRangeVariable(elementType.ToTypeReference(), navigationSource);
state.RangeVariables.Push(state.ImplicitRangeVariable);
if (applyClause != null)
{
state.AggregatedPropertyNames = applyClause.GetLastAggregatedPropertyNames();
}
MetadataBinder binder = new MetadataBinder(state);
FilterBinder filterBinder = new FilterBinder(binder.Bind, state);
FilterClause boundNode = filterBinder.BindFilter(filterToken);
return boundNode;
}
private ExpandToken StarExpandTesting(string expand, String entitySetType)
{
IEdmModel model = Microsoft.Test.OData.Utils.Metadata.TestModels.BuildTestModel();
ODataUriParserConfiguration configuration = new ODataUriParserConfiguration(EdmCoreModel.Instance)
{
Settings = { PathLimit = 10, FilterLimit = 10, OrderByLimit = 10, SearchLimit = 10, SelectExpandLimit = 10 }
};
var parentEntityType = configuration.Resolver.ResolveNavigationSource(model, entitySetType).EntityType();
SelectExpandParser expandParser = new SelectExpandParser(configuration.Resolver, expand, parentEntityType, configuration.Settings.SelectExpandLimit, configuration.EnableCaseInsensitiveUriFunctionIdentifier)
{
MaxPathDepth = configuration.Settings.PathLimit,
MaxFilterDepth = configuration.Settings.FilterLimit,
MaxOrderByDepth = configuration.Settings.OrderByLimit,
MaxSearchDepth = configuration.Settings.SearchLimit
};
return expandParser.ParseExpand();
}
/// <summary>
/// Parses the <paramref name="select"/> and <paramref name="expand"/> clauses on the given <paramref name="elementType"/>, binding
/// the text into a metadata-bound list of properties to be selected using the provided model.
/// </summary>
/// <param name="select">String representation of the select expression from the URI.</param>
/// <param name="expand">String representation of the expand expression from the URI.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <param name="elementType">Type that the select and expand clauses are projecting.</param>
/// <param name="navigationSource">Navigation source that the elements being filtered are from.</param>
/// <returns>A <see cref="SelectExpandClause"/> representing the metadata bound select and expand expression.</returns>
private static SelectExpandClause ParseSelectAndExpandImplementation(string select, string expand, ODataUriParserConfiguration configuration, IEdmStructuredType elementType, IEdmNavigationSource navigationSource)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(configuration.Model, "model");
ExceptionUtils.CheckArgumentNotNull(elementType, "elementType");
ExpandToken expandTree;
SelectToken selectTree;
// syntactic pass , pass in the expand parent entity type name, in case expand option contains star, will get all the parent entity navigation properties (both declared and dynamical).
SelectExpandSyntacticParser.Parse(select, expand, elementType, configuration, out expandTree, out selectTree);
// semantic pass
SelectExpandSemanticBinder binder = new SelectExpandSemanticBinder();
return binder.Bind(elementType, navigationSource, expandTree, selectTree, configuration);
}
public void ParentEntityTypeIsNullForExpandStar()
{
var expand = "*";
ODataUriParserConfiguration configuration = new ODataUriParserConfiguration(EdmCoreModel.Instance)
{
Settings = { PathLimit = 10, FilterLimit = 10, OrderByLimit = 10, SearchLimit = 10, SelectExpandLimit = 10 }
};
SelectExpandParser expandParser = new SelectExpandParser(configuration.Resolver, expand, null, configuration.Settings.SelectExpandLimit, configuration.EnableCaseInsensitiveUriFunctionIdentifier)
{
MaxPathDepth = configuration.Settings.PathLimit,
MaxFilterDepth = configuration.Settings.FilterLimit,
MaxOrderByDepth = configuration.Settings.OrderByLimit,
MaxSearchDepth = configuration.Settings.SearchLimit
};
Action action = () => expandParser.ParseExpand();
action.ShouldThrow<ODataException>().WithMessage(Strings.UriExpandParser_ParentEntityIsNull(""));
}
/// <summary>
/// Parses the <paramref name="search"/> clause, binding
/// the text into a metadata-bound list of properties to be selected using the provided model.
/// </summary>
/// <param name="search">String representation of the search expression from the URI.</param>
/// <param name="configuration">The configuration used for binding.</param>
/// <returns>A <see cref="SearchClause"/> representing the metadata bound search expression.</returns>
private static SearchClause ParseSearchImplementation(string search, ODataUriParserConfiguration configuration)
{
ExceptionUtils.CheckArgumentNotNull(configuration, "configuration");
ExceptionUtils.CheckArgumentNotNull(search, "search");
SearchParser searchParser = new SearchParser(configuration.Settings.SearchLimit);
QueryToken queryToken = searchParser.ParseSearch(search);
// Bind it to metadata
BindingState state = new BindingState(configuration);
MetadataBinder binder = new MetadataBinder(state);
SearchBinder searchBinder = new SearchBinder(binder.Bind);
return searchBinder.BindSearch(queryToken);
}
private void LimitationTest(string select, string expand)
{
SelectToken selectTree;
ExpandToken expandTree;
ODataUriParserConfiguration configuration = new ODataUriParserConfiguration(EdmCoreModel.Instance)
{
Settings = { PathLimit = 2, FilterLimit = 7, OrderByLimit = 7, SearchLimit = 7, SelectExpandLimit = 5 }
};
SelectExpandSyntacticParser.Parse(select, expand, configuration, out expandTree, out selectTree);
}