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);
}
/// <summary>
/// Gets the configuration.
/// </summary>
/// <param name="odataModel">The odata model.</param>
/// <returns></returns>
public static HttpConfiguration GetConfig(IEdmModel odataModel)
{
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
var pathHandler = new DefaultODataPathHandler();
var routingConventions = ODataRoutingConventions.CreateDefaultWithAttributeRouting(config, odataModel);
var batchHandler = new DefaultODataBatchHandler(new HttpServer(config));
config.MapODataServiceRoute(
routeName: "ODataService",
routePrefix: "api/v1",
model: odataModel,
pathHandler: pathHandler,
routingConventions: routingConventions,
batchHandler: batchHandler);
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
config.EnsureInitialized();
// XML JSON
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
return(config);
}
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);
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
// Web API configuration and services
var builder = new ODataConventionModelBuilder();
config.EnableUnqualifiedNameCall(true);
config.EnableEnumPrefixFree(true);
RegisterEntities(ref builder);
RegisterCustomRoutes(ref builder);
builder.Namespace = "";
builder.EnableLowerCamelCase();
ODataBatchHandler odataBatchHandler =
new DefaultODataBatchHandler(new HttpServer(config));
odataBatchHandler.MessageQuotas.MaxOperationsPerChangeset = 10;
odataBatchHandler.MessageQuotas.MaxPartsPerBatch = 10;
config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel(), odataBatchHandler);
// Web API routes
}
public static void Register(HttpConfiguration config)
{
SecurityAdapterHelper.Enable(ReloadPermissionStrategy.CacheOnFirstAccess);
var httpControllerRouteHandler = typeof(HttpControllerRouteHandler).GetField("_instance",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
if (httpControllerRouteHandler != null)
{
httpControllerRouteHandler.SetValue(null,
new Lazy <HttpControllerRouteHandler>(() => new SessionHttpControllerRouteHandler(), true));
}
if (HttpContext.Current != null)
{
ValueManager.ValueManagerType = typeof(MyASPSessionValueManager <>).GetGenericTypeDefinition();
}
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
ODataModelBuilder modelBuilder = CreateODataModelBuilder();
ODataBatchHandler batchHandler =
new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer);
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: modelBuilder.GetEdmModel(),
batchHandler: batchHandler);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseRouting();
app.UseODataBatching();
// Newer endpoint routing.
//app.UseEndpoints(endpoints =>
//{
// endpoints.MapControllers();
// endpoints.Select().Filter().OrderBy().Count().MaxTop(10);
// endpoints.MapODataRoute("odata", "odata", GetEdmModel());
//});
// Older non-endpoint routing.
var routeName = "odata";
var routePrefix = "odata";
var pathHandler = new DefaultODataPathHandler();
var batchHandler = new DefaultODataBatchHandler();
var routingConventions = GetRoutingConventions(app.ApplicationServices, routeName);
app.UseMvc(routeBuilder =>
{
routeBuilder.EnableDependencyInjection();
routeBuilder.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
routeBuilder.MapODataServiceRoute(
routeName: routeName,
routePrefix: routePrefix,
model: GetEdmModel(),
pathHandler: pathHandler,
routingConventions: routingConventions,
batchHandler: batchHandler);
});
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration
{
DependencyResolver = new UnityDependencyResolver(Bootstrapper.ConfigureUnity(new WebApplicationSettings()))
};
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
config.MapHttpAttributeRoutes();
config.SetupClrTypes();
config.RegisterODataControllers();
config.EnableSwagger(c =>
{
c.SingleApiVersion("v1", "NuClear River API reference");
c.CustomProvider(defaultProvider => new ODataSwaggerProvider(defaultProvider, c, config));
})
.EnableSwaggerUi();
var httpServer = new HttpServer(config);
var batchHandler = new DefaultODataBatchHandler(httpServer);
config.MapODataServiceRoutes(batchHandler);
appBuilder.UseWebApi(httpServer);
}
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 map_versioned_odata_routes_should_return_expected_result()
{
// arrange
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
var routeName = "odata";
var routePrefix = "api/v3";
var model = new ODataModelBuilder().GetEdmModel();
var apiVersion = new ApiVersion(3, 0);
var batchHandler = new DefaultODataBatchHandler(httpServer);
// act
var route = configuration.MapVersionedODataRoute(routeName, routePrefix, model, apiVersion, batchHandler);
var constraint = route.PathRouteConstraint;
var routingConventions = GetRoutingConventions(configuration, route);
var batchRoute = configuration.Routes["odataBatch"];
// assert
routingConventions[0].Should().BeOfType <VersionedAttributeRoutingConvention>();
routingConventions[1].Should().BeOfType <VersionedMetadataRoutingConvention>();
routingConventions.OfType <MetadataRoutingConvention>().Should().BeEmpty();
constraint.RouteName.Should().Be(routeName);
route.RoutePrefix.Should().Be(routePrefix);
batchRoute.Handler.Should().Be(batchHandler);
batchRoute.RouteTemplate.Should().Be("api/v3/$batch");
}
public static void Register(HttpConfiguration config)
{
var batchHandler = new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer);
config.MapODataServiceRoute("OrderODataRoute", ODataRoutePrefix + "/order", GetOrderEdmModal(), batchHandler);
config.MapODataServiceRoute("ProductODataRoute", ODataRoutePrefix + "/product", GetProductEdmModal(), batchHandler);
}
public void map_versioned_odata_route_should_return_expected_result(string routePrefix)
{
// arrange
var configuration = new HttpConfiguration();
var httpServer = new HttpServer(configuration);
var routeName = "odata";
var batchTemplate = "$batch";
var batchHandler = new DefaultODataBatchHandler(httpServer);
var models = CreateModels(configuration);
if (!string.IsNullOrEmpty(routePrefix))
{
batchTemplate = routePrefix + "/" + batchTemplate;
}
// act
var route = configuration.MapVersionedODataRoute(routeName, routePrefix, models, batchHandler);
var batchRoute = configuration.Routes["odataBatch"];
// assert
var selector = GetODataRootContainer(configuration, routeName).GetRequiredService <IEdmModelSelector>();
var routingConventions = GetRoutingConventions(configuration, route);
selector.ApiVersions.Should().Equal(new[] { new ApiVersion(1, 0), new ApiVersion(2, 0) });
routingConventions[0].Should().BeOfType <VersionedAttributeRoutingConvention>();
routingConventions[1].Should().BeOfType <VersionedMetadataRoutingConvention>();
routingConventions.OfType <MetadataRoutingConvention>().Should().BeEmpty();
route.PathRouteConstraint.RouteName.Should().Be(routeName);
route.RoutePrefix.Should().Be(routePrefix);
batchRoute.Handler.Should().Be(batchHandler);
batchRoute.RouteTemplate.Should().Be(batchTemplate);
}
public async Task ProcessBatchAsync_CallsRegisterForDispose()
{
// Arrange
List <IDisposable> expectedResourcesForDisposal = new List <IDisposable>();
MockHttpServer server = new MockHttpServer(request =>
{
var tmpContent = new StringContent(String.Empty);
request.RegisterForDispose(tmpContent);
expectedResourcesForDisposal.Add(tmpContent);
return(new HttpResponseMessage {
Content = new StringContent(request.RequestUri.AbsoluteUri)
});
});
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(server);
HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, "http://example.com/$batch")
{
Content = new MultipartContent("mixed")
{
ODataBatchRequestHelper.CreateODataRequestContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/"))
}
};
batchRequest.EnableHttpDependencyInjectionSupport();
// Act
var response = await batchHandler.ProcessBatchAsync(batchRequest, CancellationToken.None);
var resourcesForDisposal = batchRequest.GetResourcesForDisposal();
// Assert
foreach (var expectedResource in expectedResourcesForDisposal)
{
Assert.Contains(expectedResource, resourcesForDisposal);
}
}
// 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.UseODataBatching();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints
.Select().Filter().OrderBy().Count().Expand().MaxTop(50)
.SetUrlKeyDelimiter(ODataUrlKeyDelimiter.Parentheses);
var defaultBatchHandler = new DefaultODataBatchHandler();
defaultBatchHandler.MessageQuotas.MaxNestingDepth = 2;
defaultBatchHandler.MessageQuotas.MaxOperationsPerChangeset = 10;
endpoints.MapODataRoute("odata", "odata", GetEdmModel(), defaultBatchHandler);
});
}
public void map_versioned_odata_route_should_return_expected_result()
{
// arrange
var routeName = "odata";
var routePrefix = "api/v3";
var modelBuilder = new ODataModelBuilder();
var modelConfiguration = new TestModelConfiguration();
var apiVersion = new ApiVersion(3, 0);
var batchHandler = new DefaultODataBatchHandler();
var app = NewApplicationBuilder();
var route = default(ODataRoute);
modelConfiguration.Apply(modelBuilder, apiVersion);
var model = modelBuilder.GetEdmModel();
// act
app.UseMvc(r => route = r.MapVersionedODataRoute(routeName, routePrefix, model, apiVersion, batchHandler));
var perRequestContainer = app.ApplicationServices.GetRequiredService <IPerRouteContainer>();
var serviceProvider = perRequestContainer.GetODataRootContainer(route.Name);
var routingConventions = serviceProvider.GetRequiredService <IEnumerable <IODataRoutingConvention> >().ToArray();
var constraint = (VersionedODataPathRouteConstraint)route.PathRouteConstraint;
// assert
routingConventions[0].Should().BeOfType <VersionedAttributeRoutingConvention>();
routingConventions[1].Should().BeOfType <VersionedMetadataRoutingConvention>();
routingConventions.OfType <MetadataRoutingConvention>().Should().BeEmpty();
constraint.RouteName.Should().Be(routeName);
route.RoutePrefix.Should().Be(routePrefix);
batchHandler.ODataRoute.Should().NotBeNull();
batchHandler.ODataRouteName.Should().Be(routeName);
}
public async Task ProcessBatchAsync_Throws_IfRequestIsNull()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
await ExceptionAssert.ThrowsArgumentNullAsync(
() => batchHandler.ProcessBatchAsync(null, CancellationToken.None),
"request");
}
public async Task ParseBatchRequestsAsync_Returns_RequestsFromMultipartContent()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, "http://example.com/$batch")
{
Content = new MultipartContent("mixed")
{
ODataBatchRequestHelper.CreateODataRequestContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
new MultipartContent("mixed") // ChangeSet
{
ODataBatchRequestHelper.CreateODataRequestContent(new HttpRequestMessage(HttpMethod.Post, "http://example.com/values"))
}
}
};
batchRequest.EnableHttpDependencyInjectionSupport();
IList <ODataBatchRequestItem> requests = await batchHandler.ParseBatchRequestsAsync(batchRequest, CancellationToken.None);
Assert.Equal(2, requests.Count);
var operationRequest = ((OperationRequestItem)requests[0]).Request;
Assert.Equal(HttpMethod.Get, operationRequest.Method);
Assert.Equal("http://example.com/", operationRequest.RequestUri.AbsoluteUri);
var changeSetRequest = ((ChangeSetRequestItem)requests[1]).Requests.First();
Assert.Equal(HttpMethod.Post, changeSetRequest.Method);
Assert.Equal("http://example.com/values", changeSetRequest.RequestUri.AbsoluteUri);
}
public async Task ExecuteRequestMessagesAsync_DisposesResponseInCaseOfException()
{
List <MockHttpResponseMessage> responses = new List <MockHttpResponseMessage>();
MockHttpServer server = new MockHttpServer(request =>
{
if (request.Method == HttpMethod.Put)
{
throw new InvalidOperationException();
}
var response = new MockHttpResponseMessage();
responses.Add(response);
return(response);
});
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(server);
ODataBatchRequestItem[] requests = new ODataBatchRequestItem[]
{
new OperationRequestItem(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
new OperationRequestItem(new HttpRequestMessage(HttpMethod.Post, "http://example.com/")),
new OperationRequestItem(new HttpRequestMessage(HttpMethod.Put, "http://example.com/")),
};
await ExceptionAssert.ThrowsAsync <InvalidOperationException>(
() => batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None));
Assert.Equal(2, responses.Count);
foreach (var response in responses)
{
Assert.True(response.IsDisposed);
}
}
public async Task ExecuteRequestMessagesAsync_Throws_IfRequestsIsNull()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
await ExceptionAssert.ThrowsArgumentNullAsync(
() => batchHandler.ExecuteRequestMessagesAsync(null, CancellationToken.None),
"requests");
}
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 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 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);
}
public async Task CreateResponseMessageAsync_Throws_IfRequestIsNull()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
await ExceptionAssert.ThrowsArgumentNullAsync(
() => batchHandler.CreateResponseMessageAsync(new ODataBatchResponseItem[0], null, CancellationToken.None),
"request");
}
public async Task ExecuteRequestMessagesAsync_Throws_IfRequestsIsNull()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => batchHandler.ExecuteRequestMessagesAsync(null, null), "requests");
}
public async Task ProcessBatchAsync_Throws_IfContextIsNull()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => batchHandler.ProcessBatchAsync(null, null), "context");
}
public async Task CreateResponseMessageAsync_Throws_IfRequestIsNull()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => batchHandler.CreateResponseMessageAsync(new ODataBatchResponseItem[0], null), "request");
}
public async Task ParseBatchRequestsAsync_Throws_IfRequestIsNull()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => batchHandler.ParseBatchRequestsAsync(null), "context");
}
public void ValidateRequest_Throws_IfRequestIsNull()
{
// Arrange
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => batchHandler.ValidateRequest(null), "request");
}
public void ValidateRequest_Throws_IfResponsesIsNull()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
ExceptionAssert.ThrowsArgumentNull(
() => batchHandler.ValidateRequest(null),
"request");
}
public void Parameter_Constructor()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
Assert.NotNull(batchHandler.Invoker);
Assert.NotNull(batchHandler.MessageQuotas);
Assert.Null(batchHandler.ODataRouteName);
}
public void ProcessBatchAsync_Throws_IfRequestIsNull()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
Assert.ThrowsArgumentNull(
() => batchHandler.ProcessBatchAsync(null, CancellationToken.None).Wait(),
"request");
}
