[InlineData("GET", "http://localhost/Customers(12)/NS.SpecialCustomer/NS.GetSalary()", "GetSalaryFromSpecialCustomer_12")] // call function on derived entity type
public async Task AttriubteRouting_SelectsExpectedControllerAndAction(string method, string requestUri,
string expectedResult)
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
var controllers = new[] { typeof(CustomersController), typeof(MetadataAndServiceController), typeof(OrdersController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new MockAssembly(controllers));
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.Services.Replace(typeof(IAssembliesResolver), resolver);
config.MapODataServiceRoute("odata", "", model.Model);
HttpServer server = new HttpServer(config);
config.EnsureInitialized();
HttpClient client = new HttpClient(server);
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(method), requestUri);
// Act
var response = await client.SendAsync(request);
// Assert
if (!response.IsSuccessStatusCode)
{
Assert.False(true, await response.Content.ReadAsStringAsync());
}
var result = await response.Content.ReadAsAsync<AttributeRoutingTestODataResponse>();
Assert.Equal(expectedResult, result.Value);
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
var controllers = new[] { typeof(FilesController), typeof(MetadataController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
configuration.Services.Replace(typeof(IAssembliesResolver), resolver);
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"); // -8:00
configuration.SetTimeZoneInfo(timeZoneInfo);
configuration.Routes.Clear();
HttpServer httpServer = configuration.GetHttpServer();
configuration.MapODataServiceRoute(
routeName: "convention",
routePrefix: "convention",
model: DateTimeEdmModel.GetConventionModel());
configuration.MapODataServiceRoute(
routeName: "explicit",
routePrefix: "explicit",
model: DateTimeEdmModel.GetExplicitModel(),
batchHandler: new DefaultODataBatchHandler(httpServer));
configuration.EnsureInitialized();
}
public static void Register(HttpConfiguration config)
{
//
// Web API routes
//
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{customerid}",
defaults: new { customerid = RouteParameter.Optional });
//
// OData CRUD Routes
//
config.MapODataServiceRoute(
routeName: "odata",
routePrefix: "odata",
model: GetModel());
//
// OData Read only Routes
//
config.MapODataServiceRoute(
routeName: "odataReadOnly",
routePrefix: "odata/readonly",
model: GetReadOnlyModel());
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
var controllers = new[] { typeof(ForeignKeyCustomersController),
typeof(ForeignKeyOrdersController),
typeof(ForeignKeyCustomersNoCascadeController),
typeof(ForeignKeyOrdersNoCascadeController),
typeof(MetadataController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
configuration.Services.Replace(typeof(IAssembliesResolver), resolver);
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
configuration.Routes.Clear();
configuration.GetHttpServer();
configuration.MapODataServiceRoute(routeName: "explicit", routePrefix: "explicit",
model: ForeignKeyEdmModel.GetExplicitModel(foreignKey: true));
configuration.MapODataServiceRoute(routeName: "convention", routePrefix: "convention",
model: ForeignKeyEdmModel.GetConventionModel());
configuration.MapODataServiceRoute(routeName: "noncascade", routePrefix: "noncascade",
model: ForeignKeyEdmModel.GetExplicitModel(foreignKey: false));
configuration.EnsureInitialized();
}
public SelectExpandTest()
{
_configuration =
new[]
{
typeof(SelectExpandTestCustomersController), typeof(SelectExpandTestCustomersAliasController),
typeof(PlayersController), typeof(NonODataSelectExpandTestCustomersController),
typeof(AttributedSelectExpandCustomersController), typeof(SelectExpandTestCustomer),
typeof(SelectExpandTestSpecialCustomer), typeof(SelectExpandTestCustomerWithAlias),
typeof(SelectExpandTestOrder), typeof(SelectExpandTestSpecialOrder),
typeof(SelectExpandTestSpecialOrderWithAlias)
}.GetHttpConfiguration();
_configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
_configuration.MapODataServiceRoute("odata", "odata", GetModel());
_configuration.MapODataServiceRoute("odata-inheritance", "odata-inheritance", GetModelWithInheritance());
_configuration.MapODataServiceRoute("odata-alias", "odata-alias", GetModelWithCustomerAlias());
_configuration.MapODataServiceRoute(
"odata-alias2-inheritance",
"odata-alias2-inheritance",
GetModelWithCustomerAliasAndInheritance());
_configuration.MapODataServiceRoute("odata2", "odata2", GetModelWithProcedures());
_configuration.Routes.MapHttpRoute("api", "api/{controller}", new { controller = "NonODataSelectExpandTestCustomers" });
HttpServer server = new HttpServer(_configuration);
_client = new HttpClient(server);
}
private static void ConfigureWebApiOData(HttpConfiguration config)
{
var controllerSelector = new ODataVersionControllerSelector(config);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
// Define a versioned route
config.MapODataServiceRoute("V1RouteVersioning", "odata/v1", GetVersionedModel());
controllerSelector.RouteVersionSuffixMapping.Add("V1RouteVersioning", "V1");
// Define a versioned route that doesn't map to any controller
config.MapODataServiceRoute("odata/v2", "odata/v2", GetFakeModel());
controllerSelector.RouteVersionSuffixMapping.Add("odata/v2", "V2");
// Define a custom route with custom routing conventions
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new CustomNavigationPropertyRoutingConvention());
var customODataRoute = config.MapODataServiceRoute("CustomODataRoute", ODataRoutePrefix, GetCustomRouteModel(), batchHandler: null, pathHandler: new DefaultODataPathHandler(), routingConventions: conventions);
config.AddCustomSwaggerRoute(customODataRoute, "/Customers({Id})/Orders")
.Operation(HttpMethod.Post)
.PathParameter<int>("Id")
.BodyParameter<Order>("order");
// Define a route to a controller class that contains functions
config.MapODataServiceRoute("FunctionsODataRoute", ODataRoutePrefix, GetFunctionsEdmModel());
// Define a default non- versioned route(default route should be at the end as a last catch-all)
config.MapODataServiceRoute("DefaultODataRoute", ODataRoutePrefix, GetDefaultModel());
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
var controllers = new[] { typeof(EmployeesController), typeof(MetadataController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
configuration.Services.Replace(typeof(IAssembliesResolver), resolver);
configuration.Routes.Clear();
IEdmModel edmModel = UnBoundFunctionEdmModel.GetEdmModel();
DefaultODataPathHandler pathHandler = new DefaultODataPathHandler();
// only with attribute routing & metadata routing convention
IList<IODataRoutingConvention> routingConventions = new List<IODataRoutingConvention>
{
new AttributeRoutingConvention(edmModel, configuration),
new MetadataRoutingConvention()
};
configuration.MapODataServiceRoute("AttributeRouting", "AttributeRouting", edmModel, pathHandler, routingConventions);
// only with convention routing
configuration.MapODataServiceRoute("ConventionRouting", "ConventionRouting", edmModel, pathHandler, ODataRoutingConventions.CreateDefault());
configuration.EnsureInitialized();
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var model1 = GetEdmModel1(configuration);
var model2 = GetEdmModel2(configuration);
configuration.MapODataServiceRoute("OData1", "v1", model1, new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.MapODataServiceRoute("OData2", "v2", model2, new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.Routes.MapHttpRoute("ApiDefault", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
HttpServer server = configuration.Properties["Nuwa.HttpServerKey"] as HttpServer;
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
configuration.MapODataServiceRoute("noPrefix", "", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.MapODataServiceRoute("prefix", "prefix", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.MapODataServiceRoute("oneParameterInPrefix", "{a}", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
}
public static void Register(HttpConfiguration config)
{
// Default routes
config.MapODataServiceRoute(
routeName: "DefaultODataRoute",
routePrefix: null,
model: GetModel());
// Versioning by route prefix
config.MapODataServiceRoute(
routeName: "V2RouteVersioning",
routePrefix: "versionbyroute/v2",
model: GetModel());
// Versioning by query string
config.Routes.MapODataServiceRoute(
routeName: "V2QueryStringVersioning",
routePrefix: "versionbyquery",
model: GetModel(),
queryConstraints: new { v = "2" },
headerConstraints: null);
// Versioning by header value
config.Routes.MapODataServiceRoute(
routeName: "V2HeaderVersioning",
routePrefix: "versionbyheader",
model: GetModel(),
queryConstraints: null,
headerConstraints: new { v = "2" });
var controllerSelector = config.Services.GetService(typeof(IHttpControllerSelector)) as ODataVersionControllerSelector;
// Mapping route name to controller versioning suffix
controllerSelector.RouteVersionSuffixMapping.Add("DefaultODataRoute", "V2");
controllerSelector.RouteVersionSuffixMapping.Add("V2RouteVersioning", "V2");
controllerSelector.RouteVersionSuffixMapping.Add("V2QueryStringVersioning", "V2");
controllerSelector.RouteVersionSuffixMapping.Add("V2HeaderVersioning", "V2");
Mapper.CreateMap<DbProduct, Product>()
.ForMember(dest => dest.Family, opt => opt.Ignore());
Mapper.CreateMap<Product, DbProduct>();
Mapper.CreateMap<DbProductFamily, ProductFamily>()
.ForMember(dest => dest.Supplier, opt => opt.Ignore())
.ForMember(dest => dest.Products, opt => opt.Ignore());
Mapper.CreateMap<ProductFamily, DbProductFamily>();
Mapper.CreateMap<DbSupplier, Supplier>()
.ForMember(dest => dest.ProductFamilies, opt => opt.Ignore());
Mapper.CreateMap<Supplier, DbSupplier>();
Mapper.CreateMap<DbAddress, Address>();
Mapper.CreateMap<Address, DbAddress>();
Mapper.AssertConfigurationIsValid();
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
var controllers = new[] { typeof(EmployeesController), typeof(MetadataController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
configuration.Services.Replace(typeof(IAssembliesResolver), resolver);
configuration.Routes.Clear();
configuration.MapODataServiceRoute("convention", "convention", EnumsEdmModel.GetConventionModel());
configuration.MapODataServiceRoute("explicit", "explicit", EnumsEdmModel.GetExplicitModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.EnsureInitialized();
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
var controllers = new[] { typeof(UmbrellaController), typeof(MonstersIncController), typeof(MetadataController), typeof(PartnersController) };
TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers));
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
configuration.Services.Replace(typeof(IAssembliesResolver), resolver);
configuration.Routes.Clear();
configuration.MapODataServiceRoute("ModelBuilderWithConventionRouting", "expCon", SingletonEdmModel.GetExplicitModel("Umbrella"), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.MapODataServiceRoute("ModelBuilderWithAttributeRouting", "expAttr", SingletonEdmModel.GetExplicitModel("MonstersInc"));
configuration.MapODataServiceRoute("ConventionBuilderwithConventionRouting", "conCon", SingletonEdmModel.GetConventionModel("Umbrella"), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.MapODataServiceRoute("ConventionBuilderwithAttributeRouting", "conAttr", SingletonEdmModel.GetConventionModel("MonstersInc"));
configuration.EnsureInitialized();
}
public static void RegisterOData(HttpConfiguration config)
{
var masterBuilder = new ODataConventionModelBuilder();
RegisterMasterModels(masterBuilder);
config.MapODataServiceRoute("odataMaster", "odata", masterBuilder.GetEdmModel());
// Issue 57: The below portion causes a failure
// note: You can comment out this portion and Swagger will work
var tenantBuilder = new ODataConventionModelBuilder();
RegisterTenantModels(tenantBuilder);
var tenantODataRoute = config.MapODataServiceRoute("odataTenant", "odata/{tenantId}", tenantBuilder.GetEdmModel());
// maybe adding a default would help Swagger Odata...?
//tenantODataRoute.Defaults.Add("tenantId", 1);
}
private HttpConfiguration ConfigureWebApi()
{
var config = new HttpConfiguration();
// Attribute routing.
config.MapHttpAttributeRoutes();
config.MapODataServiceRoute("odata","odata", GetEdmModel(), null);
//config.MapODataServiceRoute("odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.EnsureInitialized();
//All routing uses attributes to be explicit
//config.Routes.MapHttpRoute(
// "aalogAPIV1",
// "api/aalog/V1/",
// new { controller = "aaLog" });
//config.Routes.MapHttpRoute(
// "DefaultApi",
// "api/{controller}/{id}",
// new { id = RouteParameter.Optional });
//var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
//config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
return config;
}
public void Configuration(IAppBuilder appBuilder)
{
// Set up server configuration
var config = new HttpConfiguration();
config.MapODataServiceRoute(routeName: "OData", routePrefix: "odata", model: GetEdmModel());
appBuilder.UseWebApi(config);
}
public void Convention_GeneratesUri_ForActionBoundToEntity()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
var action = builder.EntityType<Customer>().Action("MyAction");
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.ODataProperties().RouteName = "odata";
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var edmType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Customer");
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = customers, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, edmType.AsReference(), new Customer { Id = 109 });
// Assert
var edmAction = model.SchemaElements.OfType<IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildActionLink(entityContext);
Assert.Equal("http://localhost:123/odata/Customers(109)/Default.MyAction", link.AbsoluteUri);
}
public static void Configuration(IAppBuilder builder)
{
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.MapODataServiceRoute(routeName: "OData", routePrefix: "odata", model: ODataModels.GetModel());
builder.UseWebApi(config);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
//config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
config.EnableCors();
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "Demos";
builder.ContainerName = "DefaultContainer";
builder.EntitySet<Person>("Peoples");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: "odata",
model: builder.GetEdmModel());
// config.MapODataServiceRoute("odata", "odata", GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.EnsureInitialized();
}
public void AdvancedMapODataServiceRoute_ConfiguresARoute_WithAnODataRouteAndVersionConstraints()
{
// Arrange
HttpRouteCollection routes = new HttpRouteCollection();
HttpConfiguration config = new HttpConfiguration(routes);
IEdmModel model = new EdmModel();
string routeName = "name";
string routePrefix = "prefix";
var pathHandler = new DefaultODataPathHandler();
var conventions = new List<IODataRoutingConvention>();
// Act
config.MapODataServiceRoute(routeName, routePrefix, model, pathHandler, conventions);
// Assert
IHttpRoute odataRoute = routes[routeName];
Assert.Single(routes);
Assert.Equal(routePrefix + "/{*odataPath}", odataRoute.RouteTemplate);
Assert.Equal(2, odataRoute.Constraints.Count);
var odataPathConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataPathRouteConstraint>());
Assert.Same(model, odataPathConstraint.EdmModel);
Assert.IsType<DefaultODataPathHandler>(odataPathConstraint.PathHandler);
Assert.NotNull(odataPathConstraint.RoutingConventions);
var odataVersionConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataVersionConstraint>());
Assert.NotNull(odataVersionConstraint.Version);
Assert.Equal(ODataVersion.V4, odataVersionConstraint.Version);
}
public ODataSingletonTest()
{
_configuration = new[] { typeof(OscorpController), typeof(OscorpSubsController) }.GetHttpConfiguration();
_configuration.MapODataServiceRoute("odata", "odata", GetEdmModel());
HttpServer server = new HttpServer(_configuration);
_client = new HttpClient(server);
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Vehicle>("vehicles");
builder.EntitySet<Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainer.FindEntitySet("vehicles");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = routeName;
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehiclesEdmEntitySet);
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehiclesEdmEntitySet, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2009, Name = "Accord" });
Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.Default);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.OData.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri);
}
protected override void ConfigureController(HttpConfiguration config)
{
config.MapODataServiceRoute(
routeName: "OData funcions",
routePrefix: "functions",
model: GetEdmModel(config));
}
public static void Register(HttpConfiguration config)
{
// Web API 配置和服务
// 将 Web API 配置为仅使用不记名令牌身份验证。
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API 路由
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//有关OData
//使用ODataConventionModelBuilder创建EDM使用了一些惯例
//如果要对创建EDM有更多的控制，使用ODataModelBuilder
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Product>("Products");//创建EntityDataModel(EDM)
builder.EntitySet<Supplier>("Suppliers");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: "odata",
model: builder.GetEdmModel());
}
public static void Configuration(IAppBuilder builder)
{
HttpConfiguration config = new HttpConfiguration();
IEdmModel edmModel = ODataModels.GetModel();
config.MapODataServiceRoute(routeName: "OData", routePrefix: "odata", model: edmModel);
builder.UseWebApi(config);
}
public static void Register(HttpConfiguration config)
{
config.EnableCors();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Exercise>("Exercises");
builder.EntitySet<Workout>("Workouts");
builder.EntitySet<WorkoutSession>("WorkoutSessions");
builder.EntitySet<ExerciseSet>("ExerciseSets");
builder.EnableLowerCamelCase();
// Need this. Otherwise SingleResult<WorkoutSession> GetWorkoutSession tries to return null and then fails to serialize the null value.
config.MapODataServiceRoute(
"odata"
, "odata"
, builder.GetEdmModel()
, defaultHandler: HttpClientFactory.CreatePipeline(
innerHandler: new HttpControllerDispatcher(config)
, handlers: new[] { new ODataNullValueMessageHandler() }));
}
public void Apply_Doesnot_Override_UserConfiguration()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet<Vehicle>("vehicles");
var car = builder.AddEntityType(typeof(Car));
var paintAction = vehicles.EntityType.Action("Paint");
paintAction.HasActionLink(ctxt => new Uri("http://localhost/ActionTestWorks"), followsConventions: false);
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
convention.Apply(paintAction, builder);
IEdmModel model = builder.GetEdmModel();
var vehiclesEdmSet = model.EntityContainer.FindEntitySet("vehicles");
var carEdmType = model.FindDeclaredType("System.Web.OData.Builder.TestModels.Car") as IEdmEntityType;
var paintEdmAction =
model.GetAvailableProcedures(
model.FindDeclaredType("System.Web.OData.Builder.TestModels.Car") as IEdmEntityType).Single()
as IEdmAction;
Assert.NotNull(paintEdmAction);
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(paintEdmAction);
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehiclesEdmSet, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carEdmType.AsReference(), new Car { Model = 2009, Name = "Contoso" });
Uri link = actionLinkBuilder.BuildActionLink(entityContext);
Assert.Equal("http://localhost/ActionTestWorks", link.AbsoluteUri);
}
public static void Register(HttpConfiguration config)
{
Database.SetInitializer(new DatabaseInitialize());
var model = ModelBuilder.GetEdmModel();
// Wrap most routing conventions to redirect requests for e.g. /Products/... to the ProductsV2Controller.
var defaultConventions = ODataRoutingConventions.CreateDefaultWithAttributeRouting(config, model);
var conventions = new List<IODataRoutingConvention>();
foreach (var convention in defaultConventions)
{
if (convention is MetadataRoutingConvention ||
convention is AttributeRoutingConvention)
{
// Don't need to special case these conventions.
conventions.Add(convention);
}
else
{
conventions.Add(new VersionedRoutingConvention(convention, "V2"));
}
}
var odataRoute = config.MapODataServiceRoute(
routeName: "odataV2",
routePrefix: "odata",
model: model,
pathHandler: new DefaultODataPathHandler(),
routingConventions: conventions);
var constraint = new ODataVersionRouteConstraint(new { v = "2" });
odataRoute.Constraints.Add("VersionConstraintV2", constraint);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// OData
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Player>("Players");
builder.EntitySet<BattingDetail>("BattingDetails");
builder.EntitySet<BowlingDetail>("BowlingDetails");
builder.EntitySet<Country>("Countrys");
builder.EntitySet<Match>("Matches").EntityType.HasKey(m => m.MatchNumber);
config.AddODataQueryFilter();
config.MapODataServiceRoute(
routeName: "odata",
routePrefix: "odata",
model: builder.GetEdmModel());
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureWebApi(IAppBuilder app)
{
var config = new HttpConfiguration();
// Web API routes
config.MapHttpAttributeRoutes(); //NB Must come before OData route mapping
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
// OData: Create the OData model. Here, we're using the convention model builder that will use OData
// convention defaults for model creation and routing.
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
// All entity properties should be in lower camel case
builder.EnableLowerCamelCase();
// Because PersonSearchHit inherits from SearchHit, we'll ignore it.
// This gets around the convention builder's decision to create an entity out of the SearchHit object.
builder.Ignore<PersonSearchHit>();
// Create two entity sets:
// One for search features and one that will retrieve a given person.
builder.EntitySet<IndexSearch>("Search");
builder.EntitySet<Person>("People");
// OData model registration and route creation
config.MapODataServiceRoute("ODataRoute", null, builder.GetEdmModel());
// Set up the bearer token that will be required to do OData calls.
WebApiConfigBearerToken.Configure(config);
app.UseWebApi(config);
}
public static void Register(HttpConfiguration httpConfiguration)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ODataV4TestService.Models";
builder.EntitySet<Product>("Products");
builder.EntitySet<SuppliedProduct>("SuppliedProducts");
builder.EntitySet<Supplier>("Suppliers");
builder.EntitySet<Product>("OtherProducts");
builder.ComplexType<Description>();
builder.EntityType<Product>()
.Action("Rate")
.Parameter<int>("Rating");
builder.EntityType<Product>().Collection
.Function("Best")
.ReturnsCollectionFromEntitySet<Product>("Products");
var funcConfig = builder
.EntityType<Product>()
.Function("RelatedProducts")
.SetBindingParameter("product", builder.GetTypeConfigurationOrNull(typeof(Product)))
//.AddParameter("start", new PrimitiveTypeConfiguration(builder, builder.GetTypeConfigurationOrNull(typeof(DateTimeOffset)), typeof(DateTimeOffset)).
.ReturnsCollectionFromEntitySet<Product>("Products");
funcConfig
.Parameter<DateTimeOffset>("start");
funcConfig
.Parameter<DateTimeOffset>("end");
//builder.Function("GetSalesTaxRate")
// .Returns<double>()
// .Parameter<int>("PostalCode");
builder.EntitySet<Account>("Accounts");
builder.EntityType<PaymentInstrument>()
.Collection
.Function("GetCount")
.Returns<int>()
.Parameter<string>("NameContains");
var model = builder.GetEdmModel();
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new AttributeRoutingConvention(model, httpConfiguration));
var server = new BatchServer(httpConfiguration);
httpConfiguration.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: model,
pathHandler: new DefaultODataPathHandler(),
routingConventions: conventions,
batchHandler: new DefaultODataBatchHandler(server));
httpConfiguration.MessageHandlers.Add(new TracingMessageHandler());
}
/// <summary>
/// Instructs WebApi to map one or more of the registered Restier APIs to the specified Routes, each with it's own isolated Dependency Injection container.
/// </summary>
/// <param name="config">The <see cref="HttpConfiguration"/> instance to enhance.</param>
/// <param name="configureRoutesAction">The action for configuring a set of routes.</param>
/// <param name="httpServer">The HttpServer instance to create the routes on.</param>
/// <returns>The <see cref="HttpConfiguration"/> instance to allow for fluent method chaining.</returns>
/// <example>
/// <code>
/// config.MapRestier(builder =>
/// builder
/// .MapApiRoute<SomeApi>("SomeApiV1", "someapi/")
/// .MapApiRoute<AnotherApi>("AnotherApiV1", "anotherapi/")
/// );
/// </code>
/// </example>
public static HttpConfiguration MapRestier(this HttpConfiguration config, Action <RestierRouteBuilder> configureRoutesAction, HttpServer httpServer)
{
Ensure.NotNull(configureRoutesAction, nameof(configureRoutesAction));
var rrb = new RestierRouteBuilder();
configureRoutesAction.Invoke(rrb);
foreach (var route in rrb.Routes)
{
ODataBatchHandler batchHandler = null;
var conventions = CreateRestierRoutingConventions(config, route.Key);
if (route.Value.AllowBatching)
{
if (httpServer == null)
{
throw new ArgumentNullException(nameof(httpServer), OwinException);
}
#pragma warning disable IDE0067 // Dispose objects before losing scope
batchHandler = new RestierBatchHandler(httpServer)
{
ODataRouteName = route.Key
};
#pragma warning restore IDE0067 // Dispose objects before losing scope
}
var odataRoute = config.MapODataServiceRoute(route.Key, route.Value.RoutePrefix, (containerBuilder, routeName) =>
{
var rcb = containerBuilder as RestierContainerBuilder;
rcb.routeBuilder = rrb;
rcb.RouteName = routeName;
containerBuilder.AddService <IEnumerable <IODataRoutingConvention> >(ServiceLifetime.Singleton, sp => conventions);
if (batchHandler != null)
{
//RWM: DO NOT simplify this generic signature. It HAS to stay this way, otherwise the code breaks.
containerBuilder.AddService <ODataBatchHandler>(ServiceLifetime.Singleton, sp => batchHandler);
}
});
}
return(config);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
// Web-API-Konfiguration und -Dienste
// Web-API-Routen
config.MapHttpAttributeRoutes();
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Contracts.IResident>("Residents");
//config.AddODataQueryFilter(new System.Web.Http.Filters.ActionFilterAttribute() );
//config.Routes.MapODataRoute("ODataRoute", "odata", GetEdmModel());
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Models.ResidentViewModel>("Residents");
//config.MapODataServiceRoute(
// routeName: "ODataRoute",
// routePrefix: "odata",
// model: builder.GetEdmModel());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Models.ResidentViewModel>("ResidentViewModels");
config.AddODataQueryFilter();
//config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//config.MapODataServiceRoute( "odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.EnsureInitialized();
}
