/// <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);
}
public void FilterBinder_BindsComputedPropertyInDollarFilter_FromDollarCompute()
{
// Arrange
QueryClause clause = CreateQueryClause("$filter=Total lt 30&$compute=Price mul Qty as Total", _model, typeof(ComputeCustomer));
ODataQuerySettings querySettings = new ODataQuerySettings();
IFilterBinder binder = new FilterBinder();
QueryBinderContext context = new QueryBinderContext(_model, querySettings, typeof(ComputeCustomer));
if (clause.Compute != null)
{
context.AddComputedProperties(clause.Compute.ComputedItems);
}
// Act
Expression filterExp = binder.BindFilter(clause.Filter, context);
// Assert
string resultExpression = ExpressionStringBuilder.ToString(filterExp);
Assert.Equal("$it => (Convert(($it.Price * Convert($it.Qty))) < Convert(30))", resultExpression);
Assert.True(FilterBinderTests.InvokeFilter(new ComputeCustomer {
Price = 10, Qty = 2
}, filterExp));
Assert.False(FilterBinderTests.InvokeFilter(new ComputeCustomer {
Price = 10, Qty = 4
}, filterExp));
}
public static Expression TestBind(FilterClause filterClause, Type filterType, IEdmModel model,
IAssemblyResolver assembliesResolver, ODataQuerySettings querySettings)
{
if (filterClause == null)
{
throw Error.ArgumentNull(nameof(filterClause));
}
if (filterType == null)
{
throw Error.ArgumentNull(nameof(filterType));
}
if (model == null)
{
throw Error.ArgumentNull(nameof(model));
}
if (assembliesResolver == null)
{
throw Error.ArgumentNull(nameof(assembliesResolver));
}
IFilterBinder binder = new FilterBinder();
QueryBinderContext context = new QueryBinderContext(model, querySettings, filterType)
{
AssembliesResolver = assembliesResolver,
};
return(binder.BindFilter(filterClause, context));
}
private static Expression BindFilter <T>(string filter, IEdmModel model, ODataQuerySettings querySettings = null, IAssemblyResolver assembliesResolver = null)
{
Type elementType = typeof(T);
FilterClause orderByClause = CreateFilterClause(filter, model, elementType);
Assert.NotNull(orderByClause);
querySettings = querySettings ?? _defaultSettings;
QueryBinderContext context = new QueryBinderContext(model, querySettings, elementType)
{
AssembliesResolver = assembliesResolver,
};
IFilterBinder filterBinder = new FilterBinder();
return(filterBinder.BindFilter(orderByClause, context));
}
/// <summary>
/// Generate an expand item based on an ExpandTermToken
/// </summary>
/// <param name="tokenIn">the expandTerm token to visit</param>
/// <returns>the expand item for this expand term token.</returns>
private ExpandedNavigationSelectItem GenerateExpandItem(ExpandTermToken tokenIn)
{
ExceptionUtils.CheckArgumentNotNull(tokenIn, "tokenIn");
// ensure that we're always dealing with a normalized tree
if (tokenIn.PathToNavProp.NextToken != null && !tokenIn.PathToNavProp.IsNamespaceOrContainerQualified())
{
throw new ODataException(ODataErrorStrings.ExpandItemBinder_TraversingANonNormalizedTree);
}
PathSegmentToken currentToken = tokenIn.PathToNavProp;
IEdmEntityType currentLevelEntityType = this.entityType;
List <ODataPathSegment> pathSoFar = new List <ODataPathSegment>();
PathSegmentToken firstNonTypeToken = currentToken;
if (currentToken.IsNamespaceOrContainerQualified())
{
pathSoFar.AddRange(SelectExpandPathBinder.FollowTypeSegments(currentToken, this.Model, this.Settings.SelectExpandLimit, ref currentLevelEntityType, out firstNonTypeToken));
}
IEdmProperty edmProperty = currentLevelEntityType.FindProperty(firstNonTypeToken.Identifier);
if (edmProperty == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_PropertyNotDeclared(currentLevelEntityType.FullName(), currentToken.Identifier));
}
IEdmNavigationProperty currentNavProp = edmProperty as IEdmNavigationProperty;
if (currentNavProp == null)
{
// the server allowed non-navigation, non-stream properties to be expanded, but then ignored them.
if (this.Settings.UseWcfDataServicesServerBehavior && !edmProperty.Type.IsStream())
{
return(null);
}
throw new ODataException(ODataErrorStrings.ExpandItemBinder_PropertyIsNotANavigationProperty(currentToken.Identifier, currentLevelEntityType.FullName()));
}
pathSoFar.Add(new NavigationPropertySegment(currentNavProp, /*entitySet*/ null));
ODataExpandPath pathToNavProp = new ODataExpandPath(pathSoFar);
SelectExpandClause subSelectExpand;
if (tokenIn.ExpandOption != null)
{
subSelectExpand = this.GenerateSubExpand(currentNavProp, tokenIn);
}
else
{
subSelectExpand = BuildDefaultSubExpand();
}
subSelectExpand = this.DecorateExpandWithSelect(subSelectExpand, currentNavProp, tokenIn.SelectOption);
IEdmEntitySet targetEntitySet = null;
if (this.entitySet != null)
{
targetEntitySet = this.entitySet.FindNavigationTarget(currentNavProp);
}
// call MetadataBinder to build the filter clause
FilterClause filterOption = null;
if (tokenIn.FilterOption != null)
{
MetadataBinder binder = this.BuildNewMetadataBinder(targetEntitySet);
FilterBinder filterBinder = new FilterBinder(binder.Bind, binder.BindingState);
filterOption = filterBinder.BindFilter(tokenIn.FilterOption);
}
// call MetadataBinder again to build the orderby clause
OrderByClause orderbyOption = null;
if (tokenIn.OrderByOption != null)
{
MetadataBinder binder = this.BuildNewMetadataBinder(targetEntitySet);
OrderByBinder orderByBinder = new OrderByBinder(binder.Bind);
orderbyOption = orderByBinder.BindOrderBy(binder.BindingState, new OrderByToken[] { tokenIn.OrderByOption });
}
return(new ExpandedNavigationSelectItem(pathToNavProp, targetEntitySet, filterOption, orderbyOption, tokenIn.TopOption, tokenIn.SkipOption, tokenIn.InlineCountOption, subSelectExpand));
}