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