internal static Uri GenerateFunctionLink(this ResourceSetContext feedContext, string bindingParameterType, string functionName, IEnumerable <string> parameterNames) { Contract.Assert(feedContext != null); if (feedContext.EntitySetBase is IEdmContainedEntitySet) { return(null); } if (feedContext.EdmModel == null) { return(null); } IEdmModel model = feedContext.EdmModel; string elementType = DeserializationHelpers.GetCollectionElementTypeName(bindingParameterType, isNested: false); Contract.Assert(elementType != null); IEdmTypeReference typeReference = model.FindDeclaredType(elementType).ToEdmTypeReference(true); IEdmTypeReference collection = new EdmCollectionTypeReference(new EdmCollectionType(typeReference)); IEdmOperation operation = model.FindDeclaredOperations(functionName).First(); return(feedContext.GenerateFunctionLink(collection, operation, parameterNames)); }
internal static Uri GenerateActionLink(this ResourceSetContext resourceSetContext, IEdmTypeReference bindingParameterType, IEdmOperation action) { Contract.Assert(resourceSetContext != null); if (resourceSetContext.EntitySetBase is IEdmContainedEntitySet) { return(null); } IList <ODataPathSegment> actionPathSegments = new List <ODataPathSegment>(); resourceSetContext.GenerateBaseODataPathSegmentsForFeed(actionPathSegments); // generate link with cast if the navigation source doesn't match the type the action is bound to. if (resourceSetContext.EntitySetBase.Type.FullTypeName() != bindingParameterType.FullName()) { actionPathSegments.Add(new TypeSegment(bindingParameterType.Definition, resourceSetContext.EntitySetBase)); } OperationSegment operationSegment = new OperationSegment(action, entitySet: null); actionPathSegments.Add(operationSegment); string actionLink = resourceSetContext.InternalUrlHelper.CreateODataLink(actionPathSegments); return(actionLink == null ? null : new Uri(actionLink)); }
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions() { // Arrange Uri expectedUri = new Uri("http://server/Movies/Default.Watch(param=@param)"); ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create(); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; FunctionConfiguration watch = movie.Collection.Function("Watch").Returns <int>(); // function bound to collection watch.Parameter <string>("param"); IEdmModel model = builder.GetEdmModel(); var configuration = RoutingConfigurationFactory.Create(); string routeName = "Route"; configuration.MapODataServiceRoute(routeName, null, model); var request = RequestFactory.Create(HttpMethod.Get, "http://server/Movies", configuration, routeName); // Act IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault(); IEdmFunction watchFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault(); ODataSerializerContextFactory.Create(model, entitySet, request); ResourceSetContext context = ResourceSetContextFactory.Create(entitySet, request); OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(watchFunction); //Assert Assert.Equal(expectedUri, watch.GetFeedFunctionLink()(context)); Assert.NotNull(functionLinkBuilder); Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context)); }
private static void GenerateBaseODataPathSegmentsForFeed( this ResourceSetContext feedContext, IList <ODataPathSegment> odataPath) { GenerateBaseODataPathSegmentsForNonSingletons(feedContext.InternalRequest.Context.Path, feedContext.EntitySetBase, odataPath); }
public void GenerateFunctionLinkForFeed_ThrowsArgumentNull_Function() { // Arrange ResourceSetContext feedContext = new ResourceSetContext(); // Act & Assert ExceptionAssert.ThrowsArgumentNull(() => feedContext.GenerateFunctionLink(function: null), "function"); }
public void GenerateActionLinkForFeed_ThrowsArgumentNull_Action() { // Arrange ResourceSetContext resourceSetContext = new ResourceSetContext(); // Act & Assert Assert.ThrowsArgumentNull(() => resourceSetContext.GenerateActionLink(action: null), "action"); }
public void GenerateFunctionLinkForFeed_ThrowsArgumentNull_ResourceSetContext() { // Arrange ResourceSetContext resourceSetContext = null; IEdmFunction function = new Mock <IEdmFunction>().Object; // Act & Assert ExceptionAssert.ThrowsArgumentNull(() => resourceSetContext.GenerateFunctionLink(function), "resourceSetContext"); }
public void GenerateActionLinkForFeed_ThrowsArgumentNull_FeedContext() { // Arrange ResourceSetContext feedContext = null; IEdmAction action = new Mock <IEdmAction>().Object; // Act & Assert Assert.ThrowsArgumentNull(() => feedContext.GenerateActionLink(action), "resourceSetContext"); }
/// <summary> /// Builds the operation link for the given feed. /// </summary> /// <param name="context">An feed context wrapping the feed instance.</param> /// <returns>The generated link.</returns> public virtual Uri BuildLink(ResourceSetContext context) { if (_feedLinkFactory == null) { return(null); } return(_feedLinkFactory(context)); }
public void CreateODataOperations_CreateOperations(bool followConventions) { // Arrange string expectedTarget = "aa://Target"; Mock <ODataSerializerProvider> serializerProvider = new Mock <ODataSerializerProvider>(); ODataResourceSetSerializer serializer = new ODataResourceSetSerializer(serializerProvider.Object); var builder = new ODataConventionModelBuilder(); builder.EntitySet <FeedCustomer>("Customers"); var function = builder.EntityType <FeedCustomer>().Collection.Function("MyFunction").Returns <int>(); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers"); IEdmFunction edmFunction = model.SchemaElements.OfType <IEdmFunction>().First(f => f.Name == "MyFunction"); Func <ResourceSetContext, Uri> functionLinkFactory = a => new Uri(expectedTarget); var operationLinkBuilder = new OperationLinkBuilder(functionLinkFactory, followConventions); model.SetOperationLinkBuilder(edmFunction, operationLinkBuilder); var request = RequestFactory.Create(method: "get", uri: "http://any", opt => opt.AddModel(model)); ResourceSetContext resourceSetContext = new ResourceSetContext { EntitySetBase = customers, Request = request, }; ODataSerializerContext serializerContext = new ODataSerializerContext { NavigationSource = customers, Request = request, Model = model, MetadataLevel = ODataMetadataLevel.Full, }; string expectedMetadataPrefix = "http://any/$metadata"; // Act ODataOperation actualOperation = serializer.CreateODataOperation(edmFunction, resourceSetContext, serializerContext); // Assert Assert.NotNull(actualOperation); string expectedMetadata = expectedMetadataPrefix + "#Default.MyFunction"; ODataOperation expectedFunction = new ODataFunction { Metadata = new Uri(expectedMetadata), Target = new Uri(expectedTarget), Title = "MyFunction" }; AssertEqual(expectedFunction, actualOperation); }
public void CreateODataOperations_CreateOperations(bool followConventions) { // Arrange // Arrange string expectedTarget = "aa://Target"; ODataResourceSetSerializer serializer = new ODataResourceSetSerializer(_serializerProvider); var builder = new ODataConventionModelBuilder(); builder.EntitySet <FeedCustomer>("Customers"); var function = builder.EntityType <FeedCustomer>().Collection.Function("MyFunction").Returns <int>(); function.HasFeedFunctionLink(a => new Uri(expectedTarget), followConventions); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers"); IEdmFunction edmFunction = model.SchemaElements.OfType <IEdmFunction>().First(f => f.Name == "MyFunction"); string expectedMetadataPrefix = "http://Metadata"; UrlHelper url = CreateMetadataLinkFactory(expectedMetadataPrefix); HttpRequestMessage request = new HttpRequestMessage(); ResourceSetContext resourceSetContext = new ResourceSetContext { EntitySetBase = customers, Request = request, Url = url }; ODataSerializerContext serializerContext = new ODataSerializerContext { NavigationSource = customers, Request = request, Model = model, MetadataLevel = ODataMetadataLevel.FullMetadata, Url = url }; // Act ODataOperation actualOperation = serializer.CreateODataOperation(edmFunction, resourceSetContext, serializerContext); // Assert Assert.NotNull(actualOperation); string expectedMetadata = expectedMetadataPrefix + "#Default.MyFunction"; ODataOperation expectedFunction = new ODataFunction { Metadata = new Uri(expectedMetadata), Target = new Uri(expectedTarget), Title = "MyFunction" }; AssertEqual(expectedFunction, actualOperation); }
public void GenerateFunctionLinkForFeed_ThrowsFunctionNotBoundToCollectionOfEntity_IfFunctionHasNoParameters() { // Arrange ResourceSetContext context = new ResourceSetContext(); Mock <IEdmFunction> function = new Mock <IEdmFunction>(); function.Setup(a => a.Parameters).Returns(Enumerable.Empty <IEdmOperationParameter>()); function.Setup(a => a.Name).Returns("SomeFunction"); // Act & Assert ExceptionAssert.ThrowsArgument( () => context.GenerateFunctionLink(function.Object), "function", "The function 'SomeFunction' is not bound to the collection of entity. Only functions that are bound to entities can have function links."); }
public void GenerateFunctionLinkForFeed_GeneratesLinkWithoutCast_IfEntitySetTypeMatchesActionEntityType() { // Arrange var request = RequestFactory.Create(_model); IEdmFunction function = _model.SchemaElements.OfType <IEdmFunction>().First(a => a.Name == "IsAllUpgraded"); Assert.NotNull(function); // Guard ResourceSetContext context = new ResourceSetContext { EntitySetBase = _customers, Request = request }; // Act Uri link = context.GenerateFunctionLink(function); Assert.Equal("http://localhost/Customers/NS.IsAllUpgraded(param=@param)", link.AbsoluteUri); }
public void GenerateActionLinkForFeed_GeneratesLinkWithCast_IfEntitySetTypeDoesnotMatchActionEntityType() { // Arrange var request = RequestFactory.Create(_model); IEdmAction action = _model.SchemaElements.OfType <IEdmAction>().First(a => a.Name == "UpgradeSpecialAll"); Assert.NotNull(action); // Guard ResourceSetContext context = new ResourceSetContext { EntitySetBase = _customers, Request = request }; // Act Uri link = context.GenerateActionLink(action); // Assert Assert.Equal("http://localhost/Customers/NS.SpecialCustomer/NS.UpgradeSpecialAll", link.AbsoluteUri); }
public void BuildLinkOperationLinkBuilder_Works_ResourceSetContext() { // Arrange Uri uri = new Uri("http://any"); Func <ResourceSetContext, Uri> linkFactory = r => uri; OperationLinkBuilder linkBuilder = new OperationLinkBuilder(linkFactory, false); // Act & Assert ResourceContext context = new ResourceContext(); Assert.Null(linkBuilder.BuildLink(context)); // Act & Assert ResourceSetContext setContext = new ResourceSetContext(); Assert.Same(uri, linkBuilder.BuildLink(setContext)); }
public void BuildOperationLink_ForFeed_ReturnsLink() { // Arrange OperationLinkBuilder builder = new OperationLinkBuilder((ResourceSetContext a) => new Uri("http://localhost:456"), followsConventions: true); ResourceContext entityContext = new ResourceContext(); ResourceSetContext feedContext = new ResourceSetContext(); // Act Uri link = builder.BuildLink(entityContext); Uri feedLink = builder.BuildLink(feedContext); // Assert Assert.Null(link); Assert.NotNull(feedLink); Assert.Equal("http://localhost:456/", feedLink.AbsoluteUri); }
public void CreateODataOperation_ThrowsArgumentNull_ForInputParameters() { // Arrange & Act & Assert Mock <ODataSerializerProvider> serializerProvider = new Mock <ODataSerializerProvider>(); ODataResourceSetSerializer serializer = new ODataResourceSetSerializer(serializerProvider.Object); // Act & Assert ExceptionAssert.ThrowsArgumentNull(() => serializer.CreateODataOperation(null, null, null), "operation"); // Act & Assert IEdmOperation operation = new Mock <IEdmOperation>().Object; ExceptionAssert.ThrowsArgumentNull(() => serializer.CreateODataOperation(operation, null, null), "resourceSetContext"); // Act & Assert ResourceSetContext context = new ResourceSetContext(); ExceptionAssert.ThrowsArgumentNull(() => serializer.CreateODataOperation(operation, context, null), "writeContext"); }
public void GenerateFunctionLinkForFeed_GeneratesLinkWithDownCast_IfElementTypeDerivesFromBindingParameterType() { // Arrange var request = RequestFactory.Create(_model); IEdmFunction function = _model.SchemaElements.OfType <IEdmFunction>().First(a => a.Name == "IsAllUpgraded"); Assert.NotNull(function); // Guard IEdmEntitySet specialCustomers = new EdmEntitySet(_model.EntityContainer, "SpecialCustomers", _specialCustomer); ResourceSetContext context = new ResourceSetContext { EntitySetBase = specialCustomers, Request = request }; // Act Uri link = context.GenerateFunctionLink(function); // Assert Assert.Equal("http://localhost/SpecialCustomers/NS.Customer/NS.IsAllUpgraded(param=@param)", link.AbsoluteUri); }
public void GenerateFunctionLinkForFeed_GeneratesLinkWithCast_IfEntitySetTypeDoesnotMatchActionEntityType() { // Arrange HttpRequestMessage request = GetODataRequest(_model.Model); IEdmFunction function = _model.Model.SchemaElements.OfType <IEdmFunction>().First(a => a.Name == "IsSpecialAllUpgraded"); Assert.NotNull(function); // Guard var context = new ResourceSetContext { Request = request, EntitySetBase = _model.Customers, Url = request.GetUrlHelper(), }; // Act Uri link = context.GenerateFunctionLink(function); // Assert Assert.Equal("http://localhost/Customers/NS.SpecialCustomer/NS.IsSpecialAllUpgraded(param=@param)", link.AbsoluteUri); }
public void GenerateActionLinkForFeed_GeneratesLinkWithoutCast_IfEntitySetTypeMatchesActionEntityType() { // Arrange HttpRequestMessage request = GetODataRequest(_model.Model); IEdmAction action = _model.Model.SchemaElements.OfType <IEdmAction>().First(a => a.Name == "UpgradeAll"); Assert.NotNull(action); // Guard var context = new ResourceSetContext { Request = request, EntitySetBase = _model.Customers, Url = request.GetUrlHelper(), }; // Act Uri link = context.GenerateActionLink(action); Assert.Equal("http://localhost/Customers/NS.UpgradeAll", link.AbsoluteUri); }
public void CreateODataOperation_OmitsOperations_WhenNonFullMetadata(ODataMetadataLevel metadataLevel) { // Arrange ODataResourceSetSerializer serializer = new ODataResourceSetSerializer(_serializerProvider); IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false); IEdmFunction function = new EdmFunction("NS", "Function", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); ResourceSetContext resourceSetContext = new ResourceSetContext(); ODataSerializerContext serializerContext = new ODataSerializerContext { MetadataLevel = metadataLevel }; // Act ODataOperation operation = serializer.CreateODataOperation(function, resourceSetContext, serializerContext); // Assert Assert.Null(operation); }
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions() { // Arrange Uri expectedUri = new Uri("http://server/Movies/Default.Watch(param=@param)"); ODataModelBuilder builder = new ODataConventionModelBuilder(); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; FunctionConfiguration watch = movie.Collection.Function("Watch").Returns <int>(); // function bound to collection watch.Parameter <string>("param"); IEdmModel model = builder.GetEdmModel(); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://server/Movies"); HttpConfiguration configuration = new HttpConfiguration(); string routeName = "Route"; configuration.MapODataServiceRoute(routeName, null, model); request.SetConfiguration(configuration); request.EnableODataDependencyInjectionSupport(routeName); UrlHelper urlHelper = new UrlHelper(request); // Act IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault(); IEdmFunction watchFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault(); ResourceSetContext context = new ResourceSetContext { EntitySetBase = entitySet, Url = urlHelper, Request = request }; OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(watchFunction); //Assert Assert.Equal(expectedUri, watch.GetFeedFunctionLink()(context)); Assert.NotNull(functionLinkBuilder); Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context)); }
public void GenerateFunctionLinkForFeed_GeneratesLinkWithDownCast_IfElementTypeDerivesFromBindingParameterType() { // Arrange HttpRequestMessage request = GetODataRequest(_model.Model); IEdmFunction function = _model.Model.SchemaElements.OfType <IEdmFunction>().First(a => a.Name == "IsAllUpgraded"); Assert.NotNull(function); // Guard IEdmEntitySet specialCustomers = new EdmEntitySet(_model.Container, "SpecialCustomers", _model.SpecialCustomer); var context = new ResourceSetContext { Request = request, EntitySetBase = specialCustomers, Url = request.GetUrlHelper(), }; // Act Uri link = context.GenerateFunctionLink(function); // Assert Assert.Equal("http://localhost/SpecialCustomers/NS.Customer/NS.IsAllUpgraded(param=@param)", link.AbsoluteUri); }
/// <summary> /// Generates an action link following the OData URL conventions for the action <paramref name="action"/> and bound to the /// collection of entity represented by <paramref name="resourceSetContext"/>. /// </summary> /// <param name="resourceSetContext">The <see cref="ResourceSetContext"/> representing the feed 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 ResourceSetContext resourceSetContext, IEdmOperation action) { if (resourceSetContext == null) { throw Error.ArgumentNull("resourceSetContext"); } if (action == null) { throw Error.ArgumentNull("action"); } IEdmOperationParameter bindingParameter = action.Parameters.FirstOrDefault(); if (bindingParameter == null || !bindingParameter.Type.IsCollection() || !((IEdmCollectionType)bindingParameter.Type.Definition).ElementType.IsEntity()) { throw Error.Argument("action", SRResources.ActionNotBoundToCollectionOfEntity, action.Name); } return(GenerateActionLink(resourceSetContext, bindingParameter.Type, action)); }
internal static Uri GenerateFunctionLink(this ResourceSetContext resourceSetContext, IEdmTypeReference bindingParameterType, IEdmOperation functionImport, IEnumerable <string> parameterNames) { Contract.Assert(resourceSetContext != null); if (resourceSetContext.EntitySetBase is IEdmContainedEntitySet) { return(null); } IList <ODataPathSegment> functionPathSegments = new List <ODataPathSegment>(); resourceSetContext.GenerateBaseODataPathSegmentsForFeed(functionPathSegments); // generate link with cast if the navigation source type doesn't match the entity type the function is bound to. if (resourceSetContext.EntitySetBase.Type.FullTypeName() != bindingParameterType.Definition.FullTypeName()) { functionPathSegments.Add(new TypeSegment(bindingParameterType.Definition, null)); } IList <OperationSegmentParameter> parameters = new List <OperationSegmentParameter>(); // skip the binding parameter foreach (string param in parameterNames.Skip(1)) { string value = "@" + param; parameters.Add(new OperationSegmentParameter(param, new ConstantNode(value, value))); } OperationSegment segment = new OperationSegment(new[] { functionImport }, parameters, null); functionPathSegments.Add(segment); string functionLink = resourceSetContext.InternalUrlHelper.CreateODataLink(functionPathSegments); return(functionLink == null ? null : new Uri(functionLink)); }
public void Convention_GeneratesUri_ForFunctionBoundToCollectionOfEntity() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Customer>("Customers"); var function = builder.EntityType <Customer>().Collection.Function("MyFunction").Returns <int>(); function.Parameter <string>("param"); IEdmModel model = builder.GetEdmModel(); // Act HttpConfiguration configuration = new HttpConfiguration(); configuration.MapODataServiceRoute("odata", "odata", model); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://*****:*****@param)", link.AbsoluteUri); }
/// <summary> /// Generates a function link following the OData URL conventions for the function <paramref name="function"/> and bound to the /// collection of entity represented by <paramref name="resourceSetContext"/>. /// </summary> /// <param name="resourceSetContext">The <see cref="ResourceSetContext"/> representing the feed for which the function link needs to be generated.</param> /// <param name="function">The function for which the function link needs to be generated.</param> /// <returns>The generated function link following OData URL conventions.</returns> public static Uri GenerateFunctionLink(this ResourceSetContext resourceSetContext, IEdmOperation function) { if (resourceSetContext == null) { throw Error.ArgumentNull("resourceSetContext"); } if (function == null) { throw Error.ArgumentNull("function"); } IEdmOperationParameter bindingParameter = function.Parameters.FirstOrDefault(); if (bindingParameter == null || !bindingParameter.Type.IsCollection() || !((IEdmCollectionType)bindingParameter.Type.Definition).ElementType.IsEntity()) { throw Error.Argument("function", "TODO: " /*SRResources.FunctionNotBoundToCollectionOfEntity, function.Name*/); } return(GenerateFunctionLink(resourceSetContext, bindingParameter.Type, function, function.Parameters.Select(p => p.Name))); }
public void CanManuallyConfigureFeedFunctionLinkFactory() { // Arrange Uri expectedUri = new Uri("http://localhost/service/Customers/Reward"); ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType; customer.HasKey(c => c.CustomerId); customer.Property(c => c.Name); FunctionConfiguration reward = customer.Collection.Function("Reward").Returns <int>(); reward.HasFeedFunctionLink(ctx => expectedUri, followsConventions: false); IEdmModel model = builder.GetEdmModel(); // Act IEdmFunction rewardFuntion = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(rewardFuntion); ResourceSetContext context = new ResourceSetContext(); //Assert Assert.Equal(expectedUri, reward.GetFeedFunctionLink()(context)); Assert.NotNull(functionLinkBuilder); Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context)); }
private IEnumerable <ODataOperation> CreateODataOperations(IEnumerable <IEdmOperation> operations, ResourceSetContext resourceSetContext, ODataSerializerContext writeContext) { Contract.Assert(operations != null); Contract.Assert(resourceSetContext != null); Contract.Assert(writeContext != null); foreach (IEdmOperation operation in operations) { ODataOperation oDataOperation = CreateODataOperation(operation, resourceSetContext, writeContext); if (oDataOperation != null) { yield return(oDataOperation); } } }
public virtual ODataOperation CreateODataOperation(IEdmOperation operation, ResourceSetContext resourceSetContext, ODataSerializerContext writeContext) { if (operation == null) { throw Error.ArgumentNull("operation"); } if (resourceSetContext == null) { throw Error.ArgumentNull("resourceSetContext"); } if (writeContext == null) { throw Error.ArgumentNull("writeContext"); } ODataMetadataLevel metadataLevel = writeContext.MetadataLevel; IEdmModel model = writeContext.Model; if (metadataLevel != ODataMetadataLevel.FullMetadata) { return(null); } OperationLinkBuilder builder; builder = model.GetOperationLinkBuilder(operation); if (builder == null) { return(null); } Uri target = builder.BuildLink(resourceSetContext); if (target == null) { return(null); } Uri baseUri = new Uri(writeContext.Url.CreateODataLink(MetadataSegment.Instance)); Uri metadata = new Uri(baseUri, "#" + operation.FullName()); ODataOperation odataOperation; IEdmAction action = operation as IEdmAction; if (action != null) { odataOperation = new ODataAction(); } else { odataOperation = new ODataFunction(); } odataOperation.Metadata = metadata; // Always omit the title in minimal/no metadata modes. ODataResourceSerializer.EmitTitle(model, operation, odataOperation); // Omit the target in minimal/no metadata modes unless it doesn't follow conventions. if (metadataLevel == ODataMetadataLevel.FullMetadata || !builder.FollowsConventions) { odataOperation.Target = target; } return(odataOperation); }