/// <summary>
/// Initializes a new instance of <see cref="EdmFunctionParameterFacade"/> class.
/// </summary>
/// <param name="serverFunctionParameter">The function parameter from the server-side model to wrap.</param>
/// <param name="declaringFunctionFacade">The function import facade which this parameter belongs to.</param>
/// <param name="modelFacade">The edm model facade this function import belongs to.</param>
public EdmFunctionParameterFacade(IEdmFunctionParameter serverFunctionParameter, EdmFunctionImportFacade declaringFunctionFacade, EdmModelFacade modelFacade)
{
Debug.Assert(serverFunctionParameter != null, "serverFunctionParameter != null");
Debug.Assert(declaringFunctionFacade != null, "declaringFunctionFacade != null");
Debug.Assert(modelFacade != null, "modelFacade != null");
this.serverFunctionParameter = serverFunctionParameter;
this.declaringFunction = declaringFunctionFacade;
this.type = modelFacade.GetOrCreateEntityTypeFacadeOrReturnNonEntityServerType(serverFunctionParameter.Type.Definition).ToEdmTypeReference(serverFunctionParameter.Type.IsNullable);
}
/// <summary>
/// Returns true if the compared function parameter is semantically equivalent to this function parameter.
/// </summary>
/// <param name="thisParameter">Reference to the calling object.</param>
/// <param name="otherParameter">Function parameter being compared to.</param>
/// <returns>Equivalence of the two function parameters.</returns>
private static bool IsEquivalentTo(this IEdmFunctionParameter thisParameter, IEdmFunctionParameter otherParameter)
{
if (thisParameter == otherParameter)
{
return(true);
}
if (thisParameter == null || otherParameter == null)
{
return(false);
}
return(thisParameter.Name == otherParameter.Name &&
thisParameter.Mode == otherParameter.Mode &&
thisParameter.Type.IsEquivalentTo(otherParameter.Type));
}
private void WriteOperationParameter(ODataParameterWriter parameterWriter, IEdmFunctionParameter operationParameter, string paramName, object paramValue)
{
if (operationParameter.Type.Definition.TypeKind == EdmTypeKind.Collection)
{
var collectionWriter = parameterWriter.CreateCollectionWriter(paramName);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
}
else
{
parameterWriter.WriteValue(paramName, paramValue);
}
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
// Create the correct resource type;
ODataActionParameters payload = new ODataActionParameters();
IEdmFunctionImport action = GetFunctionImport(readContext);
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmFunctionParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
payload[parameterName] = Convert(reader.Value, parameter.Type, readContext);
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
payload[parameterName] = Convert(reader.CreateCollectionReader(), collectionType, readContext);
break;
default:
break;
}
}
return(payload);
}
internal static bool IsFunctionSignatureEquivalentTo(this IEdmFunctionBase thisFunction, IEdmFunctionBase otherFunction)
{
bool flag;
if (thisFunction != otherFunction)
{
if (thisFunction.Name == otherFunction.Name)
{
if (thisFunction.ReturnType.IsEquivalentTo(otherFunction.ReturnType))
{
IEnumerator <IEdmFunctionParameter> enumerator = otherFunction.Parameters.GetEnumerator();
IEnumerator <IEdmFunctionParameter> enumerator1 = thisFunction.Parameters.GetEnumerator();
using (enumerator1)
{
while (enumerator1.MoveNext())
{
IEdmFunctionParameter current = enumerator1.Current;
enumerator.MoveNext();
if (current.IsEquivalentTo(enumerator.Current))
{
continue;
}
flag = false;
return(flag);
}
return(true);
}
return(flag);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(true);
}
}
/// <summary>
/// Generates an action link following the OData URL conventions for the action <paramref name="action"/> and bound to the entity
/// represented by <paramref name="entityContext"/>.
/// </summary>
/// <param name="entityContext">The <see cref="EntityInstanceContext"/> representing the entity for which the action link needs to be generated.</param>
/// <param name="action">The action for which the action link needs to be generated.</param>
/// <returns>The generated action link following OData URL conventions.</returns>
public static Uri GenerateActionLink(this EntityInstanceContext entityContext, IEdmFunctionBase action)
{
if (entityContext == null)
{
throw Error.ArgumentNull("entityContext");
}
if (action == null)
{
throw Error.ArgumentNull("action");
}
IEdmFunctionParameter bindingParameter = action.Parameters.FirstOrDefault();
if (bindingParameter == null || !bindingParameter.Type.IsEntity())
{
throw Error.Argument("action", SRResources.ActionNotBoundToEntity, action.Name);
}
return(GenerateActionLink(entityContext, bindingParameter.Type.FullName(), action.Name));
}
private static bool CanBindTo(this IEdmFunctionImport function, IEdmCollectionType collection)
{
if (function == null)
{
throw Error.ArgumentNull("function");
}
if (collection == null)
{
throw Error.ArgumentNull("collection");
}
if (!function.IsBindable)
{
return(false);
}
// The binding parameter is the first parameter by convention
IEdmFunctionParameter bindingParameter = function.Parameters.FirstOrDefault();
if (bindingParameter == null)
{
return(false);
}
IEdmCollectionType bindingParameterType = bindingParameter.Type.Definition as IEdmCollectionType;
if (bindingParameterType == null)
{
return(false);
}
IEdmEntityType bindingParameterElementType = bindingParameterType.ElementType.Definition as IEdmEntityType;
IEdmEntityType entity = collection.ElementType.Definition as IEdmEntityType;
if (bindingParameterElementType == null || entity == null)
{
return(false);
}
return(entity.IsOrInheritsFrom(bindingParameterElementType));
}
private static bool TryParseFunctionParameters <TParam>(ICollection <FunctionParameterToken> splitParameters, ODataUriParserConfiguration configuration, IEdmFunctionImport functionImport, Func <string, object, TParam> createParameter, out ICollection <TParam> parsedParameters)
{
Debug.Assert(splitParameters != null, "splitParameters != null");
Debug.Assert(createParameter != null, "createParameter != null");
Debug.Assert(configuration != null, "configuration != null");
Debug.Assert(functionImport != null, "functionImport != null");
parsedParameters = new List <TParam>(splitParameters.Count);
foreach (var splitParameter in splitParameters)
{
TParam parameter;
IEdmTypeReference expectedType = null;
IEdmFunctionParameter edmFunctionParameter = null;
try
{
edmFunctionParameter = functionImport.FindParameter(splitParameter.ParameterName);
}
catch (InvalidOperationException ex)
{
// this can throw an exception if there are multiple parameters with the same name..
// catch that exception and throw something more sane.
throw new ODataException(ODataErrorStrings.FunctionCallParser_DuplicateParameterName, ex);
}
Debug.Assert(edmFunctionParameter != null, "At this point we should know that the parameter names match the given function import.");
expectedType = edmFunctionParameter.Type;
if (!TryCreateParameter(splitParameter, configuration, expectedType, o => createParameter(splitParameter.ParameterName, o), out parameter))
{
return(false);
}
parsedParameters.Add(parameter);
}
return(true);
}
private void WriteOperationParameter(ODataParameterWriter parameterWriter, IEdmFunctionParameter operationParameter, string paramName, object paramValue)
{
switch (operationParameter.Type.Definition.TypeKind)
{
case EdmTypeKind.Primitive:
case EdmTypeKind.Complex:
var value = GetPropertyValue(operationParameter.Type, paramValue);
parameterWriter.WriteValue(paramName, value);
break;
case EdmTypeKind.Collection:
var collectionWriter = parameterWriter.CreateCollectionWriter(paramName);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
break;
default:
throw new NotSupportedException(string.Format("Unable to write action parameter of a type {0}", operationParameter.Type.Definition.TypeKind));
}
}
private static string ParameterAsXml(IEdmFunctionParameter parameter)
{
return(parameter.Name);
}
private static bool IsEquivalentTo(this IEdmFunctionParameter thisParameter, IEdmFunctionParameter otherParameter)
{
if (thisParameter != otherParameter)
{
if (thisParameter == null || otherParameter == null)
{
return false;
}
else
{
if (!(thisParameter.Name == otherParameter.Name) || thisParameter.Mode != otherParameter.Mode)
{
return false;
}
else
{
return thisParameter.Type.IsEquivalentTo(otherParameter.Type);
}
}
}
else
{
return true;
}
}
/// <summary>
/// Returns true if the compared function parameter is semantically equivalent to this function parameter.
/// </summary>
/// <param name="thisParameter">Reference to the calling object.</param>
/// <param name="otherParameter">Function parameter being compared to.</param>
/// <returns>Equivalence of the two function parameters.</returns>
private static bool IsEquivalentTo(this IEdmFunctionParameter thisParameter, IEdmFunctionParameter otherParameter)
{
if (thisParameter == otherParameter)
{
return true;
}
if (thisParameter == null || otherParameter == null)
{
return false;
}
return thisParameter.Name == otherParameter.Name &&
thisParameter.Mode == otherParameter.Mode &&
thisParameter.Type.IsEquivalentTo(otherParameter.Type);
}
/// <summary>
/// Adds a parameter to this function (as the last parameter).
/// </summary>
/// <param name="parameter">The parameter being added.</param>
public void AddParameter(IEdmFunctionParameter parameter)
{
EdmUtil.CheckArgumentNull(parameter, "parameter");
this.parameters.Add(parameter);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmParameterReferenceExpression"/> class.
/// </summary>
/// <param name="referencedParameter">Referenced parameter</param>
public EdmParameterReferenceExpression(IEdmFunctionParameter referencedParameter)
{
EdmUtil.CheckArgumentNull(referencedParameter, "referencedParameter");
this.referencedParameter = referencedParameter;
}
/// <summary> /// Gets the function parameter type. /// </summary> /// <param name="functionParameter">The function parameter to get the type for.</param> /// <returns>The <see cref="IEdmTypeReference"/> representing the type on the function parameter; or null if no such type could be found.</returns> internal abstract IEdmTypeReference GetParameterType(IEdmFunctionParameter functionParameter);
private async Task WriteOperationParameterAsync(ODataParameterWriter parameterWriter, IEdmFunctionParameter operationParameter, string paramName, object paramValue)
{
switch (operationParameter.Type.Definition.TypeKind)
{
case EdmTypeKind.Primitive:
case EdmTypeKind.Complex:
var value = GetPropertyValue(operationParameter.Type, paramValue);
await parameterWriter.WriteValueAsync(paramName, value).ConfigureAwait(false);
break;
case EdmTypeKind.Collection:
var collectionWriter = await parameterWriter.CreateCollectionWriterAsync(paramName).ConfigureAwait(false);
await collectionWriter.WriteStartAsync(new ODataCollectionStart()).ConfigureAwait(false);
foreach (var item in paramValue as IEnumerable)
{
await collectionWriter.WriteItemAsync(item).ConfigureAwait(false);
}
await collectionWriter.WriteEndAsync().ConfigureAwait(false);
break;
default:
throw new NotSupportedException(string.Format("Unable to write action parameter of a type {0}", operationParameter.Type.Definition.TypeKind));
}
}
public static IEdmTypeReference GetOperationParameterType(IEdmFunctionParameter serviceOperationParameter)
{
return(serviceOperationParameter.Type);
}
private IEdmVocabularyAnnotatable ComputeTarget()
{
IEdmEntityContainer edmEntityContainer;
if (this.targetContext == null)
{
string target = this.annotationsContext.Annotations.Target;
char[] chrArray = new char[1];
chrArray[0] = '/';
string[] strArrays = target.Split(chrArray);
int num = strArrays.Count <string>();
if (num != 1)
{
if (num != 2)
{
if (num == 3)
{
edmEntityContainer = this.Model.FindEntityContainer(strArrays[0]);
if (edmEntityContainer != null)
{
IEdmEntityContainer edmEntityContainer1 = edmEntityContainer;
IEdmFunctionImport edmFunctionImport = this.FindParameterizedFunction <IEdmFunctionImport>(strArrays[1], new Func <string, IEnumerable <IEdmFunctionImport> >(edmEntityContainer1.FindFunctionImports), new Func <IEnumerable <IEdmFunctionImport>, IEdmFunctionImport>(this.CreateAmbiguousFunctionImport));
if (edmFunctionImport != null)
{
IEdmFunctionParameter edmFunctionParameter = edmFunctionImport.FindParameter(strArrays[2]);
if (edmFunctionParameter == null)
{
return(new UnresolvedParameter(edmFunctionImport, strArrays[1], base.Location));
}
else
{
return(edmFunctionParameter);
}
}
}
}
EdmError[] edmError = new EdmError[1];
edmError[0] = new EdmError(base.Location, EdmErrorCode.ImpossibleAnnotationsTarget, Strings.CsdlSemantics_ImpossibleAnnotationsTarget(target));
return(new BadElement(edmError));
}
else
{
edmEntityContainer = this.schema.FindEntityContainer(strArrays[0]);
if (edmEntityContainer == null)
{
IEdmStructuredType edmStructuredType = this.schema.FindType(strArrays[0]) as IEdmStructuredType;
if (edmStructuredType == null)
{
IEdmFunction edmFunction = this.FindParameterizedFunction <IEdmFunction>(strArrays[0], new Func <string, IEnumerable <IEdmFunction> >(this.Schema.FindFunctions), new Func <IEnumerable <IEdmFunction>, IEdmFunction>(this.CreateAmbiguousFunction));
if (edmFunction == null)
{
return(new UnresolvedProperty(new UnresolvedEntityType(this.Schema.UnresolvedName(strArrays[0]), base.Location), strArrays[1], base.Location));
}
else
{
IEdmFunctionParameter edmFunctionParameter1 = edmFunction.FindParameter(strArrays[1]);
if (edmFunctionParameter1 == null)
{
return(new UnresolvedParameter(edmFunction, strArrays[1], base.Location));
}
else
{
return(edmFunctionParameter1);
}
}
}
else
{
IEdmProperty edmProperty = edmStructuredType.FindProperty(strArrays[1]);
if (edmProperty == null)
{
return(new UnresolvedProperty(edmStructuredType, strArrays[1], base.Location));
}
else
{
return(edmProperty);
}
}
}
else
{
IEdmEntityContainerElement edmEntityContainerElement = edmEntityContainer.FindEntitySet(strArrays[1]);
if (edmEntityContainerElement == null)
{
IEdmEntityContainer edmEntityContainer2 = edmEntityContainer;
IEdmFunctionImport edmFunctionImport1 = this.FindParameterizedFunction <IEdmFunctionImport>(strArrays[1], new Func <string, IEnumerable <IEdmFunctionImport> >(edmEntityContainer2.FindFunctionImports), new Func <IEnumerable <IEdmFunctionImport>, IEdmFunctionImport>(this.CreateAmbiguousFunctionImport));
if (edmFunctionImport1 == null)
{
return(new UnresolvedEntitySet(strArrays[1], edmEntityContainer, base.Location));
}
else
{
return(edmFunctionImport1);
}
}
else
{
return(edmEntityContainerElement);
}
}
}
}
else
{
string str = strArrays[0];
IEdmSchemaType edmSchemaType = this.schema.FindType(str);
if (edmSchemaType == null)
{
IEdmValueTerm edmValueTerm = this.schema.FindValueTerm(str);
if (edmValueTerm == null)
{
IEdmFunction edmFunction1 = this.FindParameterizedFunction <IEdmFunction>(str, new Func <string, IEnumerable <IEdmFunction> >(this.Schema.FindFunctions), new Func <IEnumerable <IEdmFunction>, IEdmFunction>(this.CreateAmbiguousFunction));
if (edmFunction1 == null)
{
edmEntityContainer = this.schema.FindEntityContainer(str);
if (edmEntityContainer == null)
{
return(new UnresolvedType(this.Schema.UnresolvedName(strArrays[0]), base.Location));
}
else
{
return(edmEntityContainer);
}
}
else
{
return(edmFunction1);
}
}
else
{
return(edmValueTerm);
}
}
else
{
return(edmSchemaType);
}
}
}
else
{
return(this.targetContext);
}
}
private async Task WriteOperationParameterAsync(ODataParameterWriter parameterWriter, IEdmFunctionParameter operationParameter, string paramName, object paramValue)
{
if (operationParameter.Type.Definition.TypeKind == EdmTypeKind.Collection)
{
var collectionWriter = await parameterWriter.CreateCollectionWriterAsync(paramName);
await collectionWriter.WriteStartAsync(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
await collectionWriter.WriteItemAsync(item);
}
await collectionWriter.WriteEndAsync();
}
else
{
await parameterWriter.WriteValueAsync(paramName, paramValue);
}
}
private void WriteOperationParameter(ODataParameterWriter parameterWriter, IEdmFunctionParameter operationParameter, string paramName, object paramValue)
{
if (operationParameter.Type.Definition.TypeKind == EdmTypeKind.Collection)
{
var collectionWriter = parameterWriter.CreateCollectionWriter(paramName);
collectionWriter.WriteStart(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
collectionWriter.WriteItem(item);
}
collectionWriter.WriteEnd();
}
else
{
parameterWriter.WriteValue(paramName, paramValue);
}
}
private IEnumerable <IEdmFunctionBase> FindParameterizedFunctionFromList(IEnumerable <IEdmFunctionBase> functions, string[] parameters)
{
bool flag;
bool flag1;
bool flag2;
List <IEdmFunctionBase> edmFunctionBases = new List <IEdmFunctionBase>();
foreach (IEdmFunctionBase parameter in functions)
{
if (parameter.Parameters.Count <IEdmFunctionParameter>() != parameters.Count <string>())
{
continue;
}
bool flag3 = true;
IEnumerator <string> enumerator = ((IEnumerable <string>)parameters).GetEnumerator();
IEnumerator <IEdmFunctionParameter> enumerator1 = parameter.Parameters.GetEnumerator();
using (enumerator1)
{
do
{
if (!enumerator1.MoveNext())
{
break;
}
IEdmFunctionParameter edmFunctionParameter = enumerator1.Current;
enumerator.MoveNext();
char[] chrArray = new char[2];
chrArray[0] = '(';
chrArray[1] = ')';
string[] strArrays = enumerator.Current.Split(chrArray);
string str = strArrays[0];
string str1 = str;
if (str != null)
{
if (str1 == "Collection")
{
if (!edmFunctionParameter.Type.IsCollection())
{
flag1 = false;
}
else
{
flag1 = this.Schema.FindType(strArrays[1]).IsEquivalentTo(edmFunctionParameter.Type.AsCollection().ElementType().Definition);
}
flag3 = flag1;
continue;
}
else
{
if (str1 == "Ref")
{
if (!edmFunctionParameter.Type.IsEntityReference())
{
flag2 = false;
}
else
{
flag2 = this.Schema.FindType(strArrays[1]).IsEquivalentTo(edmFunctionParameter.Type.AsEntityReference().EntityType());
}
flag3 = flag2;
continue;
}
}
}
if (EdmCoreModel.Instance.FindDeclaredType(enumerator.Current).IsEquivalentTo(edmFunctionParameter.Type.Definition))
{
flag = true;
}
else
{
flag = this.Schema.FindType(enumerator.Current).IsEquivalentTo(edmFunctionParameter.Type.Definition);
}
flag3 = flag;
}while (flag3);
}
if (!flag3)
{
continue;
}
edmFunctionBases.Add(parameter);
}
return(edmFunctionBases);
}
private async Task WriteOperationParameterAsync(ODataParameterWriter parameterWriter, IEdmFunctionParameter operationParameter, string paramName, object paramValue)
{
if (operationParameter.Type.Definition.TypeKind == EdmTypeKind.Collection)
{
var collectionWriter = await parameterWriter.CreateCollectionWriterAsync(paramName);
await collectionWriter.WriteStartAsync(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
await collectionWriter.WriteItemAsync(item);
}
await collectionWriter.WriteEndAsync();
}
else
{
await parameterWriter.WriteValueAsync(paramName, paramValue);
}
}
/// <summary>
/// Selects the action for OData requests.
/// </summary>
/// <param name="odataPath">The OData path.</param>
/// <param name="controllerContext">The controller context.</param>
/// <param name="actionMap">The action map.</param>
/// <returns>
/// <c>null</c> if the request isn't handled by this convention; otherwise, the name of the selected action
/// </returns>
public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup <string, HttpActionDescriptor> actionMap)
{
if (odataPath == null)
{
throw Error.ArgumentNull("odataPath");
}
if (controllerContext == null)
{
throw Error.ArgumentNull("controllerContext");
}
if (actionMap == null)
{
throw Error.ArgumentNull("actionMap");
}
if (controllerContext.Request.Method == HttpMethod.Post)
{
if (odataPath.PathTemplate == "~/entityset/key/action" ||
odataPath.PathTemplate == "~/entityset/key/cast/action")
{
ActionPathSegment actionSegment = odataPath.Segments.Last() as ActionPathSegment;
IEdmFunctionImport action = actionSegment.Action;
// The binding parameter is the first parameter by convention
IEdmFunctionParameter bindingParameter = action.Parameters.FirstOrDefault();
if (action.IsBindable && bindingParameter != null)
{
IEdmEntityType bindingParameterType = bindingParameter.Type.Definition as IEdmEntityType;
if (bindingParameterType != null)
{
KeyValuePathSegment keyValueSegment = odataPath.Segments[1] as KeyValuePathSegment;
controllerContext.RouteData.Values.Add(ODataRouteConstants.Key, keyValueSegment.Value);
// e.g. Try ActionOnBindingParameterType first, then fallback on Action action name
string actionOnBindingTypeActionName = action.Name + "On" + bindingParameterType.Name;
return(actionMap.Contains(actionOnBindingTypeActionName) ? actionOnBindingTypeActionName : action.Name);
}
}
}
else if (odataPath.PathTemplate == "~/entityset/action" ||
odataPath.PathTemplate == "~/entityset/cast/action")
{
ActionPathSegment actionSegment = odataPath.Segments.Last() as ActionPathSegment;
IEdmFunctionImport action = actionSegment.Action;
// The binding parameter is the first parameter by convention
IEdmFunctionParameter bindingParameter = action.Parameters.FirstOrDefault();
if (action.IsBindable && bindingParameter != null)
{
IEdmCollectionType bindingParameterType = bindingParameter.Type.Definition as IEdmCollectionType;
if (bindingParameterType != null)
{
// e.g. Try ActionOnBindingParameterType first, then fallback on Action action name
IEdmEntityType elementType = bindingParameterType.ElementType.Definition as IEdmEntityType;
string actionOnBindingTypeActionName = action.Name + "OnCollectionOf" + elementType.Name;
return(actionMap.Contains(actionOnBindingTypeActionName) ? actionOnBindingTypeActionName : action.Name);
}
}
}
}
return(null);
}
public static string FullyQualifiedName(IEdmVocabularyAnnotatable element)
{
IEdmSchemaElement schemaElement = element as IEdmSchemaElement;
if (schemaElement != null)
{
IEdmFunction function = schemaElement as IEdmFunction;
if (function != null)
{
return(ParameterizedName(function));
}
else
{
return(schemaElement.FullName());
}
}
else
{
IEdmEntityContainerElement containerElement = element as IEdmEntityContainerElement;
if (containerElement != null)
{
IEdmFunctionImport functionImport = containerElement as IEdmFunctionImport;
if (functionImport != null)
{
return(functionImport.Container.FullName() + "/" + ParameterizedName(functionImport));
}
else
{
return(containerElement.Container.FullName() + "/" + containerElement.Name);
}
}
else
{
IEdmProperty property = element as IEdmProperty;
if (property != null)
{
IEdmSchemaType declaringSchemaType = property.DeclaringType as IEdmSchemaType;
if (declaringSchemaType != null)
{
string propertyOwnerName = FullyQualifiedName(declaringSchemaType);
if (propertyOwnerName != null)
{
return(propertyOwnerName + "/" + property.Name);
}
}
}
else
{
IEdmFunctionParameter parameter = element as IEdmFunctionParameter;
if (parameter != null)
{
string parameterOwnerName = FullyQualifiedName(parameter.DeclaringFunction);
if (parameterOwnerName != null)
{
return(parameterOwnerName + "/" + parameter.Name);
}
}
}
}
}
return(null);
}
public EdmParameterReferenceExpression(IEdmFunctionParameter referencedParameter)
{
EdmUtil.CheckArgumentNull<IEdmFunctionParameter>(referencedParameter, "referencedParameter");
this.referencedParameter = referencedParameter;
}
private IEdmVocabularyAnnotatable ComputeTarget()
{
if (this.targetContext != null)
{
return(this.targetContext);
}
else
{
Debug.Assert(this.annotationsContext != null, "Annotation must either have a target context or annotations context");
string target = this.annotationsContext.Annotations.Target;
string[] targetSegments = target.Split('/');
int targetSegmentsCount = targetSegments.Count();
IEdmEntityContainer container;
if (targetSegmentsCount == 1)
{
string elementName = targetSegments[0];
IEdmSchemaType type = this.schema.FindType(elementName);
if (type != null)
{
return(type);
}
IEdmValueTerm term = this.schema.FindValueTerm(elementName);
if (term != null)
{
return(term);
}
IEdmFunction function = this.FindParameterizedFunction(elementName, this.Schema.FindFunctions, this.CreateAmbiguousFunction);
if (function != null)
{
return(function);
}
container = this.schema.FindEntityContainer(elementName);
if (container != null)
{
return(container);
}
return(new UnresolvedType(this.Schema.UnresolvedName(targetSegments[0]), this.Location));
}
if (targetSegmentsCount == 2)
{
container = this.schema.FindEntityContainer(targetSegments[0]);
if (container != null)
{
IEdmEntityContainerElement containerElement = container.FindEntitySet(targetSegments[1]);
if (containerElement != null)
{
return(containerElement);
}
IEdmFunctionImport functionImport = this.FindParameterizedFunction(targetSegments[1], container.FindFunctionImports, this.CreateAmbiguousFunctionImport);
if (functionImport != null)
{
return(functionImport);
}
return(new UnresolvedEntitySet(targetSegments[1], container, this.Location));
}
IEdmStructuredType type = this.schema.FindType(targetSegments[0]) as IEdmStructuredType;
if (type != null)
{
IEdmProperty property = type.FindProperty(targetSegments[1]);
if (property != null)
{
return(property);
}
return(new UnresolvedProperty(type, targetSegments[1], this.Location));
}
IEdmFunction function = this.FindParameterizedFunction(targetSegments[0], this.Schema.FindFunctions, this.CreateAmbiguousFunction);
if (function != null)
{
IEdmFunctionParameter parameter = function.FindParameter(targetSegments[1]);
if (parameter != null)
{
return(parameter);
}
return(new UnresolvedParameter(function, targetSegments[1], this.Location));
}
return(new UnresolvedProperty(new UnresolvedEntityType(this.Schema.UnresolvedName(targetSegments[0]), this.Location), targetSegments[1], this.Location));
}
if (targetSegmentsCount == 3)
{
container = this.Model.FindEntityContainer(targetSegments[0]);
if (container != null)
{
IEdmFunctionImport functionImport = this.FindParameterizedFunction(targetSegments[1], container.FindFunctionImports, this.CreateAmbiguousFunctionImport);
if (functionImport != null)
{
IEdmFunctionParameter parameter = functionImport.FindParameter(targetSegments[2]);
if (parameter != null)
{
return(parameter);
}
return(new UnresolvedParameter(functionImport, targetSegments[1], this.Location));
}
}
}
return(new BadElement(new EdmError[] { new EdmError(this.Location, EdmErrorCode.ImpossibleAnnotationsTarget, Edm.Strings.CsdlSemantics_ImpossibleAnnotationsTarget(target)) }));
}
}
internal override IEdmTypeReference GetParameterType(IEdmFunctionParameter functionParameter)
{
DebugUtils.CheckNoExternalCallers();
return(functionParameter == null ? null : functionParameter.Type);
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmFunctionImport action = GetFunctionImport(readContext);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmFunctionParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = ODataCollectionDeserializer.ReadCollection(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = DeserializerProvider.GetEdmTypeDeserializer(collectionType) as ODataCollectionDeserializer;
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
default:
break;
}
}
return(payload);
}
protected virtual void ProcessFunctionParameter(IEdmFunctionParameter parameter)
{
this.ProcessVocabularyAnnotatable(parameter);
this.ProcessNamedElement(parameter);
this.VisitTypeReference(parameter.Type);
}
public static string FullyQualifiedName(IEdmVocabularyAnnotatable element)
{
IEdmSchemaElement edmSchemaElement = element as IEdmSchemaElement;
if (edmSchemaElement == null)
{
IEdmEntityContainerElement edmEntityContainerElement = element as IEdmEntityContainerElement;
if (edmEntityContainerElement == null)
{
IEdmProperty edmProperty = element as IEdmProperty;
if (edmProperty == null)
{
IEdmFunctionParameter edmFunctionParameter = element as IEdmFunctionParameter;
if (edmFunctionParameter != null)
{
string str = EdmUtil.FullyQualifiedName(edmFunctionParameter.DeclaringFunction);
if (str != null)
{
return(string.Concat(str, "/", edmFunctionParameter.Name));
}
}
}
else
{
IEdmSchemaType declaringType = edmProperty.DeclaringType as IEdmSchemaType;
if (declaringType != null)
{
string str1 = EdmUtil.FullyQualifiedName(declaringType);
if (str1 != null)
{
return(string.Concat(str1, "/", edmProperty.Name));
}
}
}
return(null);
}
else
{
IEdmFunctionImport edmFunctionImport = edmEntityContainerElement as IEdmFunctionImport;
if (edmFunctionImport == null)
{
return(string.Concat(edmEntityContainerElement.Container.FullName(), "/", edmEntityContainerElement.Name));
}
else
{
return(string.Concat(edmFunctionImport.Container.FullName(), "/", EdmUtil.ParameterizedName(edmFunctionImport)));
}
}
}
else
{
IEdmFunction edmFunction = edmSchemaElement as IEdmFunction;
if (edmFunction == null)
{
return(edmSchemaElement.FullName());
}
else
{
return(EdmUtil.ParameterizedName(edmFunction));
}
}
}
/// <summary>
/// Adds a parameter to this function (as the last parameter).
/// </summary>
/// <param name="parameter">The parameter being added.</param>
public void AddParameter(IEdmFunctionParameter parameter)
{
EdmUtil.CheckArgumentNull(parameter, "parameter");
this.parameters.Add(parameter);
}
