/// <summary>
/// Tries to bind a given token as an a declared structural or navigation property.
/// </summary>
/// <param name="tokenIn">Token to bind.</param>
/// <param name="edmType">the type to search for this property</param>
/// <param name="resolver">Resolver for uri parser.</param>
/// <param name="segment">Bound segment if the token was bound to a declared property successfully, or null.</param>
/// <returns>True if the token was bound successfully, or false otherwise.</returns>
private static bool TryBindAsDeclaredProperty(PathSegmentToken tokenIn, IEdmStructuredType edmType, ODataUriResolver resolver, out ODataPathSegment segment)
{
IEdmProperty prop = resolver.ResolveProperty(edmType, tokenIn.Identifier);
if (prop == null)
{
segment = null;
return(false);
}
if (prop.PropertyKind == EdmPropertyKind.Structural)
{
segment = new PropertySegment((IEdmStructuralProperty)prop);
return(true);
}
if (prop.PropertyKind == EdmPropertyKind.Navigation)
{
segment = new NavigationPropertySegment((IEdmNavigationProperty)prop, null /*TODO: set*/);
return(true);
}
throw new ODataException(ODataErrorStrings.SelectExpandBinder_UnknownPropertyType(prop.Name));
}
/// <summary>
/// Check if this segment is equal to another segment.
/// </summary>
/// <param name="other">the other segment to check.</param>
/// <returns>true if the other segment is equal.</returns>
/// <exception cref="System.ArgumentNullException">throws if the input other is null.</exception>
internal override bool Equals(ODataPathSegment other)
{
ExceptionUtils.CheckArgumentNotNull(other, "other");
return(other is CountSegment);
}
/// <summary>
/// Tries to bind a given token as an Operation.
/// </summary>
/// <param name="pathToken">Token to bind.</param>
/// <param name="model">The model.</param>
/// <param name="entityType">the current entity type to use as the binding type when looking for operations.</param>
/// <param name="segment">Bound segment if the token was bound to an operation successfully, or null.</param>
/// <returns>True if the token was bound successfully, or false otherwise.</returns>
internal static bool TryBindAsOperation(PathSegmentToken pathToken, IEdmModel model, IEdmStructuredType entityType, out ODataPathSegment segment)
{
Debug.Assert(pathToken != null, "pathToken != null");
Debug.Assert(entityType != null, "bindingType != null");
List <IEdmOperation> possibleFunctions = new List <IEdmOperation>();
IList <string> parameterNames = new List <string>();
// Catch all catchable exceptions as FindDeclaredBoundOperations is implemented by anyone.
// If an exception occurs it will be supressed and the possible functions will be empty and return false.
try
{
int wildCardPos = pathToken.Identifier.IndexOf("*", StringComparison.Ordinal);
if (wildCardPos > -1)
{
string namespaceName = pathToken.Identifier.Substring(0, wildCardPos - 1);
possibleFunctions = model.FindBoundOperations(entityType).Where(o => o.Namespace == namespaceName).ToList();
}
else
{
NonSystemToken nonSystemToken = pathToken as NonSystemToken;
if (nonSystemToken != null && nonSystemToken.NamedValues != null)
{
parameterNames = nonSystemToken.NamedValues.Select(s => s.Name).ToList();
}
if (parameterNames.Count > 0)
{
// Always force to use fully qualified name when select operation
possibleFunctions = model.FindBoundOperations(entityType).FilterByName(true, pathToken.Identifier).FilterOperationsByParameterNames(parameterNames, false).ToList();
}
else
{
possibleFunctions = model.FindBoundOperations(entityType).FilterByName(true, pathToken.Identifier).ToList();
}
}
}
catch (Exception exc)
{
if (!ExceptionUtils.IsCatchableExceptionType(exc))
{
throw;
}
}
possibleFunctions = possibleFunctions.EnsureOperationsBoundWithBindingParameter().ToList();
// Only filter if there is more than one and its needed.
if (possibleFunctions.Count > 1)
{
possibleFunctions = possibleFunctions.FilterBoundOperationsWithSameTypeHierarchyToTypeClosestToBindingType(entityType).ToList();
}
// If more than one overload matches, try to select based on optional parameters
if (possibleFunctions.Count > 1 && parameterNames.Count > 0)
{
possibleFunctions = possibleFunctions.FindBestOverloadBasedOnParameters(parameterNames).ToList();
}
if (possibleFunctions.Count <= 0)
{
segment = null;
return(false);
}
segment = new OperationSegment(possibleFunctions, null /*entitySet*/);
return(true);
}
/// <summary>
/// Computes whether or not the ODataPath targets at an unknown segment.
/// </summary>
/// <param name="path">Path to perform the computation on.</param>
/// <returns>True if the the ODataPath targets at an unknown segment. False otherwise.</returns>
public static bool IsUndeclared(this ODataPath path)
{
ODataPathSegment lastNonTypeCastSegment = path.TrimEndingTypeSegment().LastSegment;
return(lastNonTypeCastSegment is DynamicPathSegment);
}
/// <summary>
/// Get the string representation of <see cref="ODataPath"/>.
/// mainly translate Context Url path.
/// </summary>
/// <param name="path">Path to perform the computation on.</param>
/// <returns>The string representation of the Context Url path.</returns>
public static string ToContextUrlPathString(this ODataPath path)
{
StringBuilder pathString = new StringBuilder();
PathSegmentToContextUrlPathTranslator pathTranslator = PathSegmentToContextUrlPathTranslator.DefaultInstance;
ODataPathSegment priorSegment = null;
bool foundOperationWithoutPath = false;
foreach (ODataPathSegment segment in path)
{
OperationSegment operationSegment = segment as OperationSegment;
OperationImportSegment operationImportSegment = segment as OperationImportSegment;
if (operationImportSegment != null)
{
IEdmOperationImport operationImport = operationImportSegment.OperationImports.FirstOrDefault();
Debug.Assert(operationImport != null);
EdmPathExpression pathExpression = operationImport.EntitySet as EdmPathExpression;
if (pathExpression != null)
{
Debug.Assert(priorSegment == null); // operation import is always the first segment?
pathString.Append(pathExpression.Path);
}
else
{
pathString = operationImport.Operation.ReturnType != null ?
new StringBuilder(operationImport.Operation.ReturnType.FullName()) :
new StringBuilder("Edm.Untyped");
foundOperationWithoutPath = true;
}
}
else if (operationSegment != null)
{
IEdmOperation operation = operationSegment.Operations.FirstOrDefault();
Debug.Assert(operation != null);
if (operation.IsBound &&
priorSegment != null &&
operation.Parameters.First().Type.Definition == priorSegment.EdmType)
{
if (operation.EntitySetPath != null)
{
foreach (string pathSegment in operation.EntitySetPath.PathSegments.Skip(1))
{
pathString.Append('/');
pathString.Append(pathSegment);
}
}
else if (operationSegment.EntitySet != null)
{
// Is it correct to check EntitySet?
pathString = new StringBuilder(operationSegment.EntitySet.Name);
}
else
{
pathString = operation.ReturnType != null ?
new StringBuilder(operation.ReturnType.FullName()) :
new StringBuilder("Edm.Untyped");
foundOperationWithoutPath = true;
}
}
}
else
{
if (foundOperationWithoutPath)
{
pathString = new StringBuilder(segment.EdmType.FullTypeName());
foundOperationWithoutPath = false;
}
else
{
pathString.Append(segment.TranslateWith(pathTranslator));
}
}
priorSegment = segment;
}
return(pathString.ToString().TrimStart('/'));
}
/// <summary>Tries to create a key segment for the given filter if it is non empty.</summary>
/// <param name="previous">Segment on which to compose.</param>
/// <param name="previousKeySegment">The parent node's key segment.</param>
/// <param name="parenthesisExpression">Parenthesis expression of segment.</param>
/// <param name="resolver">The resolver to use.</param>
/// <param name="keySegment">The key segment that was created if the key was non-empty.</param>
/// <param name="enableUriTemplateParsing">Whether Uri template parsing is enabled.</param>
/// <returns>Whether the key was non-empty.</returns>
internal static bool TryCreateKeySegmentFromParentheses(ODataPathSegment previous, KeySegment previousKeySegment, string parenthesisExpression, ODataUriResolver resolver, out ODataPathSegment keySegment, bool enableUriTemplateParsing = false)
{
Debug.Assert(parenthesisExpression != null, "parenthesisExpression != null");
Debug.Assert(previous != null, "segment!= null");
Debug.Assert(resolver != null, "resolver != null");
if (previous.SingleResult)
{
throw ExceptionUtil.CreateSyntaxError();
}
SegmentArgumentParser key;
if (!SegmentArgumentParser.TryParseKeysFromUri(parenthesisExpression, out key, enableUriTemplateParsing))
{
throw ExceptionUtil.CreateSyntaxError();
}
// People/NS.Employees() is OK, just like People() is OK
if (key.IsEmpty)
{
keySegment = null;
return(false);
}
keySegment = CreateKeySegment(previous, previousKeySegment, key, resolver);
return(true);
}
/// <summary>
/// Computes whether or not the ODataPath targets at an individual property.
/// </summary>
/// <param name="path">Path to perform the computation on.</param>
/// <returns>True if the the ODataPath targets at an individual property. False otherwise.</returns>
public static bool IsIndividualProperty(this ODataPath path)
{
ODataPathSegment lastNonTypeCastSegment = path.TrimEndingTypeSegment().LastSegment;
return(lastNonTypeCastSegment is PropertySegment || lastNonTypeCastSegment is DynamicPathSegment);
}
/// <summary>
/// Creates a new Segment and copies values from another Segment.
/// </summary>
/// <param name="other">Segment to copy values from.</param>
internal ODataPathSegment(ODataPathSegment other)
{
this.CopyValuesFrom(other);
}
/// <summary>
/// Check if this segment is equal to another segment.
/// </summary>
/// <param name="other">the other segment to check</param>
/// <returns>true if the segments are equal.</returns>
internal virtual bool Equals(ODataPathSegment other)
{
return(ReferenceEquals(this, other));
}
private void ProcessTokenAsPath(NonSystemToken tokenIn)
{
Debug.Assert(tokenIn != null, "tokenIn != null");
List <ODataPathSegment> pathSoFar = new List <ODataPathSegment>();
IEdmStructuredType currentLevelType = this.edmType;
// first, walk through all type segments in a row, converting them from tokens into segments.
if (tokenIn.IsNamespaceOrContainerQualified())
{
PathSegmentToken firstNonTypeToken;
pathSoFar.AddRange(SelectExpandPathBinder.FollowTypeSegments(tokenIn, this.model, this.maxDepth, this.resolver, ref currentLevelType, out firstNonTypeToken));
Debug.Assert(firstNonTypeToken != null, "Did not get last token.");
tokenIn = firstNonTypeToken as NonSystemToken;
if (tokenIn == null)
{
throw new ODataException(ODataErrorStrings.SelectPropertyVisitor_SystemTokenInSelect(firstNonTypeToken.Identifier));
}
}
// next, create a segment for the first non-type segment in the path.
ODataPathSegment lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(tokenIn, this.model, currentLevelType, resolver);
// next, create an ODataPath and add the segments to it.
if (lastSegment != null)
{
pathSoFar.Add(lastSegment);
// try create a complex type property path.
while (true)
{
// no need to go on if the current property is not of complex type or collection of complex type,
// unless the segment is a primitive type cast or a property on an open complex property.
currentLevelType = lastSegment.EdmType as IEdmStructuredType;
IEdmCollectionType collectionType = lastSegment.EdmType as IEdmCollectionType;
IEdmPrimitiveType primitiveType = lastSegment.EdmType as IEdmPrimitiveType;
DynamicPathSegment dynamicPath = lastSegment as DynamicPathSegment;
if ((currentLevelType == null || currentLevelType.TypeKind != EdmTypeKind.Complex) &&
(collectionType == null || collectionType.ElementType.TypeKind() != EdmTypeKind.Complex) &&
(primitiveType == null || primitiveType.TypeKind != EdmTypeKind.Primitive) &&
(dynamicPath == null || tokenIn.NextToken == null))
{
break;
}
NonSystemToken nextToken = tokenIn.NextToken as NonSystemToken;
if (nextToken == null)
{
break;
}
if (primitiveType == null && dynamicPath == null)
{
// This means last segment a collection of complex type,
// current segment can only be type cast and cannot be property name.
if (currentLevelType == null)
{
currentLevelType = collectionType.ElementType.Definition as IEdmStructuredType;
}
// If there is no collection type in the path yet, will try to bind property for the next token
// first try bind the segment as property.
lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(nextToken, this.model,
currentLevelType, resolver);
}
else
{
// determine whether we are looking at a type cast or a dynamic path segment.
EdmPrimitiveTypeKind nextTypeKind = EdmCoreModel.Instance.GetPrimitiveTypeKind(nextToken.Identifier);
IEdmPrimitiveType castType = EdmCoreModel.Instance.GetPrimitiveType(nextTypeKind);
if (castType != null)
{
lastSegment = new TypeSegment(castType, castType, null);
}
else if (dynamicPath != null)
{
lastSegment = new DynamicPathSegment(nextToken.Identifier);
}
else
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
}
// then try bind the segment as type cast.
if (lastSegment == null)
{
IEdmStructuredType typeFromNextToken =
UriEdmHelpers.FindTypeFromModel(this.model, nextToken.Identifier, this.resolver) as
IEdmStructuredType;
if (typeFromNextToken.IsOrInheritsFrom(currentLevelType))
{
lastSegment = new TypeSegment(typeFromNextToken, /*entitySet*/ null);
}
}
// type cast failed too.
if (lastSegment == null)
{
break;
}
// try move to and add next path segment.
tokenIn = nextToken;
pathSoFar.Add(lastSegment);
}
}
ODataSelectPath selectedPath = new ODataSelectPath(pathSoFar);
var selectionItem = new PathSelectItem(selectedPath);
// non-navigation cases do not allow further segments in $select.
if (tokenIn.NextToken != null)
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
// if the selected item is a nav prop, then see if its already there before we add it.
NavigationPropertySegment trailingNavPropSegment = selectionItem.SelectedPath.LastSegment as NavigationPropertySegment;
if (trailingNavPropSegment != null)
{
if (this.expandClauseToDecorate.SelectedItems.Any(x => x is PathSelectItem &&
((PathSelectItem)x).SelectedPath.Equals(selectedPath)))
{
return;
}
}
this.expandClauseToDecorate.AddToSelectedItems(selectionItem);
}
/// <summary>
/// Handle a ODataPathSegment
/// </summary>
/// <param name="segment">the segment to Handle</param>
public virtual void Handle(ODataPathSegment segment)
{
throw new NotImplementedException();
}
/// <summary>
/// Tries to bind a given token as a declared annotation term.
/// </summary>
/// <param name="tokenIn">Token to bind.</param>
/// <param name="model">The model to search for this term</param>
/// <param name="resolver">Resolver for uri parser.</param>
/// <param name="segment">Bound segment if the token was bound to a declared term successfully, or null.</param>
/// <returns>True if the token was bound successfully, or false otherwise.</returns>
private static bool TryBindAsDeclaredTerm(PathSegmentToken tokenIn, IEdmModel model, ODataUriResolver resolver, out ODataPathSegment segment)
{
if (!UriParserHelper.IsAnnotation(tokenIn.Identifier))
{
segment = null;
return(false);
}
IEdmTerm term = resolver.ResolveTerm(model, tokenIn.Identifier.Remove(0, 1));
if (term == null)
{
segment = null;
return(false);
}
segment = new AnnotationSegment(term);
return(true);
}
/// <summary>
/// Process a <see cref="PathSegmentToken"/> following any type segments if necessary.
/// </summary>
/// <param name="tokenIn">the path token to process.</param>
/// <returns>The processed OData segments.</returns>
private List <ODataPathSegment> ProcessSelectTokenPath(PathSegmentToken tokenIn)
{
Debug.Assert(tokenIn != null, "tokenIn != null");
List <ODataPathSegment> pathSoFar = new List <ODataPathSegment>();
IEdmStructuredType currentLevelType = this.edmType;
// first, walk through all type segments in a row, converting them from tokens into segments.
if (tokenIn.IsNamespaceOrContainerQualified() && !UriParserHelper.IsAnnotation(tokenIn.Identifier))
{
PathSegmentToken firstNonTypeToken;
pathSoFar.AddRange(SelectExpandPathBinder.FollowTypeSegments(tokenIn, this.Model, this.Settings.SelectExpandLimit, this.configuration.Resolver, ref currentLevelType, out firstNonTypeToken));
Debug.Assert(firstNonTypeToken != null, "Did not get last token.");
tokenIn = firstNonTypeToken as NonSystemToken;
if (tokenIn == null)
{
throw new ODataException(ODataErrorStrings.SelectExpandBinder_SystemTokenInSelect(firstNonTypeToken.Identifier));
}
}
// next, create a segment for the first non-type segment in the path.
ODataPathSegment lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(tokenIn, this.Model, currentLevelType, this.configuration.Resolver, this.state);
// next, create an ODataPath and add the segments to it.
if (lastSegment != null)
{
pathSoFar.Add(lastSegment);
// try create a complex type property path.
while (true)
{
// no need to go on if the current property is not of complex type or collection of complex type,
// unless the segment is a primitive type cast or a property on an open complex property.
currentLevelType = lastSegment.EdmType as IEdmStructuredType;
IEdmCollectionType collectionType = lastSegment.EdmType as IEdmCollectionType;
IEdmPrimitiveType primitiveType = lastSegment.EdmType as IEdmPrimitiveType;
DynamicPathSegment dynamicPath = lastSegment as DynamicPathSegment;
if ((currentLevelType == null || currentLevelType.TypeKind != EdmTypeKind.Complex) &&
(collectionType == null || collectionType.ElementType.TypeKind() != EdmTypeKind.Complex) &&
(primitiveType == null || primitiveType.TypeKind != EdmTypeKind.Primitive) &&
(dynamicPath == null || tokenIn.NextToken == null))
{
break;
}
NonSystemToken nextToken = tokenIn.NextToken as NonSystemToken;
if (nextToken == null)
{
break;
}
if (UriParserHelper.IsAnnotation(nextToken.Identifier))
{
lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(nextToken, this.Model,
currentLevelType, this.configuration.Resolver, null);
}
else if (primitiveType == null && dynamicPath == null)
{
// This means last segment a collection of complex type,
// current segment can only be type cast and cannot be property name.
if (currentLevelType == null)
{
currentLevelType = collectionType.ElementType.Definition as IEdmStructuredType;
}
// If there is no collection type in the path yet, will try to bind property for the next token
// first try bind the segment as property.
lastSegment = SelectPathSegmentTokenBinder.ConvertNonTypeTokenToSegment(nextToken, this.Model,
currentLevelType, this.configuration.Resolver, null);
}
else
{
// determine whether we are looking at a type cast or a dynamic path segment.
EdmPrimitiveTypeKind nextTypeKind = EdmCoreModel.Instance.GetPrimitiveTypeKind(nextToken.Identifier);
IEdmPrimitiveType castType = EdmCoreModel.Instance.GetPrimitiveType(nextTypeKind);
if (castType != null)
{
lastSegment = new TypeSegment(castType, castType, null);
}
else if (dynamicPath != null)
{
lastSegment = new DynamicPathSegment(nextToken.Identifier);
}
else
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
}
// then try bind the segment as type cast.
if (lastSegment == null)
{
IEdmStructuredType typeFromNextToken =
UriEdmHelpers.FindTypeFromModel(this.Model, nextToken.Identifier, this.configuration.Resolver) as
IEdmStructuredType;
if (typeFromNextToken.IsOrInheritsFrom(currentLevelType))
{
lastSegment = new TypeSegment(typeFromNextToken, /*entitySet*/ null);
}
}
// type cast failed too.
if (lastSegment == null)
{
break;
}
// try move to and add next path segment.
tokenIn = nextToken;
pathSoFar.Add(lastSegment);
}
}
// non-navigation cases do not allow further segments in $select.
if (tokenIn.NextToken != null)
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
// Later, we can consider to create a "DynamicOperationSegment" to handle this.
// But now, Let's throw exception.
if (lastSegment == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_InvalidIdentifierInQueryOption(tokenIn.Identifier));
}
// navigation property is not allowed to append sub path in the selection.
NavigationPropertySegment navPropSegment = pathSoFar.LastOrDefault() as NavigationPropertySegment;
if (navPropSegment != null && tokenIn.NextToken != null)
{
throw new ODataException(ODataErrorStrings.SelectBinder_MultiLevelPathInSelect);
}
return(pathSoFar);
}
/// <summary>
/// Generate a select item <see cref="SelectItem"/> based on a <see cref="SelectTermToken"/>.
/// for example: abc/efg($count=true;$filter=....;$top=1)
/// </summary>
/// <param name="tokenIn">the select term token to visit</param>
/// <returns>the select item for this select term token.</returns>
private SelectItem GenerateSelectItem(SelectTermToken tokenIn)
{
ExceptionUtils.CheckArgumentNotNull(tokenIn, "tokenIn");
ExceptionUtils.CheckArgumentNotNull(tokenIn.PathToProperty, "pathToProperty");
VerifySelectedPath(tokenIn);
SelectItem newSelectItem;
if (ProcessWildcardTokenPath(tokenIn, out newSelectItem))
{
return(newSelectItem);
}
IList <ODataPathSegment> selectedPath = ProcessSelectTokenPath(tokenIn.PathToProperty);
Debug.Assert(selectedPath.Count > 0);
// Navigation property should be the last segment in select path.
if (VerifySelectedNavigationProperty(selectedPath, tokenIn))
{
return(new PathSelectItem(new ODataSelectPath(selectedPath)));
}
IEdmNavigationSource targetNavigationSource = null;
ODataPathSegment lastSegment = selectedPath.Last();
IEdmType targetElementType = lastSegment.TargetEdmType;
IEdmCollectionType collection = targetElementType as IEdmCollectionType;
if (collection != null)
{
targetElementType = collection.ElementType.Definition;
}
IEdmTypeReference elementTypeReference = targetElementType.ToTypeReference();
// When Creating Range Variables, we only need a Navigation Source when the elementTypeReference is a StructuredTypeReference.
// When the elementTypeReference is NOT StructuredTypeReference, We will create a NonResourceRangeVariable which don't require a Navigation Source.
if (elementTypeReference != null && elementTypeReference.IsStructured())
{
// We should use the "NavigationSource" at this level for the next level binding.
targetNavigationSource = this.NavigationSource;
}
// $compute
ComputeClause compute = BindCompute(tokenIn.ComputeOption, this.ResourcePathNavigationSource, targetNavigationSource, elementTypeReference);
HashSet <EndPathToken> generatedProperties = GetGeneratedProperties(compute, null);
// $filter
FilterClause filter = BindFilter(tokenIn.FilterOption, this.ResourcePathNavigationSource, targetNavigationSource, elementTypeReference, generatedProperties);
// $orderby
OrderByClause orderBy = BindOrderby(tokenIn.OrderByOptions, this.ResourcePathNavigationSource, targetNavigationSource, elementTypeReference, generatedProperties);
// $search
SearchClause search = BindSearch(tokenIn.SearchOption, this.ResourcePathNavigationSource, targetNavigationSource, elementTypeReference);
// $select
List <ODataPathSegment> parsedPath = new List <ODataPathSegment>(this.parsedSegments);
parsedPath.AddRange(selectedPath);
SelectExpandClause selectExpand = BindSelectExpand(null, tokenIn.SelectOption, parsedPath, this.ResourcePathNavigationSource, targetNavigationSource, elementTypeReference, generatedProperties);
return(new PathSelectItem(new ODataSelectPath(selectedPath),
targetNavigationSource,
selectExpand,
filter,
orderBy,
tokenIn.TopOption,
tokenIn.SkipOption,
tokenIn.CountQueryOption,
search,
compute));
}
