/// <summary>
/// Initializes a new instance of the <see cref="ActionPathSegment" /> class for actions at the root of the path.
/// </summary>
/// <param name="action">The action being invoked.</param>
public ActionPathSegment(IEdmFunctionImport action)
{
if (action == null)
{
throw Error.ArgumentNull("action");
}
Initialize(action);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonOutputContext">The output context to write to.</param>
/// <param name="functionImport">The function import whose parameters will be written.</param>
internal ODataJsonParameterWriter(ODataJsonOutputContext jsonOutputContext, IEdmFunctionImport functionImport)
: base(jsonOutputContext, functionImport)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(jsonOutputContext != null, "jsonOutputContext != null");
this.jsonOutputContext = jsonOutputContext;
this.jsonPropertyAndValueSerializer = new ODataJsonPropertyAndValueSerializer(this.jsonOutputContext);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionPathSegment" /> class.
/// </summary>
/// <param name="previous">The previous segment in the path.</param>
/// <param name="action">The action being invoked.</param>
public ActionPathSegment(ODataPathSegment previous, IEdmFunctionImport action)
: base(previous)
{
if (action == null)
{
throw Error.ArgumentNull("action");
}
Initialize(action);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionPathSegment" /> class.
/// </summary>
/// <param name="action">The action being invoked.</param>
public ActionPathSegment(IEdmFunctionImport action)
{
if (action == null)
{
throw Error.ArgumentNull("action");
}
Action = action;
ActionName = Action.Container.FullName() + "." + Action.Name;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="jsonInputContext">The input to read the payload from.</param>
/// <param name="functionImport">The function import whose parameters are being read.</param>
internal ODataJsonParameterReader(ODataJsonInputContext jsonInputContext, IEdmFunctionImport functionImport)
: base(jsonInputContext, functionImport)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(jsonInputContext != null, "jsonInputContext != null");
Debug.Assert(jsonInputContext.ReadingResponse == false, "jsonInputContext.ReadingResponse == false");
this.jsonInputContext = jsonInputContext;
this.jsonPropertyAndValueDeserializer = new ODataJsonPropertyAndValueDeserializer(jsonInputContext);
Debug.Assert(this.jsonInputContext.Model.IsUserModel(), "this.jsonInputContext.Model.IsUserModel()");
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionPathSegment" /> class.
/// </summary>
/// <param name="function">The function being invoked.</param>
/// <param name="model">The edm model containing the function.</param>
/// <param name="parameterValues">The raw parameter values indexed by the parameter names.</param>
public FunctionPathSegment(IEdmFunctionImport function, IEdmModel model, IDictionary<string, string> parameterValues)
{
if (function == null)
{
throw Error.ArgumentNull("function");
}
Function = function;
FunctionName = Function.Container.FullName() + "." + Function.Name;
_edmModel = model;
Values = parameterValues ?? new Dictionary<string, string>();
}
private void Initialize(IEdmFunctionImport action)
{
IEdmTypeReference returnType = action.ReturnType;
EdmType = returnType == null ? null : returnType.Definition;
IEdmEntitySet functionEntitySet = null;
if (action.TryGetStaticEntitySet(out functionEntitySet))
{
EntitySet = functionEntitySet;
}
Action = action;
}
public static bool IsAlwaysBindable(this IEdmModel model, IEdmFunctionImport functionImport)
{
bool flag;
ExceptionUtils.CheckArgumentNotNull<IEdmModel>(model, "model");
ExceptionUtils.CheckArgumentNotNull<IEdmFunctionImport>(functionImport, "functionImport");
if (!TryGetBooleanAnnotation(model, functionImport, "IsAlwaysBindable", out flag))
{
return false;
}
if (!functionImport.IsBindable && flag)
{
throw new ODataException(Microsoft.Data.OData.Strings.ODataUtils_UnexpectedIsAlwaysBindableAnnotationInANonBindableFunctionImport);
}
return flag;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnboundFunctionPathSegment" /> class.
/// </summary>
/// <param name="function">The function being invoked.</param>
/// <param name="model">The edm model containing the function.</param>
/// <param name="parameterValues">The raw parameter values indexed by the parameter names.</param>
public UnboundFunctionPathSegment(IEdmFunctionImport function, IEdmModel model, IDictionary<string, string> parameterValues)
{
if (function == null)
{
throw Error.ArgumentNull("function");
}
if (model == null)
{
throw Error.ArgumentNull("model");
}
Function = function;
FunctionName = Function.Name;
_edmModel = model;
Values = parameterValues ?? new Dictionary<string, string>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionPathSegment" /> class.
/// </summary>
/// <param name="previous">The previous segment in the path.</param>
/// <param name="action">The action being invoked.</param>
public ActionPathSegment(ODataPathSegment previous, IEdmFunctionImport action)
: base(previous)
{
if (action == null)
{
throw Error.ArgumentNull("action");
}
IEdmTypeReference returnType = action.ReturnType;
EdmType = returnType == null ? null : returnType.Definition;
IEdmEntitySet functionEntitySet = null;
if (action.TryGetStaticEntitySet(out functionEntitySet))
{
EntitySet = functionEntitySet;
}
Action = action;
}
public static ActionLinkBuilder GetActionLinkBuilder(this IEdmModel model, IEdmFunctionImport action)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
if (action == null)
{
throw Error.ArgumentNull("action");
}
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue<ActionLinkBuilder>(action);
if (actionLinkBuilder == null)
{
actionLinkBuilder = new ActionLinkBuilder(entityInstanceContext => entityInstanceContext.GenerateActionLink(action), followsConventions: true);
model.SetActionLinkBuilder(action, actionLinkBuilder);
}
return actionLinkBuilder;
}
/// <summary>
/// Initializes a new instance of <see cref="EdmFunctionImportFacade"/> class.
/// </summary>
/// <param name="serverFunctionImport">The function import from the server-side model which we are wrapping.</param>
/// <param name="containerFacade">The edm container facade this function import belongs to.</param>
/// <param name="modelFacade">The edm model facade this function import belongs to.</param>
public EdmFunctionImportFacade(IEdmFunctionImport serverFunctionImport, EdmEntityContainerFacade containerFacade, EdmModelFacade modelFacade)
{
Debug.Assert(serverFunctionImport != null, "serverFunctionImport != null");
Debug.Assert(containerFacade != null, "containerFacade != null");
Debug.Assert(modelFacade != null, "modelFacade != null");
this.serverFunctionImport = serverFunctionImport;
this.containerFacade = containerFacade;
IEdmTypeReference serverReturnTypeReference = serverFunctionImport.ReturnType;
if (serverReturnTypeReference == null)
{
this.returnType = null;
}
else
{
IEdmType serverReturnType = modelFacade.GetOrCreateEntityTypeFacadeOrReturnNonEntityServerType(serverReturnTypeReference.Definition);
this.returnType = serverReturnType.ToEdmTypeReference(serverReturnTypeReference.IsNullable);
}
this.parameters = serverFunctionImport.Parameters.Select(p => new EdmFunctionParameterFacade(p, this, modelFacade)).ToArray();
}
internal override ODataParameterReader CreateParameterReader(IEdmFunctionImport functionImport)
{
VerifyCanCreateParameterReader(functionImport);
return this.CreateParameterReaderImplementation(functionImport);
}
private static void VerifyCanCreateParameterReader(IEdmFunctionImport functionImport)
{
if (functionImport == null)
{
throw new ArgumentNullException("functionImport", Microsoft.Data.OData.Strings.ODataJsonInputContext_FunctionImportCannotBeNullForCreateParameterReader("functionImport"));
}
}
private ODataParameterReader CreateParameterReaderImplementation(IEdmFunctionImport functionImport)
{
return new ODataJsonParameterReader(this, functionImport);
}
/// <summary>
/// Binds a service operation segment.
/// </summary>
/// <param name="segmentToken">The segment which represents a service operation.</param>
/// <param name="serviceOperation">The service operation to bind.</param>
/// <returns>The bound node.</returns>
private QueryNode BindServiceOperation(SegmentQueryToken segmentToken, IEdmFunctionImport serviceOperation)
{
Debug.Assert(segmentToken != null, "segmentToken != null");
Debug.Assert(serviceOperation != null, "serviceOperation != null");
Debug.Assert(segmentToken.Name == serviceOperation.Name, "The segment represents a different service operation.");
//// This is a metadata copy of the RequestUriProcessor.CreateSegmentForServiceOperation
//// The WCF DS checks the verb in this place, we can't do that here
// All service operations other than those returning IQueryable MUST NOT have () appended to the URI
// V1/V2 behavior: if it's IEnumerable<T>, we do not allow () either, because it's not further composable.
ODataServiceOperationResultKind? resultKind = serviceOperation.GetServiceOperationResultKind(this.model);
if (resultKind != ODataServiceOperationResultKind.QueryWithMultipleResults && segmentToken.NamedValues != null)
{
throw new ODataException(Strings.MetadataBinder_NonQueryableServiceOperationWithKeyLookup(segmentToken.Name));
}
if (!resultKind.HasValue)
{
throw new ODataException(Strings.MetadataBinder_ServiceOperationWithoutResultKind(serviceOperation.Name));
}
IEnumerable<QueryNode> serviceOperationParameters = this.BindServiceOperationParameters(serviceOperation);
switch (resultKind.Value)
{
case ODataServiceOperationResultKind.QueryWithMultipleResults:
if (serviceOperation.ReturnType.TypeKind() != EdmTypeKind.Entity)
{
throw new ODataException(Strings.MetadataBinder_QueryServiceOperationOfNonEntityType(serviceOperation.Name, resultKind.Value.ToString(), serviceOperation.ReturnType.ODataFullName()));
}
CollectionServiceOperationQueryNode collectionServiceOperationQueryNode = new CollectionServiceOperationQueryNode()
{
ServiceOperation = serviceOperation,
Parameters = serviceOperationParameters
};
if (segmentToken.NamedValues != null)
{
return this.BindKeyValues(collectionServiceOperationQueryNode, segmentToken.NamedValues);
}
else
{
return collectionServiceOperationQueryNode;
}
case ODataServiceOperationResultKind.QueryWithSingleResult:
if (!serviceOperation.ReturnType.IsODataEntityTypeKind())
{
throw new ODataException(Strings.MetadataBinder_QueryServiceOperationOfNonEntityType(serviceOperation.Name, resultKind.Value.ToString(), serviceOperation.ReturnType.ODataFullName()));
}
return new SingleValueServiceOperationQueryNode()
{
ServiceOperation = serviceOperation,
Parameters = serviceOperationParameters
};
case ODataServiceOperationResultKind.DirectValue:
if (serviceOperation.ReturnType.IsODataPrimitiveTypeKind())
{
// Direct primitive values are composable, $value is allowed on them.
return new SingleValueServiceOperationQueryNode()
{
ServiceOperation = serviceOperation,
Parameters = serviceOperationParameters
};
}
else
{
// Direct non-primitive values are not composable at all
return new UncomposableServiceOperationQueryNode()
{
ServiceOperation = serviceOperation,
Parameters = serviceOperationParameters
};
}
case ODataServiceOperationResultKind.Enumeration:
case ODataServiceOperationResultKind.Void:
// Enumeration and void service operations are not composable
return new UncomposableServiceOperationQueryNode()
{
ServiceOperation = serviceOperation,
Parameters = serviceOperationParameters
};
default:
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.MetadataBinder_BindServiceOperation));
}
}
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)
{
// The only valid target with three segments is a function parameter.
string containerName = targetSegments[0];
string functionName = targetSegments[1];
string parameterName = targetSegments[2];
container = this.Model.FindEntityContainer(containerName);
if (container != null)
{
IEdmFunctionImport functionImport = this.FindParameterizedFunction(functionName, container.FindFunctionImports, this.CreateAmbiguousFunctionImport);
if (functionImport != null)
{
IEdmFunctionParameter parameter = functionImport.FindParameter(parameterName);
if (parameter != null)
{
return(parameter);
}
return(new UnresolvedParameter(functionImport, parameterName, this.Location));
}
}
string qualifiedFunctionName = containerName + "/" + functionName;
UnresolvedFunction unresolvedFunction = new UnresolvedFunction(qualifiedFunctionName, Edm.Strings.Bad_UnresolvedFunction(qualifiedFunctionName), this.Location);
return(new UnresolvedParameter(unresolvedFunction, parameterName, this.Location));
}
return(new BadElement(new EdmError[] { new EdmError(this.Location, EdmErrorCode.ImpossibleAnnotationsTarget, Edm.Strings.CsdlSemantics_ImpossibleAnnotationsTarget(target)) }));
}
}
public static void SetActionLinkBuilder(this IEdmModel model, IEdmFunctionImport action, ActionLinkBuilder actionLinkBuilder)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
model.SetAnnotationValue(action, actionLinkBuilder);
}
private bool IsFunctionBound(IEdmFunctionImport function, IEdmEntityType entityType)
{
var bindingParameterType = function.Parameters.First().Type;
return (bindingParameterType.Definition == entityType) ||
(bindingParameterType.IsCollection() &&
bindingParameterType.AsCollection().ElementType().Definition == entityType);
}
internal override Task <ODataParameterWriter> CreateODataParameterWriterAsync(IEdmFunctionImport functionImport)
{
return(TaskUtils.GetTaskForSynchronousOperation <ODataParameterWriter>(() => this.CreateODataParameterWriterImplementation(functionImport)));
}
protected virtual void ProcessFunctionImport(IEdmFunctionImport functionImport)
{
this.ProcessEntityContainerElement(functionImport);
}
public Task <ODataParameterReader> CreateODataParameterReaderAsync(IEdmFunctionImport functionImport)
{
this.VerifyCanCreateODataParameterReader(functionImport);
return(this.ReadFromInputAsync <ODataParameterReader>(context => context.CreateParameterReaderAsync(functionImport), new ODataPayloadKind[] { ODataPayloadKind.Parameter }));
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionImportSegmentTemplate" /> class.
/// </summary>
/// <param name="parameters">The function parameter template mappings.The key string is case-sensitive, the value string should wrapper with { and }.</param>
/// <param name="functionImport">The Edm function import.</param>
/// <param name="navigationSource">The target navigation source, it could be null.</param>
public FunctionImportSegmentTemplate(IDictionary <string, string> parameters, IEdmFunctionImport functionImport, IEdmNavigationSource navigationSource)
{
if (parameters == null)
{
throw Error.ArgumentNull(nameof(parameters));
}
FunctionImport = functionImport ?? throw Error.ArgumentNull(nameof(functionImport));
NavigationSource = navigationSource;
// parameters should include all required parameters, but maybe include the optional parameters.
ParameterMappings = functionImport.Function.VerifyAndBuildParameterMappings(parameters);
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionImportSegmentTemplate" /> class.
/// </summary>
/// <param name="functionImport">The Edm function import.</param>
/// <param name="navigationSource">The target navigation source, it could be null.</param>
public FunctionImportSegmentTemplate(IEdmFunctionImport functionImport, IEdmNavigationSource navigationSource)
: this(functionImport.GetFunctionParamterMappings(), functionImport, navigationSource)
{
}
internal override Task<ODataParameterReader> CreateParameterReaderAsync(IEdmFunctionImport functionImport)
{
VerifyCanCreateParameterReader(functionImport);
return TaskUtils.GetTaskForSynchronousOperation<ODataParameterReader>(() => this.CreateParameterReaderImplementation(functionImport));
}
internal override ODataParameterWriter CreateODataParameterWriter(IEdmFunctionImport functionImport)
{
return(this.CreateODataParameterWriterImplementation(functionImport));
}
/// <summary>
/// Tries to parse a collection of function parameters for path.
/// </summary>
/// <param name="splitParameters">The split parameters from the syntactic parsing step.</param>
/// <param name="configuration">The configuration for the URI Parser.</param>
/// <param name="functionImport">The function import for the function whose parameters are being parsed.</param>
/// <param name="parsedParameters">The parameters if they were successfully parsed.</param>
/// <returns>Whether the parameters could be parsed.</returns>
internal static bool TryParseFunctionParameters(ICollection <FunctionParameterToken> splitParameters, ODataUriParserConfiguration configuration, IEdmFunctionImport functionImport, out ICollection <OperationSegmentParameter> parsedParameters)
{
DebugUtils.CheckNoExternalCallers();
return(TryParseFunctionParameters(splitParameters, configuration, functionImport, (paramName, convertedValue) => new OperationSegmentParameter(paramName, convertedValue), out parsedParameters));
}
internal static ActionLinkBuilder GetActionLinkBuilder(this IEdmModel model, IEdmFunctionImport action)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
if (action == null)
{
throw Error.ArgumentNull("action");
}
ActionLinkBuilder annotation = model.GetAnnotationValue<ActionLinkBuilder>(action);
return annotation;
}
internal ODataJsonParameterWriter(ODataJsonOutputContext jsonOutputContext, IEdmFunctionImport functionImport) : base(jsonOutputContext, functionImport)
{
this.jsonOutputContext = jsonOutputContext;
this.jsonPropertyAndValueSerializer = new ODataJsonPropertyAndValueSerializer(this.jsonOutputContext);
}
private void TestWriteFunctionImportElementHeaderMethod(IEdmFunctionImport functionImport, string expected)
{
this.EdmModelCsdlSchemaWriterTest(writer => writer.WriteFunctionImportElementHeader(functionImport), expected);
}
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);
}
/// <summary>
/// Binds the service operation parameters from query options.
/// </summary>
/// <param name="serviceOperation">The service operation to bind the parameters for.</param>
/// <returns>Enumeration of parameter values for the service operation.</returns>
private IEnumerable<QueryNode> BindServiceOperationParameters(IEdmFunctionImport serviceOperation)
{
Debug.Assert(serviceOperation != null, "serviceOperation != null");
//// This is a copy of RequestUriProcessor.ReadOperationParameters
List<QueryNode> parameters = new List<QueryNode>();
foreach (IEdmFunctionParameter serviceOperationParameter in serviceOperation.Parameters)
{
IEdmTypeReference parameterType = serviceOperationParameter.Type;
string parameterTextValue = this.ConsumeQueryOption(serviceOperationParameter.Name);
object parameterValue;
if (string.IsNullOrEmpty(parameterTextValue))
{
if (!parameterType.IsNullable)
{
// The target parameter type is non-nullable, but we found null value, this usually means that the parameter is missing
throw new ODataException(Strings.MetadataBinder_ServiceOperationParameterMissing(serviceOperation.Name, serviceOperationParameter.Name));
}
parameterValue = null;
}
else
{
// We choose to be a little more flexible than with keys and
// allow surrounding whitespace (which is never significant).
parameterTextValue = parameterTextValue.Trim();
if (!UriPrimitiveTypeParser.TryUriStringToPrimitive(parameterTextValue, parameterType, out parameterValue))
{
throw new ODataException(Strings.MetadataBinder_ServiceOperationParameterInvalidType(serviceOperationParameter.Name, parameterTextValue, serviceOperation.Name, serviceOperationParameter.Type.ODataFullName()));
}
}
parameters.Add(new ConstantQueryNode() { Value = parameterValue });
}
if (parameters.Count == 0)
{
return null;
}
return new ReadOnlyCollection<QueryNode>(parameters);
}
/// <summary>
/// Asynchronously creates an <see cref="ODataParameterWriter" /> to write a parameter payload.
/// </summary>
/// <param name="functionImport">The function import whose parameters will be written.</param>
/// <returns>A running task for the created parameter writer.</returns>
/// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
internal override Task <ODataParameterWriter> CreateODataParameterWriterAsync(IEdmFunctionImport functionImport)
{
DebugUtils.CheckNoExternalCallers();
this.AssertAsynchronous();
return(TaskUtils.GetTaskForSynchronousOperation(() => this.CreateODataParameterWriterImplementation(functionImport)));
}
public virtual ODataAction CreateODataAction(IEdmFunctionImport action, EntityInstanceContext entityInstanceContext, ODataMetadataLevel metadataLevel)
{
if (action == null)
{
throw Error.ArgumentNull("action");
}
if (entityInstanceContext == null)
{
throw Error.ArgumentNull("entityInstanceContext");
}
IEdmModel model = entityInstanceContext.EdmModel;
ActionLinkBuilder builder = model.GetActionLinkBuilder(action);
if (builder == null)
{
return null;
}
if (ShouldOmitAction(action, model, builder, metadataLevel))
{
return null;
}
Uri target = builder.BuildActionLink(entityInstanceContext);
if (target == null)
{
return null;
}
Uri baseUri = new Uri(entityInstanceContext.Url.ODataLink(new MetadataPathSegment()));
Uri metadata = new Uri(baseUri, "#" + CreateMetadataFragment(action, model, metadataLevel));
ODataAction odataAction = new ODataAction
{
Metadata = metadata,
};
bool alwaysIncludeDetails = metadataLevel == ODataMetadataLevel.Default ||
metadataLevel == ODataMetadataLevel.FullMetadata;
// Always omit the title in minimal/no metadata modes (it isn't customizable and thus always follows
// conventions).
if (alwaysIncludeDetails)
{
odataAction.Title = action.Name;
}
// Omit the target in minimal/no metadata modes unless it doesn't follow conventions.
if (alwaysIncludeDetails || !builder.FollowsConventions)
{
odataAction.Target = target;
}
return odataAction;
}
internal static bool ShouldOmitAction(IEdmFunctionImport action, IEdmModel model, ActionLinkBuilder builder,
ODataMetadataLevel metadataLevel)
{
Contract.Assert(model != null);
Contract.Assert(builder != null);
switch (metadataLevel)
{
case ODataMetadataLevel.MinimalMetadata:
case ODataMetadataLevel.NoMetadata:
return model.IsAlwaysBindable(action) && builder.FollowsConventions;
case ODataMetadataLevel.Default:
case ODataMetadataLevel.FullMetadata:
default: // All values already specified; just keeping the compiler happy.
return false;
}
}
private void WriteMethod(OdcmClass odcmClass, IEdmFunctionImport operation)
{
IEnumerable<IEdmFunctionParameter> parameters = operation.IsBindable
? (from parameter in operation.Parameters
where parameter != operation.Parameters.First()
select parameter)
: (operation.Parameters);
bool isBoundToCollection = operation.IsBindable && operation.Parameters.First().Type.IsCollection();
var odcmMethod = new OdcmMethod(operation.Name, odcmClass.Namespace)
{
Verbs = operation.IsSideEffecting ? OdcmAllowedVerbs.Post : OdcmAllowedVerbs.Any,
IsBoundToCollection = isBoundToCollection,
IsComposable = operation.IsComposable,
Class = odcmClass
};
odcmClass.Methods.Add(odcmMethod);
if (operation.ReturnType != null)
{
odcmMethod.ReturnType = ResolveType(operation.ReturnType);
odcmMethod.IsCollection = operation.ReturnType.IsCollection();
}
var callingConvention =
operation.IsSideEffecting
? OdcmCallingConvention.InHttpMessageBody
: OdcmCallingConvention.InHttpRequestUri;
foreach (var parameter in parameters)
{
odcmMethod.Parameters.Add(new OdcmParameter(parameter.Name)
{
CallingConvention = callingConvention,
Type = ResolveType(parameter.Type),
IsCollection = parameter.Type.IsCollection(),
IsNullable = parameter.Type.IsNullable
});
}
}
protected override void ProcessFunctionImport(IEdmFunctionImport functionImport)
{
this.BeginElement(functionImport, this.schemaWriter.WriteFunctionImportElementHeader);
this.EndElement(functionImport);
}
private static ODataAction CreateODataAction(IEdmFunctionImport action, EntityInstanceContext context)
{
ActionLinkBuilder builder = context.EdmModel.GetActionLinkBuilder(action);
if (builder != null)
{
Uri target = builder.BuildActionLink(context);
if (target != null)
{
Uri baseUri = new Uri(context.UrlHelper.ODataLink(context.PathHandler, new MetadataPathSegment()));
Uri metadata = new Uri(baseUri, "#" + action.Container.Name + "." + action.Name);
return new ODataAction
{
Metadata = metadata,
Target = target,
Title = action.Name
};
}
}
return null;
}
private static bool IsMatch(IEdmFunctionImport function, IEnumerable<string> parameterNames)
{
IEnumerable<IEdmOperationParameter> nonBindingParameters = GetNonBindingParameters(function);
return new HashSet<string>(parameterNames).SetEquals(nonBindingParameters.Select(p => p.Name));
}
internal static string CreateMetadataFragment(IEdmFunctionImport action, IEdmModel model,
ODataMetadataLevel metadataLevel)
{
IEdmEntityContainer container = action.Container;
string actionName = action.Name;
string fragment;
if ((metadataLevel == ODataMetadataLevel.MinimalMetadata || metadataLevel == ODataMetadataLevel.NoMetadata)
&& model.IsDefaultEntityContainer(container))
{
fragment = actionName;
}
else
{
fragment = container.Name + "." + actionName;
}
return fragment;
}
internal virtual Task<ODataParameterReader> CreateParameterReaderAsync(IEdmFunctionImport functionImport)
{
throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Parameter);
}
public IEnumerable<IEdmFunctionImport> FindFunctionImports(string name)
{
object obj = null;
if (!this.FunctionImportsDictionary.TryGetValue(name, out obj))
{
return Enumerable.Empty<IEdmFunctionImport>();
}
else
{
List<IEdmFunctionImport> edmFunctionImports = obj as List<IEdmFunctionImport>;
if (edmFunctionImports == null)
{
IEdmFunctionImport[] edmFunctionImportArray = new IEdmFunctionImport[1];
edmFunctionImportArray[0] = (IEdmFunctionImport)obj;
return edmFunctionImportArray;
}
else
{
return edmFunctionImports;
}
}
}
/// <summary>
/// Asynchronously create a <see cref="ODataParameterReader"/>.
/// </summary>
/// <param name="functionImport">The function import whose parameters are being read.</param>
/// <returns>Task which when completed returns the newly created <see cref="ODataParameterReader"/>.</returns>
internal virtual Task <ODataParameterReader> CreateParameterReaderAsync(IEdmFunctionImport functionImport)
{
DebugUtils.CheckNoExternalCallers();
throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Parameter);
}
