public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IApiVersionDescriptionProvider apiVersionProvider, VersionedODataModelBuilder modelBuilder)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
var models = modelBuilder.GetEdmModels();
app.UseMvc(routeBuilder =>
{
routeBuilder.EnableDependencyInjection();
routeBuilder.Filter().SkipToken();
var apiVersion = new ApiVersion(1, 0);
routeBuilder.MapVersionedODataRoutes("odata", string.Empty, modelBuilder.GetEdmModels());
});
app.UseCors(options => options.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
app.UseAuthentication();
app.Use(async(context, next) =>
{
context.Response.Headers.Add("X-Content-Type-Options", "nosniff");
await next().ConfigureAwait(false);
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, VersionedODataModelBuilder modelBuilder)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseMvc(routeBuilder =>
{
// we need to set a new ODataConventionModelBuilder
// see https://github.com/Microsoft/aspnet-api-versioning/issues/476
//var bla = modelBuilder.ModelBuilderFactory = () => new ODataConventionModelBuilder();
var models = modelBuilder.GetEdmModels();
routeBuilder.Select().Filter().Count().MaxTop(100);
routeBuilder.ServiceProvider.GetRequiredService <ODataOptions>().UrlKeyDelimiter = ODataUrlKeyDelimiter.Parentheses;
// odata must be called in the format: http://localhost:5103/odata/StandardProjectReport?api-version=1.0
routeBuilder.MapVersionedODataRoutes("odata", "odata", models);
});
}
public virtual void Configure(IApplicationBuilder app, IWebHostEnvironment env, VersionedODataModelBuilder modelBuilder, IApiVersionDescriptionProvider provider)
{
if (env.IsDevelopment())
{
_ = app.UseDeveloperExceptionPage();
}
else
{
_ = app.UseHsts();
}
_ = app.UseAuthentication()
.UseAuthorization();
_ = app
.UseMvc(routeBuilder =>
{
var models = modelBuilder.GetEdmModels().ToList();
var singleton = Microsoft.OData.ServiceLifetime.Singleton;
_ = routeBuilder
.SetTimeZoneInfo(TimeZoneInfo.Utc)
.Select()
.Expand()
.OrderBy()
.MaxTop(MaxTop ?? 100)
.Filter()
.Count()
.MapVersionedODataRoutes("odata-bypath", "odata/v{version:apiVersion}", models, oBuilder =>
{
_ = oBuilder.AddService <ODataSerializerProvider, NrsrxODataSerializerProvider>(singleton);
});
})
.UseSwagger()
.UseSwaggerUI(options => SetupSwaggerUI(options, provider));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
VersionedODataModelBuilder modelBuilder)
{
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.UseHttpsRedirection();
app.UseMvc(builder =>
{
builder.Select().Expand().Filter().OrderBy().Count().MaxTop(100);
builder.MapVersionedODataRoutes("odata", "odata", modelBuilder.GetEdmModels());
});
BsonClassMap.RegisterClassMap <Book>(cm => {
cm.AutoMap();
cm.GetMemberMap(c => c.Title).SetElementName("title");
cm.GetMemberMap(c => c.Year).SetElementName("year");
cm.GetMemberMap(c => c.Author).SetElementName("author");
cm.SetIgnoreExtraElements(true);
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
#pragma warning disable CA1822 // Mark members as static
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, VersionedODataModelBuilder modelBuilder)
#pragma warning restore CA1822 // Mark members as static
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
// app.UseHttpsRedirection();
app.UseMvc(routeBuilder =>
{
routeBuilder.EnableDependencyInjection();
// and this line to enable OData query option, for example $filter
routeBuilder.Select().Expand().Filter().OrderBy().MaxTop(100).Count();
var models = modelBuilder.GetEdmModels();
// routeBuilder.MapODataServiceRoute("ODataRoute", "odata", builder.GetEdmModel());
// the following will not work as expected
// BUG: https://github.com/OData/WebApi/issues/1837
// routeBuilder.SetDefaultODataOptions( new ODataOptions() { UrlKeyDelimiter = Parentheses } );
routeBuilder.ServiceProvider.GetRequiredService <ODataOptions>().UrlKeyDelimiter = Parentheses;
routeBuilder.MapVersionedODataRoutes("ODataRoute", "northwind/odata", models);
routeBuilder.MapVersionedODataRoutes("odata-bypath", "northwind/odata/v{version:apiVersion}", models);
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, VersionedODataModelBuilder modelBuilder, IApiVersionDescriptionProvider provider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseMvc(routes =>
{
routes.MapVersionedODataRoute("odata", "odata", modelBuilder.GetEdmModels());
});
app.UseSwagger();
app.UseSwaggerUI(
swagger =>
{
// build a swagger endpoint for each discovered API version
foreach (var description in provider.ApiVersionDescriptions)
{
swagger.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
}
swagger.RoutePrefix = "";
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, VersionedODataModelBuilder modelBuilder, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
//Authentication middleware to the middleware pipeline
app.UseAuthentication();
//app.UseHttpsRedirection();
//app.UseCors(AllowOrigins);
app.UseCors(/*config => config
* .AllowAnyOrigin()
* .AllowAnyHeader()
* .AllowAnyMethod()*/);
app.UseRouting();
app.UseMvc(config =>
{
config.EnableDependencyInjection(/*m => m.AddService(
* Microsoft.OData.ServiceLifetime.Singleton,
* typeof(ODataUriResolver),
* typeof(UnqualifiedCallAndEnumPrefixFreeResolver))*/);
//config.SetDefaultODataOptions()
//config.SetDefaultQuerySettings()
//config.Count().Filter().OrderBy().Expand().Select().MaxTop(int.MaxValue);
config.MapVersionedODataRoutes("odata", "v{version:apiVersion}", modelBuilder.GetEdmModels());
});
}
public void Configuration(IAppBuilder appBuilder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
// reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions"
configuration.AddApiVersioning(o => o.ReportApiVersions = true);
configuration.EnableCaseInsensitive(true);
configuration.EnableUnqualifiedNameCall(true);
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(),
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration()
}
};
var models = modelBuilder.GetEdmModels();
var batchHandler = new DefaultODataBatchHandler(httpServer);
configuration.MapVersionedODataRoutes("odata", "api", models, batchHandler);
configuration.MapVersionedODataRoutes("odata-bypath", "v{apiVersion}", models, batchHandler);
appBuilder.UseWebApi(httpServer);
}
public void Configure(IApplicationBuilder app, VersionedODataModelBuilder modelBuilder, IApiVersionDescriptionProvider provider)
{
app.UseMvc(routeBuilder =>
{
// the following will not work as expected
// BUG: https://github.com/OData/WebApi/issues/1837
// routeBuilder.SetDefaultODataOptions( new ODataOptions() { UrlKeyDelimiter = Parentheses } );
routeBuilder.ServiceProvider.GetRequiredService <ODataOptions>().UrlKeyDelimiter = Parentheses;
// global odata query options
routeBuilder.Count();
routeBuilder.MapVersionedODataRoutes("odata", "api/v{apiVersion}", modelBuilder.GetEdmModels());
});
app.UseAuthorization();
app.UseSwagger();
app.UseSwaggerUI(
options =>
{
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
}
});
}
public BasicFixture()
{
FilteredControllerTypes.Add(typeof(OrdersController));
FilteredControllerTypes.Add(typeof(PeopleController));
FilteredControllerTypes.Add(typeof(People2Controller));
FilteredControllerTypes.Add(typeof(CustomersController));
FilteredControllerTypes.Add(typeof(WeatherForecastsController));
Configuration.AddApiVersioning(options => options.ReportApiVersions = true);
var modelBuilder = new VersionedODataModelBuilder(Configuration)
{
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration(),
new CustomerModelConfiguration(),
new WeatherForecastModelConfiguration(),
}
};
var models = modelBuilder.GetEdmModels();
Configuration.MapVersionedODataRoute("odata", "api", models);
Configuration.MapVersionedODataRoute("odata-bypath", "v{apiVersion}", models);
Configuration.EnsureInitialized();
}
protected AdvancedAcceptanceTest()
{
FilteredControllerTypes.Add(typeof(OrdersController));
FilteredControllerTypes.Add(typeof(Orders2Controller));
FilteredControllerTypes.Add(typeof(Orders3Controller));
FilteredControllerTypes.Add(typeof(PeopleController));
FilteredControllerTypes.Add(typeof(People2Controller));
Configuration.AddApiVersioning(
options =>
{
options.ReportApiVersions = true;
options.AssumeDefaultVersionWhenUnspecified = true;
options.ApiVersionReader = ApiVersionReader.Combine(
new QueryStringApiVersionReader(),
new HeaderApiVersionReader("api-version", "x-ms-version"));
});
var modelBuilder = new VersionedODataModelBuilder(Configuration)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(),
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration(supportedApiVersion: new ApiVersion(2, 0))
}
};
var models = modelBuilder.GetEdmModels();
Configuration.MapVersionedODataRoutes("odata", "api", models, builder => builder.AddService(Singleton, typeof(ODataUriResolver), sp => TestUriResolver));
Configuration.Routes.MapHttpRoute("orders", "api/{controller}/{key}", new { key = Optional });
Configuration.EnsureInitialized();
}
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 HttpConfiguration NewOrdersConfiguration()
{
var configuration = new HttpConfiguration();
var controllerTypeResolver = new ControllerTypeCollection(
typeof(Simulators.V1.OrdersController),
typeof(Simulators.V2.OrdersController),
typeof(Simulators.V3.OrdersController));
configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver);
configuration.AddApiVersioning(
options =>
{
options.Conventions.Controller <Simulators.V1.OrdersController>()
.HasApiVersion(1, 0)
.HasDeprecatedApiVersion(0, 9)
.Action(c => c.Post(default(Order))).MapToApiVersion(1, 0);
options.Conventions.Controller <Simulators.V2.OrdersController>()
.HasApiVersion(2, 0);
options.Conventions.Controller <Simulators.V3.OrdersController>()
.HasApiVersion(3, 0)
.AdvertisesApiVersion(4, 0);
});
var builder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations = { new OrderModelConfiguration() }
};
var models = builder.GetEdmModels();
configuration.MapVersionedODataRoutes("odata", "api", models);
return(configuration);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, VersionedODataModelBuilder modelBuilder)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
var models = modelBuilder.GetEdmModels();
app.UseMvc(routes => {
routes.Select().Filter().OrderBy().Count();
routes.MapVersionedODataRoutes("odata", "odata", models);
});
//app.UseEndpoints(endpoints =>
//{
// endpoints.MapControllers();
// endpoints.Select().Expand().OrderBy().Filter().MaxTop(100).Count();
// endpoints.MapODataRoute("odata", "odata", builder.GetEdmModel());
//});
}
public void Configuration(IAppBuilder appBuilder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
// reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions"
configuration.AddApiVersioning(options => options.ReportApiVersions = true);
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration()
}
};
var models = modelBuilder.GetEdmModels();
var batchHandler = new DefaultODataBatchHandler(httpServer);
// NOTE: you do NOT and should NOT use both the query string and url segment methods together.
// this configuration is merely illustrating that they can coexist and allows you to easily
// experiment with either configuration. one of these would be removed in a real application.
configuration.MapVersionedODataRoutes("odata", "api", models, ConfigureContainer, batchHandler);
configuration.MapVersionedODataRoutes("odata-bypath", "api/v{apiVersion}", models, ConfigureContainer);
appBuilder.UseWebApi(httpServer);
}
public AdvancedFixture()
{
FilteredControllerTypes.Add(typeof(OrdersController));
FilteredControllerTypes.Add(typeof(Orders2Controller));
FilteredControllerTypes.Add(typeof(Orders3Controller));
FilteredControllerTypes.Add(typeof(PeopleController));
FilteredControllerTypes.Add(typeof(People2Controller));
Configuration.AddApiVersioning(
options =>
{
options.ReportApiVersions = true;
options.AssumeDefaultVersionWhenUnspecified = true;
options.ApiVersionReader = ApiVersionReader.Combine(
new QueryStringApiVersionReader(),
new HeaderApiVersionReader("api-version", "x-ms-version"));
});
var modelBuilder = new VersionedODataModelBuilder(Configuration)
{
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration(supportedApiVersion: new ApiVersion(2, 0)),
}
};
var models = modelBuilder.GetEdmModels();
Configuration.MapVersionedODataRoute("odata", "api", models);
Configuration.Routes.MapHttpRoute("orders", "api/{controller}/{key}", new { key = Optional });
Configuration.Formatters.Remove(Configuration.Formatters.XmlFormatter);
Configuration.EnsureInitialized();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, VersionedODataModelBuilder modelBuilder,
IApiVersionDescriptionProvider provider, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseApiVersioning();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
app.UseMvc(builder => {
var edmModels = modelBuilder.GetEdmModels();
builder.MapVersionedODataRoutes("odata", "odata", edmModels);
});
app.UseSwagger();
app.UseSwaggerUI(options => {
// build a swagger endpoint for each discovered API version
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
}
});
}
public void Configuration(IAppBuilder builder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
configuration.AddApiVersioning(options => options.ReportApiVersions = true);
//-----DATA-----
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations = { new DataModelConfiguration() }
};
var models = modelBuilder.GetEdmModels();
configuration.MapVersionedODataRoutes("odata-data", "data/v{apiVersion}", models);
//-----CONFIG-----
var configModelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations = { new ConfigModelConfiguration() }
};
var configModels = configModelBuilder.GetEdmModels();
configuration.MapVersionedODataRoutes("odata-config", "config/v{apiVersion}", configModels);
var apiExplorer = configuration.AddODataApiExplorer(
options => {
options.GroupNameFormat = "'v'VVV";
options.SubstituteApiVersionInUrl = true;
});
builder.UseWebApi(httpServer);
}
protected ConventionsAcceptanceTest()
{
FilteredControllerTypes.Add(typeof(OrdersController));
FilteredControllerTypes.Add(typeof(PeopleController));
FilteredControllerTypes.Add(typeof(People2Controller));
Configuration.AddApiVersioning(
options =>
{
options.ReportApiVersions = true;
options.Conventions.Controller <OrdersController>()
.HasApiVersion(1, 0);
options.Conventions.Controller <PeopleController>()
.HasApiVersion(1, 0)
.HasApiVersion(2, 0)
.Action(c => c.Patch(default(int), null, null)).MapToApiVersion(2, 0);
options.Conventions.Controller <People2Controller>()
.HasApiVersion(3, 0);
});
var modelBuilder = new VersionedODataModelBuilder(Configuration)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(),
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration()
}
};
var models = modelBuilder.GetEdmModels();
Configuration.MapVersionedODataRoutes("odata", "api", models);
Configuration.MapVersionedODataRoutes("odata-bypath", "v{apiVersion}", models);
Configuration.EnsureInitialized();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
VersionedODataModelBuilder modelBuilder,
IApiVersionDescriptionProvider provider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMvc(b =>
{
// Globally enabling all OData query options:
b.Select().Expand().Filter().OrderBy().MaxTop(100).Count();
b.MapVersionedODataRoutes("odata", "odata/v{version:apiVersion}", modelBuilder.GetEdmModels());
});
app.UseSwagger();
app.UseSwaggerUI(
options =>
{
// build a swagger endpoint for each discovered API version
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
}
});
}
public void Configuration(IAppBuilder appBuilder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
configuration.AddApiVersioning(
o =>
{
o.ReportApiVersions = true;
o.AssumeDefaultVersionWhenUnspecified = true;
o.ApiVersionReader = ApiVersionReader.Combine(
new QueryStringApiVersionReader(),
new HeaderApiVersionReader("api-version", "x-ms-version"));
});
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder().EnableLowerCamelCase(),
ModelConfigurations =
{
new PersonModelConfiguration(),
new OrderModelConfiguration()
}
};
var models = modelBuilder.GetEdmModels();
var batchHandler = new DefaultODataBatchHandler(httpServer);
configuration.MapVersionedODataRoutes("odata", "api", models, OnConfigureContainer, batchHandler);
configuration.Routes.MapHttpRoute("orders", "api/{controller}/{id}", new { id = Optional });
appBuilder.UseWebApi(httpServer);
}
internal static void ConfigureOData(this HttpConfiguration configuration, HttpServer httpServer)
{
// BUG: cannot use alt keys and unqualified actions in 5.9.1; may be resolvable in 6.0, but that isn't not supported by API versioning - yet
// REF: https://github.com/OData/WebApi/issues/636
//configuration.EnableAlternateKeys( true );
configuration.EnableCaseInsensitive(true);
configuration.EnableUnqualifiedNameCall(true);
configuration.EnableEnumPrefixFree(true);
configuration.EnableMediaResources();
var modelConfigurations = configuration.DependencyResolver.GetServices <IModelConfiguration>();
var builder = new VersionedODataModelBuilder(configuration)
{
ModelBuilderFactory = () => new ODataConventionModelBuilder()
{
Namespace = nameof(Contoso)
}.EnableLowerCamelCase(),
OnModelCreated = BuilderExtensions.ApplyAnnotations
};
builder.ModelConfigurations.AddRange(modelConfigurations);
var models = builder.GetEdmModels();
var batchHandler = new DefaultODataBatchHandler(httpServer);
configuration.MapVersionedODataRoutes("odata", RoutePrefix, models, batchHandler);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, VersionedODataModelBuilder oDataModelBuilder)
{
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.UseExceptionHandler(builder =>
{
builder.Run(async ctx =>
{
ctx.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
var error = ctx.Features.Get <IExceptionHandlerFeature>();
if (error != null)
{
ctx.Response.AddApplicationError(error.Error.Message);
await ctx.Response.WriteAsync(error.Error.Message);
}
});
});
}
app.UseCors(opt => opt.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin());
//app.UseHttpsRedirection();
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
app.UseAuthentication();
app.UseMvc(builder =>
{
builder.Select().Expand().Filter().OrderBy().Count().MaxTop(100);
builder.MapVersionedODataRoutes("ODataRoutes", "odata", oDataModelBuilder.GetEdmModels());
builder.EnableDependencyInjection();
});
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("v1/swagger.json", "ICMSKD API v1.0");
});
if (!string.IsNullOrEmpty(Configuration["PathBase"]))
{
app.UsePathBase(Configuration["PathBase"]);
}
}
public void Configure(
IApplicationBuilder app,
IWebHostEnvironment env,
VersionedODataModelBuilder modelBuilder
)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.Select().Expand().Filter().OrderBy().MaxTop(100).Count();
routes.MapVersionedODataRoutes("odata", "odata", modelBuilder.GetEdmModels());
routes.EnableDependencyInjection();
});
app.Map("/hello", v =>
{
v.Run(async ctx =>
{
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
await ctx.Response.WriteAsync("hello world");
});
});
foreach (string route in new string[] { "/api", "/odata" })
{
app.Map(route, builder =>
{
builder.Run(async context =>
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
await context.Response.WriteAsync("");
});
});
}
app.UseSpa(spa =>
{
spa.Options.SourcePath = "web";
if (env.IsDevelopment())
{
spa.UseProxyToSpaDevelopmentServer("http://localhost:3000");
}
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, VersionedODataModelBuilder modelBuilder)
{
app.UseMvc(
routeBuilder =>
{
var models = modelBuilder.GetEdmModels();
routeBuilder.MapVersionedODataRoutes("odata", "api", models);
routeBuilder.MapVersionedODataRoutes("odata-bypath", "v{version:apiVersion}", models);
});
}
public void Configure(IApplicationBuilder app, VersionedODataModelBuilder modelBuilder)
{
app.UseRouting();
app.UseEndpoints(
endpoints =>
{
endpoints.MapControllers();
endpoints.MapVersionedODataRoute("odata", "api", modelBuilder.GetEdmModels());
});
}
public void Configure(IApplicationBuilder app, VersionedODataModelBuilder modelBuilder, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHttpStatusExceptionHandler();
}
app.UseHangfireServer();
app.UseHangfireDashboard(options: new DashboardOptions
{
Authorization = new[]
{
new HangfireAuthorizationFilter()
}
});
app.UseCors("CorsForUI");
app.UseHttpsRedirection();
app.UseSerilogRequestLogging();
app.UseForwardedHeaders(ForwardedHeadersSettings.Options);
app.UseODataRouting();
app.UseRouting();
app.UseIdentityServer();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.Filter().Count().OrderBy().Select().Expand().MaxTop(1000);
endpoints.MapVersionedODataRoute("odata", "odata", modelBuilder.GetEdmModels());
endpoints.SetTimeZoneInfo(TimeZoneInfo.Utc);
});
app.UseSwagger();
app.UseSwaggerUI(options =>
{
options.SwaggerEndpoint("/swagger/v1/swagger.json", "Happy Exadel Hours API V1");
options.OAuthClientId("HEHApiClient");
options.OAuthAppName("Happy Exadel Hours Api client");
options.RoutePrefix = string.Empty;
});
app.ApplicationServices.GetService <INotificationScheduler>()?.StartJobs();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, VersionedODataModelBuilder modelBuilder)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
var models = modelBuilder.GetEdmModels();
app.UseMvc(routes => routes.MapVersionedODataRoutes("odata", "odata", models));
}
/// <summary>
/// Configures the application using the provided builder.
/// </summary>
/// <param name="builder">The current application builder.</param>
public void Configuration(IAppBuilder builder)
{
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
// reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions"
configuration.AddApiVersioning(options => options.ReportApiVersions = true);
// note: this is required to make the default swagger json settings match the odata conventions applied by EnableLowerCamelCase()
configuration.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var modelBuilder = new VersionedODataModelBuilder(configuration)
{
ModelConfigurations =
{
new AllConfigurations(),
new PersonModelConfiguration(),
new OrderModelConfiguration(),
new ProductConfiguration(),
new SupplierConfiguration(),
}
};
var models = modelBuilder.GetEdmModels();
// global odata query options
configuration.Count();
// INFO: you do NOT and should NOT use both the query string and url segment methods together.
// this configuration is merely illustrating that they can coexist and allows you to easily
// experiment with either configuration. one of these would be removed in a real application.
//
// INFO: only pass the route prefix to GetEdmModels if you want to split the models; otherwise, both routes contain all models
// WHEN VERSIONING BY: query string, header, or media type
configuration.MapVersionedODataRoute("odata", "api", models);
// WHEN VERSIONING BY: url segment
// configuration.MapVersionedODataRoute( "odata-bypath", "api/v{apiVersion}", models );
// add the versioned IApiExplorer and capture the strongly-typed implementation (e.g. ODataApiExplorer vs IApiExplorer)
// note: the specified format code will format the version as "'v'major[.minor][-status]"
var apiExplorer = configuration.AddODataApiExplorer(
options =>
{
options.GroupNameFormat = "'v'VVV";
// note: this option is only necessary when versioning by url segment. the SubstitutionFormat
// can also be used to control the format of the API version in route templates
options.SubstituteApiVersionInUrl = true;
// configure query options (which cannot otherwise be configured by OData conventions)
options.QueryOptions.Controller <V2.PeopleController>()
.Action(c => c.Get(default))
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, VersionedODataModelBuilder modelBuilder)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseMvc(
routeBuilder =>
{
var models = modelBuilder.GetEdmModels();
routeBuilder.MapVersionedODataRoutes("odata", "api", models);
routeBuilder.MapVersionedODataRoutes("odata-bypath", "v{version:apiVersion}", models);
});
}
