public void Convention_GeneratesUri_ForActionBoundToCollectionOfEntity()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("Customers");
var action = builder.EntityType <Customer>().Collection.Action("MyAction").Returns <int>();
action.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
var configuration = RoutingConfigurationFactory.Create();
configuration.MapODataServiceRoute("odata", "odata", model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost:123", configuration, "odata");
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var entityContext = ResourceSetContextFactory.Create(customers, request);
// Assert
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildLink(entityContext);
Assert.Equal("http://localhost:123/odata/Customers/Default.MyAction", link.AbsoluteUri);
}
public void Convention_GeneratesUri_ForActionBoundToEntity()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("Customers");
var action = builder.EntityType <Customer>().Action("MyAction");
action.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
var configuration = RoutingConfigurationFactory.Create();
configuration.MapODataServiceRoute("odata", "odata", model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost:123", configuration, "odata");
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var edmType = model.SchemaElements.OfType <IEdmEntityType>().First(e => e.Name == "Customer");
var serializerContext = ODataSerializerContextFactory.Create(model, customers, request);
var resourceContext = new ResourceContext(serializerContext, edmType.AsReference(), new Customer {
Id = 109
});
// Assert
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildLink(resourceContext);
Assert.Equal("http://localhost:123/odata/Customers(109)/Default.MyAction", link.AbsoluteUri);
}
public void SetOperationLinkBuilder_ResetOperationLinkBuilder_AfterCallGetOperationLinkBuilder()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmEntityType entity = new EdmEntityType("NS", "entity");
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
EdmFunction function = new EdmFunction("NS", "Function", returnType);
function.AddParameter("entity", new EdmEntityTypeReference(entity, true));
// Act
OperationLinkBuilder linkBuilder = model.GetOperationLinkBuilder(function);
Assert.NotNull(linkBuilder);
OperationLinkBuilder linkBuilder2 = new OperationLinkBuilder((ResourceContext a) => new Uri("http://localhost2"), followsConventions: false);
model.SetOperationLinkBuilder(function, linkBuilder2);
// Assert
OperationLinkBuilder actualLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(function);
Assert.Same(linkBuilder2, actualLinkBuilder);
Assert.Equal(new Uri("http://localhost2"), actualLinkBuilder.BuildLink((ResourceContext)null));
}
public void WhenActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
string uriTemplate = "http://server/Movies({0})/Default.Watch";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
ActionConfiguration watch = movie.Action("Watch");
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
IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmAction watchAction = Assert.Single(model.SchemaElements.OfType <IEdmAction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
ODataSerializerContext serializerContext = ODataSerializerContextFactory.Create(model, entitySet, request);
ResourceContext context = new ResourceContext(serializerContext, movieType.AsReference(), new Movie {
ID = 1, Name = "Avatar"
});
OperationLinkBuilder actionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(watchAction);
//Assert
Assert.Equal(expectedUri, watch.GetActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildLink(context));
}
public void FunctionLink_PreservesFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
FunctionConfiguration configuration = new FunctionConfiguration(builder, "IgnoreFunction");
configuration.Returns <int>();
Mock <IEdmTypeConfiguration> bindingParameterTypeMock = new Mock <IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
Type entityType = typeof(object);
bindingParameterTypeMock.Setup(o => o.ClrType).Returns(entityType);
configuration.SetBindingParameter("IgnoreParameter", bindingParameterTypeMock.Object);
configuration.HasFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
builder.AddOperation(configuration);
builder.AddEntityType(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
OperationLinkBuilder functionLinkBuilder = model.GetOperationLinkBuilder(function);
Assert.NotNull(functionLinkBuilder);
Assert.Equal(value, functionLinkBuilder.FollowsConventions);
}
public void CanManuallyConfigureFunctionLinkFactory()
{
// Arrange
string uriTemplate = "http://server/service/Customers({0})/Reward";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration reward = customer.Function("Reward");
reward.HasFunctionLink(ctx => new Uri(string.Format(uriTemplate, ctx.GetPropertyValue("CustomerId"))),
followsConventions: false);
reward.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
ODataSerializerContext serializerContext = new ODataSerializerContext {
Model = model
};
ResourceContext context = new ResourceContext(serializerContext, customerType.AsReference(), new Customer {
CustomerId = 1
});
IEdmFunction rewardFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(rewardFunction);
//Assert
Assert.Equal(expectedUri, reward.GetFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context));
}
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));
}
public void FollowsConventions_IsSpecifiedValue(bool value)
{
// Arrange
OperationLinkBuilder builder = new OperationLinkBuilder((ResourceContext a) => { throw new NotImplementedException(); },
followsConventions: value);
// Act
bool followsConventions = builder.FollowsConventions;
// Assert
Assert.Equal(value, followsConventions);
}
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 GetActionOperationLinkBuilderForFeed_After_SetOperationLinkBuilder()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmAction action = new Mock <IEdmAction>().Object;
OperationLinkBuilder builder = new OperationLinkBuilder((ResourceSetContext _) => null, followsConventions: false);
// Act
model.SetOperationLinkBuilder(action, builder);
var result = model.GetOperationLinkBuilder(action);
// Assert
Assert.Same(builder, result);
}
private static ODataOperation CreateODataOperation(IEdmOperation operation, OperationLinkBuilder builder, ResourceContext resourceContext)
{
Contract.Assert(operation != null);
Contract.Assert(builder != null);
Contract.Assert(resourceContext != null);
ODataMetadataLevel metadataLevel = resourceContext.SerializerContext.MetadataLevel;
IEdmModel model = resourceContext.EdmModel;
if (ShouldOmitOperation(operation, builder, metadataLevel))
{
return(null);
}
Uri target = builder.BuildLink(resourceContext);
if (target == null)
{
return(null);
}
Uri baseUri = new Uri(resourceContext.Url.CreateODataLink(MetadataSegment.Instance));
Uri metadata = new Uri(baseUri, "#" + CreateMetadataFragment(operation));
ODataOperation odataOperation;
if (operation is IEdmAction)
{
odataOperation = new ODataAction();
}
else
{
odataOperation = new ODataFunction();
}
odataOperation.Metadata = metadata;
// Always omit the title in minimal/no metadata modes.
if (metadataLevel == ODataMetadataLevel.FullMetadata)
{
EmitTitle(model, operation, odataOperation);
}
// Omit the target in minimal/no metadata modes unless it doesn't follow conventions.
if (!builder.FollowsConventions || metadataLevel == ODataMetadataLevel.FullMetadata)
{
odataOperation.Target = target;
}
return(odataOperation);
}
internal static bool ShouldOmitOperation(IEdmOperation operation, OperationLinkBuilder builder,
ODataMetadataLevel metadataLevel)
{
Contract.Assert(builder != null);
switch (metadataLevel)
{
case ODataMetadataLevel.MinimalMetadata:
case ODataMetadataLevel.NoMetadata:
return(operation.IsBound && builder.FollowsConventions);
case ODataMetadataLevel.FullMetadata:
default: // All values already specified; just keeping the compiler happy.
return(false);
}
}
public void GetActionOperationLinkBuilder_ReturnsDefaultOperationLinkBuilder_IfNotSet()
{
// Arrange
IEdmModel model = new EdmModel();
EdmAction action = new EdmAction("NS", "Action", returnType: null);
action.AddParameter("entity", new EdmEntityTypeReference(new EdmEntityType("NS", "Customer"), false));
// Act
OperationLinkBuilder builder = model.GetOperationLinkBuilder(action);
// Assert
Assert.NotNull(builder);
Assert.NotNull(builder.LinkFactory);
Assert.IsType <Func <ResourceContext, Uri> >(builder.LinkFactory);
Assert.Null(builder.FeedLinkFactory);
}
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 OperationLinkBuilderTests()
{
ResourceType intType = ResourceType.GetPrimitiveResourceType(typeof(int));
var customerType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "FQ.NS", "Customer", false);
customerType.CanReflectOnInstanceType = false;
customerType.AddProperty(new ResourceProperty("Id", ResourcePropertyKind.Primitive | ResourcePropertyKind.Key, intType)
{
CanReflectOnInstanceTypeProperty = false
});
customerType.SetReadOnly();
var operation = new ServiceAction("Action", intType, OperationParameterBindingKind.Sometimes, new[] { new ServiceActionParameter("P1", customerType), new ServiceActionParameter("P2", intType) }, null);
operation.SetReadOnly();
this.operationWithParameters = new OperationWrapper(operation);
var typeWithEscapedName = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "FQ NS", "+ /", false);
typeWithEscapedName.CanReflectOnInstanceType = false;
typeWithEscapedName.AddProperty(new ResourceProperty("Number", ResourcePropertyKind.Primitive, intType)
{
CanReflectOnInstanceTypeProperty = false
});
typeWithEscapedName.SetReadOnly();
operation = new ServiceAction("Action", intType, OperationParameterBindingKind.Sometimes, new[] { new ServiceActionParameter("P1", customerType), new ServiceActionParameter("P2", typeWithEscapedName) }, null);
operation.SetReadOnly();
this.operationWithEscapedParameter = new OperationWrapper(operation);
var bestCustomerType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, customerType, "FQ.NS", "BestCustomer", false);
bestCustomerType.SetReadOnly();
operation = new ServiceAction("Action", intType, OperationParameterBindingKind.Sometimes, new[] { new ServiceActionParameter("P1", customerType) }, null);
operation.SetReadOnly();
this.operationBoundToBaseType = new OperationWrapper(operation);
this.entityToSerialize = EntityToSerialize.CreateFromExplicitValues(new object(), bestCustomerType, new TestSerializedEntityKey("http://odata.org/Service.svc/Customers/", bestCustomerType.FullName));
var metadataUri = new Uri("http://odata.org/Service.svc/$metadata");
this.testSubject = new OperationLinkBuilder("MyContainer", metadataUri);
}
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 SetOperationLinkBuilder_SetsOperationLinkBuilder()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmFunction function = new EdmFunction("NS", "Function", returnType, isBound: true, entitySetPathExpression: null, isComposable: false);
OperationLinkBuilder linkBuilder = new OperationLinkBuilder((ResourceContext a) => new Uri("http://localhost"), followsConventions: false);
// Act
model.SetOperationLinkBuilder(function, linkBuilder);
// Assert
OperationLinkBuilder actualLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(function);
Assert.Same(linkBuilder, actualLinkBuilder);
Assert.Equal(new Uri("http://localhost"), actualLinkBuilder.BuildLink((ResourceContext)null));
}
public void GetFunctionOperationLinkBuilder_ReturnsDefaultOperationLinkBuilder_IfNotSet()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
EdmFunction function = new EdmFunction("NS", "Function", returnType);
function.AddParameter("entity", new EdmEntityTypeReference(new EdmEntityType("NS", "Customer"), false));
// Act
OperationLinkBuilder builder = model.GetOperationLinkBuilder(function);
// Assert
Assert.NotNull(builder);
Assert.NotNull(builder.LinkFactory);
Assert.IsType <Func <ResourceContext, Uri> >(builder.LinkFactory);
Assert.Null(builder.FeedLinkFactory);
}
public void Apply_Doesnot_Override_UserConfiguration()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var customers = builder.EntitySet <Customer>("Customers");
var paintAction = customers.EntityType.Action("Paint");
paintAction.HasActionLink(ctxt => new Uri("http://localhost/ActionTestWorks"), followsConventions: false);
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
// Act
convention.Apply(paintAction, builder);
IEdmModel model = builder.GetEdmModel();
var edmCustomers = model.EntityContainer.FindEntitySet("Customers");
var edmCustomer = model.SchemaElements.OfType <IEdmEntityType>().First(c => c.Name == "Customer");
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(a => a.Name == "Paint");
Assert.NotNull(edmAction);
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
var serializerContext = new ODataSerializerContext {
Model = model, NavigationSource = edmCustomers, Url = request.GetUrlHelper()
};
var entityContext = new ResourceContext(serializerContext, edmCustomer.AsReference(), new Customer {
Id = 2009
});
// Assert
Uri link = actionLinkBuilder.BuildLink(entityContext);
Assert.Equal("http://localhost/ActionTestWorks", link.AbsoluteUri);
}
public void Apply_SetsOperationLinkBuilder_OnlyIfFunctionIsBindable()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
var function = builder.Function("MyFunction").Returns <int>();
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
// Act
convention.Apply(function, builder);
// Assert
IEdmModel model = builder.GetEdmModel();
var edmFunction = model.EntityContainer.Elements.OfType <IEdmFunctionImport>().Single();
Assert.NotNull(edmFunction);
OperationLinkBuilder linkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(edmFunction);
Assert.Null(linkBuilder);
}
public void Apply_SetsOperationLinkBuilder_OnlyIfActionIsBindable()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("Customers");
var paintAction = builder.Action("Paint");
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
// Act
convention.Apply(paintAction, builder);
// Assert
IEdmModel model = builder.GetEdmModel();
var paintEdmAction = model.EntityContainer.Elements.OfType <IEdmActionImport>().Single();
OperationLinkBuilder actionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(paintEdmAction);
Assert.Null(actionLinkBuilder);
}
public void CtorOperationLinkBuilder_SetsProperties()
{
// Arrange & Act & Assert
Func <ResourceContext, Uri> linkFactory = r => null;
OperationLinkBuilder linkBuilder = new OperationLinkBuilder(linkFactory, false);
// Act & Assert
Assert.Same(linkFactory, linkBuilder.LinkFactory);
Assert.False(linkBuilder.FollowsConventions);
Assert.Null(linkBuilder.FeedLinkFactory);
// Arrange
Func <ResourceSetContext, Uri> linkSetFactory = r => null;
OperationLinkBuilder linkSetBuilder = new OperationLinkBuilder(linkSetFactory, true);
// Act & Assert
Assert.Null(linkSetBuilder.LinkFactory);
Assert.True(linkSetBuilder.FollowsConventions);
Assert.Same(linkSetFactory, linkSetBuilder.FeedLinkFactory);
}
private static OperationLinkBuilder GetDefaultOperationLinkBuilder(IEdmOperation operation)
{
OperationLinkBuilder linkBuilder = null;
if (operation.Parameters != null)
{
if (operation.Parameters.First().Type.IsEntity())
{
if (operation is IEdmAction)
{
linkBuilder = new OperationLinkBuilder(
(ResourceContext resourceContext) =>
resourceContext.GenerateActionLink(operation), followsConventions: true);
}
else
{
linkBuilder = new OperationLinkBuilder(
(ResourceContext resourceContext) =>
resourceContext.GenerateFunctionLink(operation), followsConventions: true);
}
}
else if (operation.Parameters.First().Type.IsCollection())
{
if (operation is IEdmAction)
{
linkBuilder =
new OperationLinkBuilder(
(ResourceSetContext reseourceSetContext) =>
reseourceSetContext.GenerateActionLink(operation), followsConventions: true);
}
else
{
linkBuilder =
new OperationLinkBuilder(
(ResourceSetContext reseourceSetContext) =>
reseourceSetContext.GenerateFunctionLink(operation), followsConventions: true);
}
}
}
return(linkBuilder);
}
public void Convention_GeneratesUri_ForFunctionBoundToEntity()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
var function = builder.EntityType <Customer>().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);
}
public static OperationLinkBuilder GetOperationLinkBuilder(this IEdmModel model, IEdmOperation operation)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
if (operation == null)
{
throw Error.ArgumentNull("operation");
}
OperationLinkBuilder linkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(operation);
if (linkBuilder == null)
{
linkBuilder = GetDefaultOperationLinkBuilder(operation);
model.SetOperationLinkBuilder(operation, linkBuilder);
}
return(linkBuilder);
}
public virtual ODataFunction CreateODataFunction(IEdmFunction function, ResourceContext resourceContext)
{
if (function == null)
{
throw Error.ArgumentNull("function");
}
if (resourceContext == null)
{
throw Error.ArgumentNull("resourceContext");
}
IEdmModel model = resourceContext.EdmModel;
OperationLinkBuilder builder = model.GetOperationLinkBuilder(function);
if (builder == null)
{
return(null);
}
return(CreateODataOperation(function, builder, resourceContext) as ODataFunction);
}
public void Apply_Doesnot_Override_UserConfiguration()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
var customers = builder.EntitySet <Customer>("Customers");
var paintAction = customers.EntityType.Action("Paint");
paintAction.HasActionLink(ctxt => new Uri("http://localhost/ActionTestWorks"), followsConventions: false);
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
// Act
convention.Apply(paintAction, builder);
IEdmModel model = builder.GetEdmModel();
var edmCustomers = model.EntityContainer.FindEntitySet("Customers");
var edmCustomer = model.SchemaElements.OfType <IEdmEntityType>().First(c => c.Name == "Customer");
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(a => a.Name == "Paint");
Assert.NotNull(edmAction);
string routeName = "OData";
var configuration = RoutingConfigurationFactory.CreateWithRootContainer(routeName);
configuration.MapODataServiceRoute(routeName, null, model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost", configuration, routeName);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
var serializerContext = ODataSerializerContextFactory.Create(model, edmCustomers, request);
var entityContext = new ResourceContext(serializerContext, edmCustomer.AsReference(), new Customer {
Id = 2009
});
// Assert
Uri link = actionLinkBuilder.BuildLink(entityContext);
Assert.Equal("http://localhost/ActionTestWorks", link.AbsoluteUri);
}
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));
}
public void Convention_GeneratesUri_ForActionBoundToCollectionOfEntity()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
var action = builder.EntityType <Customer>().Collection.Action("MyAction").Returns <int>();
action.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:123");
request.SetConfiguration(configuration);
request.EnableODataDependencyInjectionSupport("odata");
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var entityContext = new ResourceSetContext {
EntitySetBase = customers, Request = request, Url = request.GetUrlHelper()
};
// Assert
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildLink(entityContext);
Assert.Equal("http://localhost:123/odata/Customers/Default.MyAction", link.AbsoluteUri);
}
public virtual ODataOperation CreateODataOperation(IEdmOperation operation, ResourceSetContext resourceSetContext, ODataSerializerContext writeContext)
{
if (operation == null)
{
throw Error.ArgumentNull(nameof(operation));
}
if (resourceSetContext == null)
{
throw Error.ArgumentNull(nameof(resourceSetContext));
}
if (writeContext == null)
{
throw Error.ArgumentNull(nameof(writeContext));
}
ODataMetadataLevel metadataLevel = writeContext.MetadataLevel;
IEdmModel model = writeContext.Model;
if (metadataLevel != ODataMetadataLevel.Full)
{
return(null);
}
OperationLinkBuilder builder = model.GetOperationLinkBuilder(operation);
if (builder == null)
{
return(null);
}
Uri target = builder.BuildLink(resourceSetContext);
if (target == null)
{
return(null);
}
Uri baseUri = new Uri(writeContext.Request.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.Full || !builder.FollowsConventions)
{
odataOperation.Target = target;
}
return(odataOperation);
}
