private async Task <object> GetResultWithCount <T>(IQueryable <T> queryable, HttpRequestMessage httpRequestMessage,
IQueryableToODataResultConverter converter)
{
var queryOptions = GetQueryOptions <T>(httpRequestMessage);
return(await converter.ToListWithCountAsync(queryable, queryOptions, default(CancellationToken)));
}
public override async Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
{
await base.OnActionExecutedAsync(actionExecutedContext, cancellationToken);
var originalContent = actionExecutedContext.Response?.Content as ObjectContent;
if (originalContent?.Value != null &&
originalContent.ObjectType.IsConstructedGenericType &&
originalContent.ObjectType.GetGenericTypeDefinition() == typeof(IQueryable <>))
{
Type entityType = originalContent.ObjectType.GenericTypeArguments[0];
bool includeCount = actionExecutedContext.Request.RequestUri.Query.Contains("$count=true") ||
actionExecutedContext.Request.RequestUri.Query.Contains("%24count=true"); // TODO improve
IQueryable queryable = (IQueryable)originalContent.Value;
IQueryableToODataResultConverter converter =
ODataResultConverters.FirstOrDefault(x => x.Supports(queryable))
?? DefaultConverter.Instance;
object result;
if (includeCount)
{
var method = this.GetType().GetMethod(nameof(GetResultWithCount), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(new[] { entityType });
result = await(Task <object>) method.Invoke(this, new object[] { queryable, actionExecutedContext.Request, converter });
}
else
{
var method = this.GetType().GetMethod(nameof(GetResult), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(new[] { entityType });
result = await(Task <object>) method.Invoke(this, new object[] { queryable, actionExecutedContext.Request, converter });
}
actionExecutedContext.Response.Content = (HttpContent)typeof(ObjectContent <>)
.MakeGenericType(result.GetType())
.GetConstructors().First(x => x.GetParameters().Length == 3)
.Invoke(new object[]
{
result,
originalContent.Formatter,
originalContent.Headers.ContentType.MediaType
});
}
}
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
{
var originalContent = context.Result as ObjectResult;
if (originalContent?.Value != null &&
originalContent.DeclaredType.IsConstructedGenericType &&
originalContent.DeclaredType.GetGenericTypeDefinition() == typeof(IQueryable <>))
{
Type entityType = originalContent.DeclaredType.GenericTypeArguments[0];
ODataQueryOptions queryOptions = GetQueryOptions(context, entityType);
bool includeCount = queryOptions.Count?.Value ?? false;
var odataResultConverters =
((IKernel)context.HttpContext.RequestServices.GetRequiredService(typeof(IKernel)))
.GetAll <IQueryableToODataResultConverter>();
IQueryable queryable = (IQueryable)originalContent.Value;
IQueryableToODataResultConverter converter =
odataResultConverters.FirstOrDefault(x => x.Supports(queryable))
?? DefaultConverter.Instance;
object result;
if (includeCount)
{
var method = GetType().GetMethod(nameof(GetResultWithCount), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(new[] { entityType });
result = await(Task <object>) method.Invoke(this, new object[] { queryable, queryOptions, converter });
}
else
{
var method = GetType().GetMethod(nameof(GetResult), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(new[] { entityType });
result = await(Task <object>) method.Invoke(this, new object[] { queryable, queryOptions, converter });
}
context.Result = new ObjectResult(result);
}
await next();
}
private async Task <object> GetResultWithCount <T>(IQueryable <T> queryable, ODataQueryOptions <T> queryOptions,
IQueryableToODataResultConverter converter)
{
return(await converter.ToListWithCountAsync(queryable, queryOptions, default(CancellationToken)));
}
