[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(); }