/// <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); }