public void AddOData_RegistersODataOptionsWithServiceProvider()
{
// Arrange
var services = new ServiceCollection();
services.AddLogging();
IEdmModel coreModel = EdmCoreModel.Instance;
services.AddSingleton(_ => coreModel);
// Act
services.AddOData((options, serviceProvider) =>
{
var edmModel = serviceProvider.GetRequiredService <IEdmModel>();
options.AddModel("odata", edmModel);
});
IServiceProvider provider = services.BuildServiceProvider();
// Assert
IOptions <ODataOptions> options = provider.GetService <IOptions <ODataOptions> >();
Assert.NotNull(options);
ODataOptions odataOptions = options.Value;
var model = Assert.Single(odataOptions.Models);
Assert.Equal("odata", model.Key);
Assert.Same(coreModel, model.Value.Item1);
Assert.NotNull(model.Value.Item2);
}
public async Task <IQueryable> ApplyQuery(IQueryable collection)
{
T = collection.GetType().GetGenericArguments()[0];
ODataOptions.Validate(ODataValidationSettings);
return(await Task.Run(() => ODataOptions.ApplyTo(collection.AsQueryable())));
}
public void Register(ODataOptions options)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Person>("PersonApi");
options.AddRouteComponents("odata", builder.GetEdmModel());
}
private void Initialize(ODataOptions options)
{
Contract.Assert(options != null);
foreach (var model in options.Models)
{
IServiceProvider subServiceProvider = model.Value.Item2;
if (subServiceProvider == null)
{
continue;
}
// If a batch handler is present, register the route with the batch path mapper. This will be used
// by the batching middleware to handle the batch request. Batching still requires the injection
// of the batching middleware via UseODataBatching().
ODataBatchHandler batchHandler = subServiceProvider.GetService <ODataBatchHandler>();
if (batchHandler != null)
{
batchHandler.PrefixName = model.Key;
string batchPath = string.IsNullOrEmpty(model.Key) ? "/$batch" : $"/{model.Key}/$batch";
if (_batchMapping == null)
{
_batchMapping = new ODataBatchPathMapping();
}
_batchMapping.AddRoute(model.Key, batchPath, batchHandler);
}
}
}
public void OnProvidersExecuted_AddODataRoutingSelector_WhenAttributeRoutingConvention()
{
// Arrange
ODataOptions options = new ODataOptions();
options.AddModel("odata", _model);
LoggerFactory loggerFactory = new LoggerFactory();
var logger = new Logger <AttributeRoutingConvention>(loggerFactory);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
IODataControllerActionConvention[] conventions = new IODataControllerActionConvention[]
{
new AttributeRoutingConvention(logger, parser)
};
ODataRoutingApplicationModelProvider provider = CreateProvider(options, conventions);
ApplicationModelProviderContext providerContext = CreateProviderContext(typeof(AttributeRoutingController));
// Act
provider.OnProvidersExecuted(providerContext);
// Assert
ControllerModel controller = Assert.Single(providerContext.Result.Controllers);
ActionModel action = Assert.Single(controller.Actions);
Assert.Equal("AnyMethodNameHere", action.ActionMethod.Name);
Assert.Single(action.Parameters);
Assert.Equal(2, action.Selectors.Count);
Assert.Equal(new[] { "odata/Customers({key})/Name", "odata/Customers/{key}/Name" }, action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
/// <inheritdoc/>
public override async Task ProcessBatchAsync(HttpContext context, RequestDelegate nextHandler)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (nextHandler == null)
{
throw Error.ArgumentNull("nextHandler");
}
if (!await ValidateRequest(context.Request))
{
return;
}
IList <ODataBatchRequestItem> subRequests = await ParseBatchRequestsAsync(context);
ODataOptions options = context.RequestServices.GetRequiredService <ODataOptions>();
bool enableContinueOnErrorHeader = (options != null)
? options.EnableContinueOnErrorHeader
: false;
SetContinueOnError(new WebApiRequestHeaders(context.Request.Headers), enableContinueOnErrorHeader);
IList <ODataBatchResponseItem> responses = await ExecuteRequestMessagesAsync(subRequests, nextHandler);
await CreateResponseMessageAsync(responses, context.Request);
}
/// <summary>
/// Initializes a new instance of the WebApiRequestMessage class.
/// </summary>
/// <param name="request">The inner request.</param>
public WebApiRequestMessage(HttpRequest request)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
this.innerRequest = request;
this.Headers = new WebApiRequestHeaders(request.Headers);
IODataFeature feature = request.ODataFeature();
if (feature != null)
{
this.Context = new WebApiContext(feature);
}
// Get the ODataOptions from the global service provider.
ODataOptions options = request.HttpContext.RequestServices.GetRequiredService <ODataOptions>();
if (options != null)
{
this.Options = new WebApiOptions(options);
}
}
public static ODataQueryOptions <T> GetODataQueryOptions <T>(string queryString, IServiceProvider serviceProvider) where T : class
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <T>(typeof(T).Name);
IEdmModel model = builder.GetEdmModel();
IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet(typeof(T).Name);
ODataPath path = new ODataPath(new Microsoft.OData.UriParser.EntitySetSegment(entitySet));
var request = new DefaultHttpContext()
{
RequestServices = serviceProvider
}.Request;
var oDataOptions = new ODataOptions().AddRouteComponents("key", model,
x => x.AddSingleton <ISearchBinder, OpsTenantSearchBinder>());
var(_, routeProvider) = oDataOptions.RouteComponents["key"];
request.ODataFeature().Services = routeProvider;
var oDataQueryOptions = new ODataQueryOptions <T>
(
new ODataQueryContext(model, typeof(T), path),
BuildRequest(request, new Uri(BASEADDRESS + queryString))
);
return(oDataQueryOptions);
private static ODataRoutingApplicationModelProvider CreateProvider(ODataOptions options,
IEnumerable <IODataControllerActionConvention> conventions)
{
IOptions <ODataOptions> odataOptions = Options.Create(options);
return(new ODataRoutingApplicationModelProvider(conventions, odataOptions));
}
/// <inheritdoc/>
public override async Task ProcessBatchAsync(HttpContext context, RequestDelegate nextHandler)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (nextHandler == null)
{
throw new ArgumentNullException(nameof(nextHandler));
}
if (!await ValidateRequest(context.Request).ConfigureAwait(false))
{
return;
}
IList <ODataBatchRequestItem> subRequests = await ParseBatchRequestsAsync(context).ConfigureAwait(false);
// ODataOptions options = context.RequestServices.GetRequiredService<ODataOptions>();
ODataOptions options = context.RequestServices.GetRequiredService <IOptions <ODataOptions> >().Value;
bool enableContinueOnErrorHeader = (options != null)
? options.EnableContinueOnErrorHeader
: false;
SetContinueOnError(context.Request.Headers, enableContinueOnErrorHeader);
IList <ODataBatchResponseItem> responses = await ExecuteRequestMessagesAsync(subRequests, nextHandler).ConfigureAwait(false);
await CreateResponseMessageAsync(responses, context.Request).ConfigureAwait(false);
}
public IActionResult Index(ODataOptions <Entity> options)
{
return(View(new ODataSqlQuery(
"SELECT FROM Entities WHERE OwnerId = @p0",
10456, options
)));
}
/// <summary>
/// Gets the dependency injection container for the OData request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The dependency injection container.</returns>
public static IServiceProvider GetSubServiceProvider(this HttpRequest request)
{
if (request == null)
{
throw Error.ArgumentNull(nameof(request));
}
IServiceProvider requestContainer = request.ODataFeature().SubServiceProvider;
if (requestContainer != null)
{
return(requestContainer);
}
IOptions <ODataOptions> odataOptionsOptions = request.HttpContext.RequestServices.GetRequiredService <IOptions <ODataOptions> >();
if (odataOptionsOptions == null)
{
throw Error.InvalidOperation(SRResources.MissingODataServices, nameof(ODataOptions));
}
ODataOptions options = odataOptionsOptions.Value;
return(options.GetODataServiceProvider(request.ODataFeature().PrefixName));
// HTTP routes will not have chance to call CreateRequestContainer. We have to call it.
// return request.CreateSubServiceProvider(request.ODataFeature().PrefixName);
}
static AttributeRoutingConventionTests()
{
_edmModel = GetEdmModel();
_options = new ODataOptions();
_options.AddModel(_edmModel);
_attributeConvention = CreateConvention();
}
public void AddODataWithSetup_OnMvcCoreBuilder_RegistersODataOptions()
{
// Arrange
var services = new ServiceCollection();
services.AddLogging();
IMvcCoreBuilder builder = new MyMvcCoreBuilder
{
Services = services
};
IEdmModel coreModel = EdmCoreModel.Instance;
// Act
builder.AddOData(opt => opt.AddModel("odata", EdmCoreModel.Instance));
IServiceProvider provider = services.BuildServiceProvider();
// Assert
IOptions <ODataOptions> options = provider.GetService <IOptions <ODataOptions> >();
Assert.NotNull(options);
ODataOptions odataOptions = options.Value;
var model = Assert.Single(odataOptions.Models);
Assert.Equal("odata", model.Key);
Assert.Same(coreModel, model.Value.Item1);
Assert.NotNull(model.Value.Item2);
}
public void SetDefaultODataOptions()
{
var defaultOptions = new ODataOptions
{
NullDynamicPropertyIsEnabled = false,
EnableContinueOnErrorHeader = false,
CompatibilityOptions = CompatibilityOptions.AllowNextLinkWithNonPositiveTopValue,
UrlKeyDelimiter = ODataUrlKeyDelimiter.Slash
};
var services = new ServiceCollection();
services.Insert(0, ServiceDescriptor.Singleton(new ODataOptions
{
NullDynamicPropertyIsEnabled = true,
EnableContinueOnErrorHeader = true,
CompatibilityOptions = CompatibilityOptions.None,
UrlKeyDelimiter = ODataUrlKeyDelimiter.Parentheses
}));
ODataOptions updatedOptions;
using (var serviceProvider = services.BuildServiceProvider())
{
serviceProvider.SetDefaultODataOptions(defaultOptions);
updatedOptions = serviceProvider.GetRequiredService <ODataOptions>();
}
Assert.Equal(defaultOptions.NullDynamicPropertyIsEnabled, updatedOptions.NullDynamicPropertyIsEnabled);
Assert.Equal(defaultOptions.EnableContinueOnErrorHeader, updatedOptions.EnableContinueOnErrorHeader);
Assert.Equal(defaultOptions.CompatibilityOptions, updatedOptions.CompatibilityOptions);
Assert.Equal(defaultOptions.UrlKeyDelimiter, updatedOptions.UrlKeyDelimiter);
}
public void PropertySetting_SetsCorrectValue()
{
// Arrange
ODataOptions options = new ODataOptions();
// verify default
Assert.Equal(ODataUrlKeyDelimiter.Slash, options.UrlKeyDelimiter); // Guard
Assert.False(options.EnableContinueOnErrorHeader);
Assert.True(options.EnableAttributeRouting);
Assert.Null(options.BuilderFactory);
Assert.Equal(TimeZoneInfo.Local, options.TimeZone);
Assert.True(options.RouteOptions.EnableKeyAsSegment);
Assert.True(options.EnableNoDollarQueryOptions);
// Act
options.UrlKeyDelimiter = ODataUrlKeyDelimiter.Parentheses;
options.EnableContinueOnErrorHeader = true;
options.EnableAttributeRouting = false;
options.BuilderFactory = () => null;
options.TimeZone = TimeZoneInfo.Utc;
options.RouteOptions.EnableKeyAsSegment = false;
options.EnableNoDollarQueryOptions = false;
// Act & Assert
Assert.Equal(ODataUrlKeyDelimiter.Parentheses, options.UrlKeyDelimiter);
Assert.True(options.EnableContinueOnErrorHeader);
Assert.False(options.EnableAttributeRouting);
Assert.NotNull(options.BuilderFactory);
Assert.Equal(TimeZoneInfo.Utc, options.TimeZone);
Assert.False(options.RouteOptions.EnableKeyAsSegment);
Assert.False(options.EnableNoDollarQueryOptions);
Assert.Empty(options.Models);
}
/// <inheritdoc/>
public override async Task ProcessBatchAsync(HttpContext context, RequestDelegate nextHandler)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (nextHandler == null)
{
throw Error.ArgumentNull("nextHandler");
}
if (!await ValidateRequest(context.Request))
{
return;
}
// This container is for the overall batch request.
HttpRequest request = context.Request;
IServiceProvider requestContainer = request.CreateRequestContainer(ODataRouteName);
requestContainer.GetRequiredService <ODataMessageReaderSettings>().BaseUri = GetBaseUri(request);
ODataMessageReader reader = request.GetODataMessageReader(requestContainer);
ODataBatchReader batchReader = await reader.CreateODataBatchReaderAsync();
List <ODataBatchResponseItem> responses = new List <ODataBatchResponseItem>();
Guid batchId = Guid.NewGuid();
ODataOptions options = context.RequestServices.GetRequiredService <ODataOptions>();
bool enableContinueOnErrorHeader = (options != null)
? options.EnableContinueOnErrorHeader
: false;
SetContinueOnError(new WebApiRequestHeaders(request.Headers), enableContinueOnErrorHeader);
while (await batchReader.ReadAsync())
{
ODataBatchResponseItem responseItem = null;
if (batchReader.State == ODataBatchReaderState.ChangesetStart)
{
responseItem = await ExecuteChangeSetAsync(batchReader, batchId, request, nextHandler);
}
else if (batchReader.State == ODataBatchReaderState.Operation)
{
responseItem = await ExecuteOperationAsync(batchReader, batchId, request, nextHandler);
}
if (responseItem != null)
{
responses.Add(responseItem);
if (responseItem.IsResponseSuccessful() == false && ContinueOnError == false)
{
break;
}
}
}
await CreateResponseMessageAsync(responses, request);
}
public MyODataRoutingMatcherPolicy(IODataTemplateTranslator translator,
IODataModelProvider provider,
IOptions <ODataOptions> options)
{
_translator = translator;
_provider = provider;
_options = options.Value;
}
public void AddRouteComponents_Throws_IfRoutePrefixNull()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => options.AddRouteComponents(null, EdmCoreModel.Instance, builder => { }), "routePrefix");
}
public void GetRouteServices_ReturnsNull()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
Assert.Null(options.GetRouteServices(null));
}
public void AddModel_Throws_IfModelNull()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => options.AddModel("odata", null, builder => { }), "model");
}
public DynamicsSignInManager(UserManager <TUser> userManager, IHttpContextAccessor contextAccessor, IUserClaimsPrincipalFactory <TUser> claimsFactory, IOptions <IdentityOptions> optionsAccessor, ILogger <SignInManager <TUser> > logger, IOptions <ODataOptions> odataOptions)
: base(userManager, contextAccessor, claimsFactory, optionsAccessor, logger)
{
var context = contextAccessor.HttpContext;
this.authenticationManager = context.Authentication;
this.odataOptions = odataOptions.Value;
}
public void ODataOptionsSetup_DoesNotSetup_ODataRoutingConventions()
{
// Arrange & Act
ODataOptions options = GetODataOptions(false);
// Assert
Assert.Empty(options.Conventions);
}
public void GetODataServiceProvider_ReturnsNull()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
Assert.Null(options.GetODataServiceProvider(null));
}
static void ConfigurePathHandler(this IServiceProvider rootContainer, ODataOptions options)
{
var pathHandler = rootContainer.GetRequiredService <IODataPathHandler>();
if (pathHandler != null && pathHandler.UrlKeyDelimiter == null)
{
pathHandler.UrlKeyDelimiter = options.UrlKeyDelimiter;
}
}
public ODataService(IPrincipal user, IDynamicsHttpClient httpClient, IOptions <ODataOptions> odataOptions, ILockEntityService lockEntityService)
{
this.user = user as ClaimsPrincipal;
this.odataOptions = odataOptions.Value;
this.httpClient = httpClient;
this.lockEntityService = lockEntityService;
BuildUrls();
}
public void SetMaxTop_Throws_ForWrongValue()
{
// Arrange
ODataOptions options = new ODataOptions();
// Act & Assert
ArgumentOutOfRangeException exception = ExceptionAssert.Throws <ArgumentOutOfRangeException>(() => options.SetMaxTop(-2));
Assert.Contains("Value must be greater than or equal to 0", exception.Message);
}
/// <summary>
/// Initialize the middleware
/// </summary>
/// <param name="options">The OData options.</param>
private void Initialize(ODataOptions options)
{
Contract.Assert(options != null);
foreach (var model in options.Models)
{
string openapiPath = string.IsNullOrEmpty(model.Key) ? $"/{_requestName}" : $"/{model.Key}/{_requestName}";
AddRoute(model.Key, openapiPath);
}
}
/// <summary>
/// Initializes a new instance of the WebApiOptions class.
/// </summary>
/// <param name="options">The inner options.</param>
public WebApiOptions(ODataOptions options)
{
if (options == null)
{
throw Error.ArgumentNull("options");
}
this.NullDynamicPropertyIsEnabled = options.NullDynamicPropertyIsEnabled;
this.UrlKeyDelimiter = options.UrlKeyDelimiter;
}
/// <summary>
/// Get the UrlKeyDelimiter in DefaultODataPathHandler.
/// </summary>
/// <param name="builder">The <see cref="IEndpointRouteBuilder"/>.</param>
internal static ODataUrlKeyDelimiter GetUrlKeyDelimiter(this IEndpointRouteBuilder builder)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
ODataOptions defaultOptions = builder.GetDefaultODataOptions();
return(defaultOptions.UrlKeyDelimiter);
}
