/// <summary>Ors the current filter.</summary>
/// <param name="filter">The new filter.</param>
/// <returns>A filter expression.</returns>
public IFilterExpression <T> Or(string filter)
{
this.query = this.queryFactory.Modify(new Dictionary <string, string> {
{ "$filter", $" or {filter}" }
}, this.query);
return(this);
}
public async Task <IODataQueryable <Track> > GetTracks(IODataQuery <Track> query)
{
using (var context = new ChinookEntities())
{
var r = query.ApplyTo(context.Track.Include(x => x.Album));
return(await r.ToListAsync());
}
}
public async Task <IODataQueryable <Album> > GetAlbums(IODataQuery <Album> query)
{
using (var context = new ChinookEntities())
{
var r = query.ApplyTo(context.Album.Include(x => x.Artist));
return(await r.ToListAsync());
}
}
public async Task <IEnumerable <Artist> > GetArtists(IODataQuery <Artist> query)
{
using (var context = new ChinookEntities())
{
var r = query.ApplyTo(context.Artist);
return(await r.ToListAsync());
}
}
private static SortDefinition <T> CreateODataSort <T>(IODataQuery query, bool check = false)
{
var orderby = query.Order;
SortDefinitionBuilder <T> sortBuilder = Builders <T> .Sort;
SortDefinition <T> sortDefinition = null;
SortDefinition <T> defaultSortDefinition = sortBuilder.Descending("CreateDate");
if (String.IsNullOrEmpty(orderby))
{
return(defaultSortDefinition);
}
var sections = orderby.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
foreach (var section in sections)
{
var order = section.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
var field = order.FirstOrDefault();
var direction = "asc";
if (check && !typeof(T).HasField(field))
{
continue;
}
if (order.LastOrDefault().ToLower() == "desc")
{
direction = "desc";
}
if (sortDefinition == null)
{
sortDefinition = direction == "asc"
? sortBuilder.Ascending(field)
: sortBuilder.Descending(field);
}
sortDefinition = direction == "asc"
? sortDefinition.Ascending(field)
: sortDefinition.Descending(field);
}
return(sortDefinition ?? defaultSortDefinition);
}
private static FilterDefinition <T> CreateODataFilter <T>(IODataQuery query, bool check = false)
{
var filter = query.Filter;
if (String.IsNullOrEmpty(filter))
{
return(FilterDefinition <T> .Empty);
}
var sections = filter.Split(new string[] { " and ", " or " }, StringSplitOptions.RemoveEmptyEntries);
var firstSection = sections.FirstOrDefault();
var fieldIdx = firstSection.IndexOf(" ");
var operatorIdx = firstSection.IndexOf(" ", fieldIdx + 1);
var field = firstSection.Substring(0, fieldIdx);
var operatorName = firstSection.Substring(fieldIdx + 1, operatorIdx - fieldIdx - 1);
var stringValue = firstSection.Substring(operatorIdx + 1);
object value = stringValue;
if (check)
{
var propery = typeof(T)
.GetProperties()
.Where(r => r.Name.ToLower() == field.ToLower())
.SingleOrDefault();
if (propery == null)
{
return(FilterDefinition <T> .Empty);
}
value = Cast(stringValue, propery.PropertyType);
}
if (value == null)
{
return(FilterDefinition <T> .Empty);
}
return(CreatePredicate <T>(operatorName, field, value));
}
/// <summary>Initializes a new instance of the <see cref="FilterExpression{T}" /> class.</summary>
/// <param name="queryFactory">The query options factory.</param>
/// <param name="query">The query.</param>
internal FilterExpression(IODataQueryFactory queryFactory, IODataQuery <T> query)
{
this.queryFactory = queryFactory;
this.query = query;
}
/// <summary>Modifies the original query and returns a new one.</summary>
/// <typeparam name="T">The object type.</typeparam>
/// <param name="clauses">The clauses.</param>
/// <param name="original">The original query.</param>
/// <returns>A new query.</returns>
public IODataQuery <T> Modify <T>(Dictionary <string, string> clauses, IODataQuery <T> original)
{
var builder = new UriBuilder(original.Options.Request.RequestUri);
// Modify query string items
var querystring = this.GetQueryParameters(original.Options.Request, original.Options.Context);
if (clauses.ContainsKey("$filter"))
{
if (!querystring.ContainsKey("$filter"))
{
if (clauses["$filter"].Trim().StartsWith("and"))
{
querystring["$filter"] = clauses["$filter"].Trim().Substring(3).Trim();
}
else if (clauses["$filter"].Trim().StartsWith("or"))
{
querystring["$filter"] = clauses["$filter"].Trim().Substring(2).Trim();
}
else
{
querystring["$filter"] = clauses["$filter"];
}
}
else
{
querystring["$filter"] = querystring["$filter"] + clauses["$filter"];
}
}
if (clauses.ContainsKey("$orderby"))
{
if (!querystring.ContainsKey("$orderby"))
{
querystring["$orderby"] = clauses["$orderby"].Trim().StartsWith(",") ? clauses["$orderby"].Trim().Substring(1) : clauses["$orderby"];
}
else
{
querystring["$orderby"] = querystring["$orderby"] + clauses["$orderby"];
}
}
if (clauses.ContainsKey("$expand"))
{
if (!querystring.ContainsKey("$expand"))
{
querystring["$expand"] = clauses["$expand"].Trim().StartsWith(",") ? clauses["$expand"].Trim().Substring(1) : clauses["$expand"];
}
else
{
querystring["$expand"] = querystring["$expand"] + clauses["$expand"];
}
}
if (clauses.ContainsKey("$select"))
{
if (!querystring.ContainsKey("$select"))
{
querystring["$select"] = clauses["$select"].Trim().StartsWith(",") ? clauses["$select"].Trim().Substring(1) : clauses["$select"];
}
else
{
querystring["$select"] = querystring["$select"] + clauses["$select"];
}
}
builder.Query = string.Join("&", querystring.Select(x => $"{x.Key}={this.EscapeODataQueryComponent(x.Value)}"));
var mappedRequest = this.Clone(original.Options.Request);
mappedRequest.RequestUri = builder.Uri;
return(new ODataQuery <T>(original.Options.Context, mappedRequest));
}
public static async Task <PagedCollection <T> > ApplyOData <T>(this IMongoCollection <T> collection, IODataQuery query)
{
var page = 1;
var skip = query.Skip.Normalize(0);
var limit = query.Limit.Normalize(10, 1000);
var countFacet = AggregateFacet.Create("count",
PipelineDefinition <T, AggregateCountResult> .Create(new[]
{
PipelineStageDefinitionBuilder.Count <T>()
}));
var sort = CreateODataSort <T>(query, false);
var filter = CreateODataFilter <T>(query, false);
var dataFacet = AggregateFacet.Create("data",
PipelineDefinition <T, T> .Create(new []
{
PipelineStageDefinitionBuilder.Sort(sort),
PipelineStageDefinitionBuilder.Skip <T>(skip),
PipelineStageDefinitionBuilder.Limit <T>(limit),
}));
var aggregation = await collection.Aggregate()
.Match(filter)
.Facet(countFacet, dataFacet)
.ToListAsync();
var count = aggregation.First()
.Facets.First(x => x.Name == "count")
.Output <AggregateCountResult>()
.First()
.Count;
int totalPages = (int)(count / limit);
var data = aggregation.First()
.Facets.First(x => x.Name == "data")
.Output <T>();
return(PagedCollection <T> .Create(data, page, limit, totalPages, count));
}
