public static void Register(HttpConfiguration config) { Database.SetInitializer(new CreateDatabaseIfNotExists <ProductsContext>()); //Create sample data for the demo DataSeeder.CreateData(); UnityConfig.RegisterComponents(); var builder = new ODataConventionModelBuilder(); builder.EntitySet <Product>("Products"); config.Routes.MapODataRoute( routeName: "odata", routePrefix: "odata", model: builder.GetEdmModel(), pathHandler: UnityConfig.UnityContainer.Resolve <CustomDataPathHandler>(), routingConventions: ODataRoutingConventions.CreateDefault()); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional }); }
public static void Register(HttpConfiguration config) { config.MapHttpAttributeRoutes(); var httpServer = new HttpServer(config); config.AddApiVersioning(); config.Select().Expand().Filter().OrderBy().MaxTop(null).Count(); var modelBuilder = new VersionedODataModelBuilder(config) { ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(), ModelConfigurations = { new FlightPlanConfiguration(), new FlightDetailsConfiguration() } }; var models = modelBuilder.GetEdmModels(); var batchHandler = new DefaultODataBatchHandler(httpServer); var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new CompositeKeyRoutingConvention()); config.MapVersionedODataRoutes("odata", "data/v{apiVersion}", models, ConfigureODataServices, batchHandler); //config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }); //config.MapVersionedODataRoutes("odata", "data/v{apiVersion}", models, new DefaultODataPathHandler(),conventions, batchHandler); }
public static void Register(HttpConfiguration config) { // Web API configuration and services var cors = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(cors); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Basket>("Baskets"); builder.EntitySet <Configuration>("Configurations"); builder.EntitySet <Face>("Faces"); builder.EntitySet <StoreTree>("StoreTrees"); builder.EntitySet <ZoneMonitoring>("ZoneMonitorings"); IList <IODataRoutingConvention> conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new CountODataRoutingConvention()); // allow $count segments in WebAPI OData config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel(), new CountODataPathHandler(), conventions); }
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.Routes.MapHttpRoute( name: "ActionApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); var routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new CreateNavigationPropertyRoutingConvention()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Cliente>("Cliente"); builder.EntitySet <Equipamento>("Equipamento"); builder.EntitySet <Motorista>("Motorista"); builder.EntitySet <Veiculo>("Veiculo"); builder.EntitySet <SimCard>("SimCard"); builder.EntitySet <Usuario>("Usuario"); builder.EntitySet <Perfil>("Perfil"); config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel()); }
public static void RegisterODataModel(HttpConfiguration config) { ODataBatchHandler odataBatchHandler = new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer); ODataModelBuilder builder = new ODataConventionModelBuilder(); RegisterEntities(builder); RegisterFunctions(builder); RegisterActions(builder); var conventions = ODataRoutingConventions.CreateDefault(); //conventions.Insert(0, new CityCustomConvention()); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: "odata", model: builder.GetEdmModel(), pathHandler: new DefaultODataPathHandler(), routingConventions: conventions, batchHandler: odataBatchHandler ); config.MaxTop(null).OrderBy().Filter(); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(CustomersController), typeof(OrdersController), typeof(PeopleController), typeof(CompaniesController), typeof(MetadataController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.EnableAlternateKeys(true); configuration.Routes.Clear(); IEdmModel model = AlternateKeysEdmModel.GetEdmModel(); configuration.MapODataServiceRoute("odata", "odata", model: AlternateKeysEdmModel.GetEdmModel()); var conventions = ODataRoutingConventions.CreateDefault(); configuration.MapODataServiceRoute("odata1", "convention", model, new DefaultODataPathHandler(), conventions); configuration.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Stavka>("Stavke"); builder.EntitySet <Zaposlenik>("Zaposlenici"); builder.EntitySet <Racun>("Racuni"); //Configure action of adding stavka to racun on Post: ~odata/Racuni(1)/AddStavkaById var addStavkaByIdToRacunAction = builder.Entity <Racun>().Action("AddStavkaById"); addStavkaByIdToRacunAction.Parameter <int>("Value"); //Configure action of adding stavka to racun on Post: ~odata/Racuni(1)/AddStavka var addStavkaToRacunAction = builder.Entity <Racun>().Action("AddStavka"); addStavkaToRacunAction.Parameter <StavkaDTO>("Value"); IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new CountODataRoutingConvention()); config.MessageHandlers.Add(new LoggingRequestHandler()); config.EnableQuerySupport(); config.Routes.MapODataServiceRoute( "ODataRoute", null, builder.GetEdmModel(), new CountODataPathHandler(), routingConventions ); }
public static ODataRoute CustomMapODataServiceRoute(HttpRouteCollection routes, string routeName, string routePrefix, HttpMessageHandler handler = null) { if (!string.IsNullOrEmpty(routePrefix)) { int prefixLastIndex = routePrefix.Length - 1; if (routePrefix[prefixLastIndex] == '/') { routePrefix = routePrefix.Substring(0, routePrefix.Length - 1); } } var pathHandler = new DefaultODataPathHandler(); var routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new DynamicRoutingConvention()); var modelProvider = GetModelFuncFromRequest(); var routeConstraint = new CustomODataPathRouteConstraint(pathHandler, modelProvider, routeName, routingConventions); var odataRoute = new CustomODataRoute( routePrefix: routePrefix, pathConstraint: routeConstraint, defaults: null, constraints: null, dataTokens: null, handler: handler); routes.Add(routeName, odataRoute); return(odataRoute); }
public static IEndpointRouteBuilder MapDynamicODataServiceRoute(this IEndpointRouteBuilder builder, string routeName, string routePrefix, IDataSource dataSource) { IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new DynamicODataRoutingConvention()); return(builder.MapDynamicODataServiceRoute(routeName, routePrefix, null, routingConventions, dataSource)); }
public void Start() { var config = GlobalConfiguration.Configuration; var configBroadcaster = new WebApiConfigurationBroadcaster { Configuration = config, ModelBuilder = new ODataConventionModelBuilder(), RoutingConventions = ODataRoutingConventions.CreateDefault() }; config.DependencyResolver = new AutofacWebApiDependencyResolver(); config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented; config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new WebApiContractResolver(config.Formatters.JsonFormatter); config.Formatters.JsonFormatter.MediaTypeMappings.Add(new QueryStringMapping("format", "json", "application/json")); config.Formatters.XmlFormatter.MediaTypeMappings.Add(new QueryStringMapping("format", "xml", "application/xml")); config.AddODataQueryFilter(new WebApiQueryableAttribute()); var corsAttribute = new EnableCorsAttribute("*", "*", "*", WebApiGlobal.Header.CorsExposed); config.EnableCors(corsAttribute); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; var configPublisher = (IWebApiConfigurationPublisher)config.DependencyResolver.GetService(typeof(IWebApiConfigurationPublisher)); configPublisher.Configure(configBroadcaster); //config.Services.Insert(typeof(ModelBinderProvider), 0, // new SimpleModelBinderProvider(typeof(Address), new AddressModelBinder())); try { if (!config.Routes.ContainsKey(WebApiGlobal.RouteNameUploads)) { config.Routes.MapHttpRoute(WebApiGlobal.RouteNameUploads, "api/{version}/Uploads/{action}/{id}", new { version = "v1", controller = "Uploads", action = "Index", id = RouteParameter.Optional }); } if (!config.Routes.ContainsKey(WebApiGlobal.RouteNameDefaultApi)) { config.Routes.MapHttpRoute(WebApiGlobal.RouteNameDefaultApi, "api/{version}/{controller}/{id}", new { version = "v1", controller = "Home", id = RouteParameter.Optional }); } } catch (Exception) { } try { if (!config.Routes.ContainsKey(WebApiGlobal.RouteNameDefaultOdata)) { config.Routes.MapODataServiceRoute(WebApiGlobal.RouteNameDefaultOdata, WebApiGlobal.MostRecentOdataPath, configBroadcaster.ModelBuilder.GetEdmModel(), new DefaultODataPathHandler(), configBroadcaster.RoutingConventions); } } catch (Exception) { } }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes // Add the CompositeKeyRoutingConvention. var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new CompositeKeyRoutingConvention()); config.MapHttpAttributeRoutes(); config.MapODataServiceRoute("ODataRoute" , "odata" , StudyOdataModelBuilder.CreateConventionalEdm() , pathHandler: new DefaultODataPathHandler() , routingConventions: conventions); config.Routes.MapHttpRoute( name: "ResourceById", routeTemplate: "api/{controller}({keys})" ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public static ODataRoute MapDynamicODataServiceRoute( this HttpRouteCollection routes, string routeName, string routePrefix, HttpServer httpServer) { IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new DynamicODataRoutingConvention()); if (!string.IsNullOrEmpty(routePrefix)) { int prefixLastIndex = routePrefix.Length - 1; if (routePrefix[prefixLastIndex] == '/') { routePrefix = routePrefix.Substring(0, routePrefix.Length - 1); } } DynamicODataPathRouteConstraint routeConstraint = new DynamicODataPathRouteConstraint( new DefaultODataPathHandler(), GetModelFuncFromRequest(), routeName, routingConventions); DynamicODataRoute odataRoute = new DynamicODataRoute(routePrefix, routeConstraint); routes.Add(routeName, odataRoute); return(odataRoute); }
public static void UpdateConfiguration(HttpConfiguration configuration) { configuration.Routes.Clear(); configuration.Routes.MapODataServiceRoute("odata", "odata", GetEdmModel(), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault()); configuration.MessageHandlers.Add(new ETagMessageHandler()); }
public static void ConfigureOData(this IApplicationBuilder app, IServiceProvider serviceProvider) { var defaultConventions = ODataRoutingConventions.CreateDefault(); // restricts access to /$metadata url var conventions = defaultConventions.Except( defaultConventions.OfType <MetadataRoutingConvention>()); // uri resolver var uriResolver = new UnqualifiedODataUriResolver { EnableCaseInsensitive = true }; app.UseMvc(routeBuilder => { // allows to use EnableQuery on non-OData routing routeBuilder.EnableDependencyInjection(); // available operations routeBuilder.Filter().Expand().Select().OrderBy().MaxTop(100).Count(); routeBuilder.MapODataServiceRoute("odata", "api", builder => { builder.AddService(ServiceLifetime.Singleton, _ => GetEdmModel(serviceProvider)); builder.AddService(ServiceLifetime.Singleton, _ => conventions); builder.AddService <ODataUriResolver>(ServiceLifetime.Singleton, _ => uriResolver); }); }); }
public CompositeKeyTest() { _configuration = new[] { typeof(MetadataController), typeof(DriverReleaseLifecycleDescriptionsController), typeof(AnyController) }.GetHttpConfiguration(); IEdmModel model = CompositeEdmModel.GetEdmModel(); // only convention routings var routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new CompositeKeyRoutingConvention()); _configuration.MapODataServiceRoute("odata1", "odata", model, new DefaultODataPathHandler(), routingConventions); // only attribute routings var attrRouting = new AttributeRoutingConvention(model, _configuration); IList <IODataRoutingConvention> attributeRoutingConventions = new List <IODataRoutingConvention> { attrRouting }; _configuration.MapODataServiceRoute("odata2", "attribute", model, new DefaultODataPathHandler(), attributeRoutingConventions); HttpServer server = new HttpServer(_configuration); _client = new HttpClient(server); }
private static HttpClient GetClient(IEdmModel model) { var config = new[] { typeof(MetadataController), typeof(PeopleController) }.GetHttpConfiguration(); config.Filter(); var routings = ODataRoutingConventions.CreateDefault(); routings.Insert(0, new DynamicDollarValueRoutingConvention()); config.MapODataServiceRoute("odata", "odata", builder => builder.AddService(ServiceLifetime.Singleton, sp => model) .AddService <IEnumerable <IODataRoutingConvention> >(ServiceLifetime.Singleton, sp => routings)); var formatters = ODataMediaTypeFormatters.Create(); foreach (var oDataMediaTypeFormatter in formatters) { oDataMediaTypeFormatter.MediaTypeMappings.Insert(0, new ODataDynamicValueMediaTypeMapping()); } config.Formatters.InsertRange(0, formatters); HttpServer server = new HttpServer(config); return(new HttpClient(server)); }
private static void RegisterOData(HttpConfiguration httpConfiguration) { httpConfiguration.AddODataQueryFilter(); var builder = new ODataConventionModelBuilder(); var packages = builder.EntitySet <V2FeedPackage>("Packages"); var search = builder.Action("Search"); search.ReturnsCollectionFromEntitySet <V2FeedPackage>("Packages"); search.Parameter <string>("searchTerm"); var model = builder.GetEdmModel(); var packageType = model.FindDeclaredType(typeof(V2FeedPackage).FullName); model.SetHasDefaultStream((IEdmEntityType)packageType, true); var handler = new DefaultODataPathHandler(); var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new NonBindableActionRoutingConvention("Packages")); httpConfiguration.Routes.MapODataServiceRoute("ODataDefault", "", model, handler, conventions); httpConfiguration.Routes.MapODataServiceRoute("ODataNamed", "{feedName}", model, handler, conventions); }
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()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseRouting(); app.UseAuthorization(); app.UseODataBatching(); app.UseEndpoints(endpoints => { endpoints.Select().Expand().Filter().OrderBy().MaxTop(100).Count(); var routeBuilder = endpoints.MapODataRoute("odataPrefix", "odata/{dataSource}", containerBuilder => { containerBuilder.AddService(Microsoft.OData.ServiceLifetime.Scoped, typeof(IEdmModel), sp => { var serviceScope = sp.GetRequiredService <HttpRequestScope>(); IEdmModel model = DataSourceProvider.GetEdmModel(serviceScope.HttpRequest); return(model); }); containerBuilder.AddService(Microsoft.OData.ServiceLifetime.Scoped, typeof(IEnumerable <IODataRoutingConvention>), sp => { IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new MatchAllRoutingConvention()); return(routingConventions.ToList().AsEnumerable()); }); }); }); }
public static void Register(HttpConfiguration config) { // Build model var model = GetEdmModel(); // Insert conventions to make NuGet-compatible OData feed possible var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new EntitySetCountRoutingConvention()); conventions.Insert(0, new ActionCountRoutingConvention("ODataV1Feed")); conventions.Insert(0, new MethodNameActionRoutingConvention("ODataV1Feed")); conventions.Insert(0, new EntitySetPropertyRoutingConvention("ODataV1Feed")); conventions.Insert(0, new CompositeKeyRoutingConvention()); // Translate all requests to use V2FeedController instead of PackagesController conventions = conventions.Select(c => new ControllerAliasingODataRoutingConvention(c, "Packages", "ODataV1Feed")) .Cast <IODataRoutingConvention>() .ToList(); // Add OData routes config.Routes.MapODataServiceRoute("api-v1-odata1", "api/v1/FeedService.svc", model, new CountODataPathHandler(), conventions, new ODataServiceVersionHeaderPropagatingBatchHandler(GlobalConfiguration.DefaultServer)); config.Routes.MapODataServiceRoute("api-v1-odata2", "api/v1", model, new CountODataPathHandler(), conventions, new ODataServiceVersionHeaderPropagatingBatchHandler(GlobalConfiguration.DefaultServer)); config.Routes.MapODataServiceRoute("api-v1-odata3", "v1/FeedService.svc", model, new CountODataPathHandler(), conventions, new ODataServiceVersionHeaderPropagatingBatchHandler(GlobalConfiguration.DefaultServer)); }
static void Main(string[] args) { HttpSelfHostServer server = null; try { // Set up server configuration HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(_baseAddress); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; // Add $format support config.MessageHandlers.Add(new FormatQueryMessageHandler()); // Add NavigationRoutingConvention2 to support POST, PUT, PATCH and DELETE on navigation property var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new CustomNavigationRoutingConvention()); // Enables OData support by adding an OData route and enabling querying support for OData. // Action selector and odata media type formatters will be registered in per-controller configuration only config.Routes.MapODataRoute( routeName: "OData", routePrefix: null, model: ModelBuilder.GetEdmModel(), pathHandler: new DefaultODataPathHandler(), routingConventions: conventions); // Enable queryable support and allow $format query config.EnableQuerySupport(new QueryableAttribute { AllowedQueryOptions = AllowedQueryOptions.Supported | AllowedQueryOptions.Format }); // To disable tracing in your application, please comment out or remove the following line of code // For more information, refer to: http://www.asp.net/web-api config.EnableSystemDiagnosticsTracing(); config.Filters.Add(new ModelValidationFilterAttribute()); // Create server server = new HttpSelfHostServer(config); // Start listening server.OpenAsync().Wait(); Console.WriteLine("Listening on " + _baseAddress); } catch (Exception e) { Console.WriteLine("Could not start server: {0}", e.GetBaseException().Message); } finally { Console.WriteLine("Hit ENTER to exit..."); Console.ReadLine(); if (server != null) { // Stop listening server.CloseAsync().Wait(); } } }
public static ODataRoute CustomMapODataServiceRoute(this HttpConfiguration configuration, string routeName, string routePrefix) { ODataRoute route = configuration.MapODataServiceRoute(routeName, routePrefix, builder => { // Get the model from the datasource of the current request: model-per-request. builder.AddService(ServiceLifetime.Scoped, sp => { IHttpRequestMessageProvider requestMessageProvider = sp.GetRequiredService <IHttpRequestMessageProvider>(); string dataSource = requestMessageProvider.Request.Properties[Constants.ODataDataSource] as string; IEdmModel model = DataSourceProvider.GetEdmModel(dataSource); return(model); }); // Create a request provider for every request. This is a workaround for the missing HttpContext of a self-hosted webapi. builder.AddService <IHttpRequestMessageProvider>(ServiceLifetime.Scoped, sp => new HttpRequestMessageProvider()); // The routing conventions are registered as singleton. builder.AddService(ServiceLifetime.Singleton, sp => { IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new MatchAllRoutingConvention()); return(routingConventions.ToList().AsEnumerable()); }); }); CustomODataRoute odataRoute = new CustomODataRoute(route.RoutePrefix, new CustomODataPathRouteConstraint(routeName)); configuration.Routes.Remove(routeName); configuration.Routes.Add(routeName, odataRoute); return(odataRoute); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } app.UseMvc( routeBuilder => { routeBuilder.Count().Filter().OrderBy().Expand().Select().MaxTop(null); var conventions = ODataRoutingConventions.CreateDefault(); int index = 0; // Insert the custom convention at the start of the collection. foreach (var item in ODataRoutingConventions.CreateDefault()) { conventions.Insert(index++, item); } routeBuilder.MapODataServiceRoute("ODataRoute", "odata", GetEdmModel(), new DefaultODataPathHandler(), conventions); } ); app.UseHttpsRedirection(); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseCors(police => { police.AllowAnyOrigin(); police.AllowAnyMethod(); police.AllowAnyHeader(); }); app.UseAuthentication(); app.UseMvcWithDefaultRoute(); app.UseMvc(b => { b.Select().Expand().Filter().OrderBy().MaxTop(100).Count(); IList <IODataRoutingConvention> conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new MatchRoutingConvention()); b.MapODataServiceRoute("odata", "odata", ODataConfig.GetEdmModel(), new DefaultODataPathHandler(), conventions); //b.MapODataServiceRoute("odata", "odata", ODataConfig.GetEdmModel()); b.EnableDependencyInjection(); b.MapRoute( name: "default", template: "api/{controller}/{action}/{id?}"); }); AutoMapperConfig.InitAutoMapperConfig(); }
public static void Register(HttpConfiguration config) { //DateTimeKind of UTC are serialised correctly with the Z suffix config.SetTimeZoneInfo(System.TimeZoneInfo.Utc); // Web API routes //This has to be called before the following OData mapping, so also before WebApi mapping //AND Support inheritance of Route attributes for generic web api config.MapHttpAttributeRoutes(new CustomDirectRouteProvider()); //Enabling OData Query Options config.Select().Expand().Filter().OrderBy().MaxTop(null).Count(); // Create the default collection of built-in conventions. var conventions = ODataRoutingConventions.CreateDefault(); // Insert the custom convention at the start of the collection. conventions.Insert(0, new NavigationIndexRoutingConvention()); //config.MapODataServiceRoute("ODataRoute", "odata",GetEdmModel(),new DefaultODataPathHandler(),conventions, new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)); var odatarouteConf = config.MapODataServiceRoute("odata", "api", GetEdmModel()); // INSERT CUSTOM FORMATTERS //var odataFormatters = ODataMediaTypeFormatters.Create(new CustomODataSerializerProvider(),new CustomODataDeSerializerProvider()); //config.Formatters.InsertRange(0, odataFormatters); config.EnsureInitialized(); GlobalConfiguration.Configuration.EnableDependencyInjection(); }
protected override void UpdateConfiguration(WebRouteConfiguration configuration) { var conventions = ODataRoutingConventions.CreateDefault(); configuration.MapODataServiceRoute("CustomActionConventions", "CustomActionConventions", GetCustomActionConventionsModel(configuration), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault()); configuration.AddODataQueryFilter(); }
public void MapODataRoutes(HttpConfiguration config) { var builder = new NuGetWebApiODataModelBuilder(); builder.Build(); config.Formatters.InsertRange(0, ODataMediaTypeFormatters.Create( new ODataPackageDefaultStreamAwareSerializerProvider(), new DefaultODataDeserializerProvider())); var conventions = new List <IODataRoutingConvention> { new CompositeKeyRoutingConvention(), new CompositeKeyPropertyRoutingConvention(), new NonBindableActionRoutingConvention("PackagesOData"), new EntitySetCountRoutingConvention(), new NonBindableActionCountRoutingConvention("PackagesOData") }; conventions.AddRange(ODataRoutingConventions.CreateDefault()); conventions = conventions.Select(c => new ControllerAliasingODataRoutingConvention(c, "Packages", "PackagesOData")).Cast <IODataRoutingConvention>().ToList(); config.Routes.MapODataServiceRoute( RouteNames.Packages.Feed, ODataRoutePath, builder.Model, new CountODataPathHandler(), conventions, new HeaderCascadingODataBatchHandler(new BatchHttpServer(config))); }
public static void RegisterDynamicOData(this HttpConfiguration config, Action <ODataServiceSettings> configureSettings) { var routeName = $"ODataService_{Guid.NewGuid().ToString("N")}"; ODataServiceSettings settings = new ODataServiceSettings(); BuildDefaultConfiguration(settings); configureSettings(settings); EdmModel edmModel = settings.Services.EdmModelBuilder(settings).GetModel(); IDataService dataService = settings.Services.DataService(settings); var routingConventions = ODataRoutingConventions.CreateDefault(); routingConventions.Insert(0, new DynamicRoutingConvention()); var oDataRoute = new ODataRoute( settings.RoutePrefix, new CustomODataPathRouteConstraint( new CustomODataPathHandler(), _ => edmModel, routeName, routingConventions, dataService)); config.Services.Insert(typeof(ModelBinderProvider), 0, new SimpleModelBinderProvider(typeof(ODataQueryOptions), new ODataQueryOptionsBinder())); config.Services.Insert(typeof(ModelBinderProvider), 0, new SimpleModelBinderProvider(typeof(HttpRequestMessageProperties), new ODataRequestPropertiesBinder())); config.Services.Insert(typeof(ModelBinderProvider), 0, new SimpleModelBinderProvider(typeof(IDataService), new DataServiceBinder())); config.Routes.Add(routeName, oDataRoute); }
public static void Register(HttpConfiguration config) { config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; // Add $format support config.MessageHandlers.Add(new FormatQueryMessageHandler()); // Add NavigationRoutingConvention2 to support POST, PUT, PATCH and DELETE on navigation property var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new CustomNavigationRoutingConvention()); // Enables OData support by adding an OData route and enabling querying support for OData. // Action selector and odata media type formatters will be registered in per-controller configuration only config.Routes.MapODataServiceRoute( routeName: "OData", routePrefix: null, model: ModelBuilder.GetEdmModel(), pathHandler: new DefaultODataPathHandler(), routingConventions: conventions); // To disable tracing in your application, please comment out or remove the following line of code // For more information, refer to: http://www.asp.net/web-api config.EnableSystemDiagnosticsTracing(); config.Filters.Add(new ModelValidationFilterAttribute()); }
/// <summary> /// Создает набор конвенций маршрутизации по умолчанию. /// </summary> /// <remarks> /// Набор состоит из <see cref="DataObjectRoutingConvention"/> и стандартных реализаций <see cref="IODataRoutingConvention"/>. /// </remarks> /// <returns> /// Набор конвенций маршрутизации. /// </returns> public static List <IODataRoutingConvention> CreateDefault() { List <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault().ToList(); routingConventions.Insert(0, new DataObjectRoutingConvention()); return(routingConventions); }