/// <summary>
/// Parses the key properties based on the segment's target type, then creates a new segment for the key.
/// </summary>
/// <param name="segment">The segment to apply the key to.</param>
/// <param name="previousKeySegment">The parent node's key segment.</param>
/// <param name="key">The key to apply.</param>
/// <param name="resolver">The resolver to use.</param>
/// <returns>The newly created key segment.</returns>
private static KeySegment CreateKeySegment(ODataPathSegment segment, KeySegment previousKeySegment, SegmentArgumentParser key, ODataUriResolver resolver)
{
Debug.Assert(segment != null, "segment != null");
Debug.Assert(key != null && !key.IsEmpty, "key != null && !key.IsEmpty");
Debug.Assert(segment.SingleResult == false, "segment.SingleResult == false");
IEdmEntityType targetEntityType = null;
if (!(segment.TargetEdmType != null && segment.TargetEdmType.IsEntityOrEntityCollectionType(out targetEntityType)))
{
throw ExceptionUtil.CreateSyntaxError();
}
Debug.Assert(targetEntityType != null, "targetEntityType != null");
// Make sure the keys specified in the uri matches with the number of keys in the metadata
var keyProperties = targetEntityType.Key().ToList();
if (keyProperties.Count != key.ValueCount)
{
NavigationPropertySegment currentNavPropSegment = segment as NavigationPropertySegment;
if (currentNavPropSegment != null)
{
key = KeyFinder.FindAndUseKeysFromRelatedSegment(key, keyProperties, currentNavPropSegment.NavigationProperty, previousKeySegment);
}
// if we still didn't find any keys, then throw an error.
if (keyProperties.Count != key.ValueCount && resolver.GetType() == typeof(ODataUriResolver))
{
throw ExceptionUtil.CreateBadRequestError(ErrorStrings.BadRequest_KeyCountMismatch(targetEntityType.FullName()));
}
}
if (!key.AreValuesNamed && key.ValueCount > 1 && resolver.GetType() == typeof(ODataUriResolver))
{
throw ExceptionUtil.CreateBadRequestError(ErrorStrings.RequestUriProcessor_KeysMustBeNamed);
}
IEnumerable <KeyValuePair <string, object> > keyPairs;
if (!key.TryConvertValues(targetEntityType, out keyPairs, resolver))
{
throw ExceptionUtil.CreateSyntaxError();
}
IEdmEntityType entityType;
bool isEntity = segment.TargetEdmType.IsEntityOrEntityCollectionType(out entityType);
Debug.Assert(isEntity, "Key target type should be an entity type.");
var keySegment = new KeySegment(keyPairs, entityType, segment.TargetEdmNavigationSource);
keySegment.CopyValuesFrom(segment);
keySegment.SingleResult = true;
return(keySegment);
}
/// <summary>Tries to convert values to the keys of the specified type.</summary>
/// <param name="targetEntityType">The specified type.</param>
/// <param name="keyPairs">The converted key-value pairs.</param>
/// <param name="resolver">The resolver to use.</param>
/// <returns>true if all values were converted; false otherwise.</returns>
public bool TryConvertValues(IEdmEntityType targetEntityType, out IEnumerable <KeyValuePair <string, object> > keyPairs, ODataUriResolver resolver)
{
Debug.Assert(!this.IsEmpty, "!this.IsEmpty -- caller should check");
IList <IEdmStructuralProperty> keyProperties = targetEntityType.Key().ToList();
Debug.Assert(keyProperties.Count == this.ValueCount || resolver.GetType() != typeof(ODataUriResolver), "type.KeyProperties.Count == this.ValueCount -- will change with containment");
if (this.NamedValues != null)
{
keyPairs = resolver.ResolveKeys(targetEntityType, this.NamedValues, this.ConvertValueWrapper);
}
else
{
Debug.Assert(this.positionalValues != null, "positionalValues != null -- otherwise this is Empty");
Debug.Assert(this.PositionalValues.Count == keyProperties.Count || resolver.GetType() != typeof(ODataUriResolver), "Count of positional values does not match.");
keyPairs = resolver.ResolveKeys(targetEntityType, this.PositionalValues, this.ConvertValueWrapper);
}
return(true);
}
internal static bool ResolveOperationFromList(string identifier, IEnumerable <string> parameterNames, IEdmType bindingType, IEdmModel model, out IEdmOperation matchingOperation, ODataUriResolver resolver)
{
// TODO: update code that is duplicate between operation and operation import, add more tests.
// If the previous segment is an open type, the service action name is required to be fully qualified or else we always treat it as an open property name.
if (bindingType != null)
{
// TODO: look up actual container names here?
// When using extension, there may be function call with unqualified name. So loose the restriction here.
if (bindingType.IsOpenType() && !identifier.Contains(".") && resolver.GetType() == typeof(ODataUriResolver))
{
matchingOperation = null;
return(false);
}
}
IList <IEdmOperation> candidateMatchingOperations = null;
// The extension method FindBoundOperations & FindOperations call IEdmModel.FindDeclaredBoundOperations which can be implemented by anyone and it could throw any type of exception
// so catching all of them and simply putting it in the inner exception.
try
{
if (bindingType != null)
{
candidateMatchingOperations = resolver.ResolveBoundOperations(model, identifier, bindingType).ToList();
}
else
{
candidateMatchingOperations = resolver.ResolveUnboundOperations(model, identifier).ToList();
}
}
catch (Exception exc)
{
if (ExceptionUtils.IsCatchableExceptionType(exc))
{
throw new ODataException(ODataErrorStrings.FunctionOverloadResolver_FoundInvalidOperation(identifier), exc);
}
throw;
}
IList <IEdmAction> foundActionsWhenLookingForFunctions = new List <IEdmAction>();
int parameterNamesCount = parameterNames.Count();
if (bindingType != null)
{
candidateMatchingOperations = candidateMatchingOperations.EnsureOperationsBoundWithBindingParameter().ToList();
}
// If the number of parameters > 0 then this has to be a function as actions can't have parameters on the uri only in the payload. Filter further by parameters in this case, otherwise don't.
if (parameterNamesCount > 0)
{
// can only be a function as only functions have parameters on the uri.
candidateMatchingOperations = candidateMatchingOperations.RemoveActions(out foundActionsWhenLookingForFunctions).FilterFunctionsByParameterNames(parameterNames, resolver.EnableCaseInsensitive).Cast <IEdmOperation>().ToList();
}
else if (bindingType != null)
{
// Filter out functions with more than one parameter. Actions should not be filtered as the parameters are in the payload not the uri
candidateMatchingOperations = candidateMatchingOperations.Where(o => (o.IsFunction() && o.Parameters.Count() == 1) || o.IsAction()).ToList();
}
else
{
// Filter out functions with any parameters
candidateMatchingOperations = candidateMatchingOperations.Where(o => (o.IsFunction() && !o.Parameters.Any()) || o.IsAction()).ToList();
}
// Only filter if there is more than one and its needed.
if (candidateMatchingOperations.Count > 1)
{
candidateMatchingOperations = candidateMatchingOperations.FilterBoundOperationsWithSameTypeHierarchyToTypeClosestToBindingType(bindingType).ToList();
}
// If any of the things returned are an action, it better be the only thing returned, and there can't be parameters in the URL
if (candidateMatchingOperations.Any(f => f.IsAction()))
{
if (candidateMatchingOperations.Count > 1)
{
if (candidateMatchingOperations.Any(o => o.IsFunction()))
{
throw new ODataException(ODataErrorStrings.FunctionOverloadResolver_MultipleOperationOverloads(identifier));
}
else
{
throw new ODataException(ODataErrorStrings.FunctionOverloadResolver_MultipleActionOverloads(identifier));
}
}
if (parameterNames.Count() != 0)
{
throw ExceptionUtil.CreateBadRequestError(ODataErrorStrings.RequestUriProcessor_SegmentDoesNotSupportKeyPredicates(identifier));
}
matchingOperation = candidateMatchingOperations.Single();
return(true);
}
if (foundActionsWhenLookingForFunctions.Count > 0)
{
throw ExceptionUtil.CreateBadRequestError(ODataErrorStrings.RequestUriProcessor_SegmentDoesNotSupportKeyPredicates(identifier));
}
if (candidateMatchingOperations.Count > 1)
{
throw new ODataException(ODataErrorStrings.FunctionOverloadResolver_NoSingleMatchFound(identifier, string.Join(",", parameterNames.ToArray())));
}
matchingOperation = candidateMatchingOperations.SingleOrDefault();
return(matchingOperation != null);
}