private IMongoQueryable <T> GetQueryableByConditionsAndSort <TKey>(Expression <Func <T, bool> > expression, Sort <T, TKey> sort)
{
if (sort == null)
{
throw new ArgumentNullException(nameof(sort));
}
IMongoQueryable <T> entities = this.GetQueryableByConditions(expression);
switch (sort.SortType)
{
case SortType.Asc:
entities = entities.OrderBy(sort.SortExpression);
break;
case SortType.Desc:
entities = entities.OrderByDescending(sort.SortExpression);
break;
default:
throw new ArgumentException();
}
return(entities);
}
public static IMongoQueryable <T> SortBy <T>(this IMongoQueryable <T> query, IEnumerable <SortRequest> sorts)
{
if (sorts == null || !sorts.Any())
{
return(query);
}
var firstSort = sorts.FirstOrDefault();
IOrderedQueryable <T> result = null;
// ReSharper disable once PossibleNullReferenceException
if (firstSort.Asc)
{
result = query.OrderBy(firstSort.Field);
}
else
{
result = query.OrderByDescending(firstSort.Field);
}
for (int i = 1; i < sorts.Count(); i++)
{
var sort = sorts.ElementAt(i);
if (sort.Asc)
{
result = result.ThenBy(sort.Field);
}
else
{
result = result.ThenByDescending(sort.Field);
}
}
return(result as IMongoQueryable <T>);
}
public static async Task <IQueryResult <TDocument> > Paginate <TDocument>(this IMongoQueryable <TDocument> queryable, PaginationOptions <TDocument> options)
{
if (options == default)
{
options = new PaginationOptions <TDocument>()
{
Page = DefaultPage,
PageSize = DefaultPageSize
};
}
if (options.Sorting != default && options.Sorting.Any())
{
(var selector, var ascending) = options.Sorting.First();
var orderQueryable = ascending ? queryable.OrderBy(selector) : queryable.OrderByDescending(selector);
foreach (var(selectorThen, ascendingThen) in options.Sorting.Skip(1))
{
orderQueryable = ascendingThen ? orderQueryable.ThenBy(selectorThen) : orderQueryable.ThenByDescending(selectorThen);
}
queryable = orderQueryable;
}
int page = options.Page ?? DefaultPage;
int pageSize = options.PageSize ?? DefaultPageSize;
int toSkip = (page - 1) * pageSize;
List <TDocument> listResult = await queryable.Skip(toSkip).Take(pageSize + 1).ToListAsync();
var hasNext = listResult.Count >= (pageSize + 1);
if (hasNext)
{
listResult.RemoveAt(listResult.Count - 1);
}
return(new QueryResult <TDocument>(hasNext, listResult));
}
public TRepositoryType OrderByDescending <TKey>(Expression <Func <TType, TKey> > expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
_query = _query.OrderByDescending(expression);
return(GetSelf());
}
public async Task <IReadOnlyList <LogModule.Domain.Entities.Log> > GetPagedReponseAsync(int pageNumber, int pageSize, LogLevels logLevel = LogLevels.ALL, string sorOrder = "desc")
{
IMongoQueryable <LogModule.Domain.Entities.Log> query = _logs.AsQueryable();
switch (logLevel)
{
case LogLevels.ALL:
break;
case LogLevels.Information:
query = query.Where(x => x.Level == "Information");
break;
case LogLevels.Error:
query = query.Where(x => x.Level == "Error");
break;
case LogLevels.Warning:
query = query.Where(x => x.Level == "Warning");
break;
case LogLevels.Debug:
query = query.Where(x => x.Level == "Debug");
break;
case LogLevels.Fatal:
query = query.Where(x => x.Level == "Fatal");
break;
case LogLevels.Critical:
query = query.Where(x => x.Level == "Critical");
break;
case LogLevels.Trace:
query = query.Where(x => x.Level == "Trace");
break;
case LogLevels.Verbose:
query = query.Where(x => x.Level == "Verbose");
break;
default:
break;
}
switch (sorOrder)
{
default:
query = query.OrderByDescending(x => x.Id); //.ThenByDescending(t => t.Timestamp);
break;
}
return(await query
.Skip((pageNumber - 1) *pageSize)
.Take(pageSize)
.ToListAsync());
}
public async Task <IEnumerable <T> > FindAsync <TKey>(Expression <Func <T, bool> > filter, Expression <Func <T, TKey> > orderBy, bool desc = false, int?top = null)
{
IMongoQueryable <T> query = entities.AsQueryable().Where(filter);
query = desc ? query.OrderByDescending(orderBy) : query.OrderBy(orderBy);
if (top != null)
{
query = query.Take(top ?? 0);
}
return(await query.ToListAsync());
}
public void _03_BooksWithMaxMinCount()
{
var bookMax = queryable.OrderByDescending(b => b.count).First();
Assert.IsTrue(bookMax.count == 11);
var bookMin = queryable.OrderBy(b => b.count).First();
Assert.IsTrue(bookMin.count == 1);
Console.WriteLine(bookMax.name + "\t" + bookMax.count
+ "\n\n"
+ bookMin.name + "\t" + bookMin.count);
}
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, string orderBy,
string sortOrder, int page = 1, int resultsPerPage = 10)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = await collection.AnyAsync() == false;
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = await collection.CountAsync();
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
List <T> data;
if (string.IsNullOrWhiteSpace(orderBy))
{
data = await collection.Limit(page, resultsPerPage).ToListAsync();
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
if (sortOrder?.ToLowerInvariant() == "asc")
{
data = await collection.OrderBy(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync();
}
else
{
data = await collection.OrderByDescending(ToLambda <T>(orderBy)).Limit(page, resultsPerPage)
.ToListAsync();
}
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
public static async Task <PagedResult <T> > Paginate <T>(this IMongoQueryable <T> collection, string orderBy,
string sortOrderDirection = DefaultSort, int page = DefaultPage, int resultsPerPage = DefaultPageSize, CancellationToken cancellationToken = default)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = await collection.AnyAsync(cancellationToken) == false;
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = await collection.CountAsync(cancellationToken);
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
List <T> data;
if (string.IsNullOrWhiteSpace(orderBy))
{
data = await collection.Limit(page, resultsPerPage).ToListAsync(cancellationToken);
return(PagedResult <T> .From(data, page, resultsPerPage, totalPages, totalResults));
}
var sortOrder = SortOrder.From(sortOrderDirection);
if (sortOrder == SortOrder.Ascending)
{
data = await collection.OrderBy(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(cancellationToken);
}
else
{
data = await collection.OrderByDescending(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(cancellationToken);
}
return(PagedResult <T> .From(data, page, resultsPerPage, totalPages, totalResults));
}
/// <summary>
/// 日志分页查询
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">分页大小</param>
/// <param name="func">lambda表达式</param>
/// <param name="totalCount">总数</param>
/// <returns>查询结果</returns>
public List <T> GetPageList <T>(int pageIndex, int pageSize, Expression <Func <T, bool> > func, out int totalCount)
where T : Model.BaseInfo
{
IMongoCollection <T> mongoCollection = this.GetCollection <T>();
IMongoQueryable <T> mongoQueryable = mongoCollection.AsQueryable();
if (func != null)
{
mongoQueryable = mongoQueryable.Where(func); //.AsQueryable();
}
totalCount = mongoQueryable.Count();
return(mongoQueryable
.OrderByDescending(m => m.Time)
.Skip((pageIndex) * pageSize).Take(pageSize)
.ToList());
}
public async Task <IEnumerable <Notification> > GetNotificationAsync(Username username, bool?isSeen, int skip, int take, CancellationToken cancellationToken)
{
IMongoQueryable <Notification>?queryable = DbSet.AsQueryable();
queryable = queryable.Where(x => x.Username.Value == username.Value);
if (isSeen.HasValue)
{
queryable = queryable.Where(x => x.IsSeen == isSeen.Value);
}
queryable = queryable.OrderByDescending(x => x.CreatedOn);
List <Notification> notificationList = await queryable.Skip(skip).Take(take).ToListAsync(cancellationToken);
if (!notificationList.Any())
{
throw new NotFoundException <Notification>();
}
return(notificationList);
}
private static IOrderedMongoQueryable <TSource> OrderData <TSource>(this IMongoQueryable <TSource> data,
string filterPropertyName, SortOrder sortOrder)
{
var filterProperty = typeof(TSource).GetProperty(filterPropertyName,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
if (filterProperty is null)
{
throw new MissingMemberException();
}
var filterExpression = BuildFilterExpression <TSource, object>(filterProperty);
switch (sortOrder)
{
case SortOrder.desc:
return(data.OrderByDescending(filterExpression));
case SortOrder.asc:
default:
return(data.OrderBy(filterExpression));
}
}
private IMongoQueryable <User> SetFilters(Contract request, IMongoQueryable <User> queryable)
{
queryable = queryable.Where(u =>
u.Id != request.UserId && !u.IsBlocked
);
if (request.UserRole != "Admin")
{
queryable = queryable.Where(u =>
u.AllowRecommendation.HasValue &&
u.AllowRecommendation.Value &&
u.SecretaryAllowRecommendation.HasValue &&
u.SecretaryAllowRecommendation.Value
);
}
if (request.MandatoryFields)
{
queryable = queryable.Where(u =>
!string.IsNullOrEmpty(u.ImageUrl) &&
!string.IsNullOrEmpty(u.Name) &&
u.DateBorn != null &&
u.Address != null &&
!string.IsNullOrEmpty(u.Address.Street) &&
!string.IsNullOrEmpty(u.Address.District) &&
!string.IsNullOrEmpty(u.Address.City) &&
!string.IsNullOrEmpty(u.Address.State) &&
!string.IsNullOrEmpty(u.Phone) &&
!string.IsNullOrEmpty(u.Email)
);
}
if (request.Filters == null)
{
return(queryable);
}
if (!String.IsNullOrEmpty(request.Filters.Term))
{
queryable = queryable.Where(user =>
user.Name.ToLower()
.Contains(request.Filters.Term.ToLower()) ||
user.Email.ToLower()
.Contains(request.Filters.Term.ToLower())
);
}
if (!string.IsNullOrEmpty(request.Filters.SortBy))
{
if (request.Filters.SortBy == "name")
{
if (request.Filters.IsSortAscending.Value)
{
queryable = queryable.OrderBy(user => user.Name);
}
else
{
queryable = queryable.OrderByDescending(user => user.Name);
}
}
}
return(queryable);
}
public override IMongoQueryable <LogDocument> Sort(IMongoQueryable <LogDocument> logs) => logs.OrderByDescending(l => l.Date);
private IMongoQueryable <User> SetFilters(Contract request, IMongoQueryable <User> queryable)
{
queryable = queryable.Where(u =>
u.Id != request.UserId
);
if (request.UserRole == "Student")
{
queryable = queryable.Where(u => u.ResponsibleId == request.UserId);
}
if (request.Filters == null)
{
return(queryable);
}
if (!String.IsNullOrEmpty(request.Filters.Term))
{
queryable = queryable.Where(user =>
user.Name.ToLower()
.Contains(request.Filters.Term.ToLower()) ||
user.Email.ToLower()
.Contains(request.Filters.Term.ToLower())
);
}
if (request.Filters.CreatedSince.HasValue)
{
queryable = queryable.Where(user =>
user.CreatedAt >= request.Filters.CreatedSince.Value.Date
);
}
if (request.UserRole == "Student" && !String.IsNullOrEmpty(request.Filters.Dependent))
{
queryable = queryable.Where(user =>
user.LineManager.ToLower()
.Contains(request.Filters.Dependent.ToLower())
);
}
if (request.Filters.CategoryFilter != null && request.Filters.CategoryFilter.Count > 0)
{
foreach (UserCategoryFilter userCategoryFilter in request.Filters.CategoryFilter)
{
foreach (string contentName in userCategoryFilter.ContentNames)
{
queryable = FilterByCategory(
queryable, userCategoryFilter.ColumnName, contentName
);
}
}
}
if (!string.IsNullOrEmpty(request.Filters.SortBy))
{
if (request.Filters.SortBy == "name")
{
if (request.Filters.IsSortAscending.Value)
{
queryable = queryable.OrderBy(user => user.Name);
}
else
{
queryable = queryable.OrderByDescending(user => user.Name);
}
}
}
return(queryable);
}
private async Task <PageResponse <T> > FilterAndSortQuery <T>(IMongoQueryable <T> query, PageInfo info, string senderId) where T : ISupportFiltering
{
if (!string.IsNullOrWhiteSpace(info.Order) && !string.IsNullOrWhiteSpace(info.OrderBy))
{
if (typeof(T).GetProperty(info.Order, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance) != null)
{
query = info.OrderBy == "ASCENDING"
? query.OrderBy(GetPropertySelector <T>(info.Order))
: query.OrderByDescending(GetPropertySelector <T>(info.Order));
}
}
var responses = await query.ToListAsync();
if (info.CreatedBySender.HasValue && info.CreatedBySender.Value)
{
responses = responses.Where(response => response.CheckCreator(senderId)).ToList();
}
if (info.DateLabels != null)
{
responses = responses.Where(response => response.CheckDateStatus(info.DateLabels.Select(l => l.ToLower()).ToList())).ToList();
}
if (!string.IsNullOrWhiteSpace(info.Filter))
{
var filters = new Regex(@"\s").Split(info.Filter.ToLower());
var groupfilters = new List <string>();
var textsfilter = new List <string>();
var groupNames = (await _groupRepository.GetAllAsync()).Select(group => group.Name).ToList();
bool groupflag;
bool textflag;
var filteredResponses = new List <T>();
foreach (var filter in filters)
{
if (groupNames.Contains(filter))
{
groupfilters.Add(filter);
}
else
{
textsfilter.Add(filter);
}
}
foreach (var response in responses)
{
groupflag = true;
textflag = true;
if (groupfilters.Count != 0)
{
groupflag = response.CheckGroupFilters(groupfilters);
}
if (textsfilter.Count != 0)
{
foreach (var filter in textsfilter)
{
textflag = response.CheckTextFilter(filter);
if (!textflag)
{
break;
}
}
}
if (groupflag && textflag)
{
filteredResponses.Add(response);
}
}
responses = filteredResponses;
}
return(new PageResponse <T>
{
CurrentPage = info.CurrentPage,
ItemsPerPage = info.ItemsPerPage,
TotalItems = responses.Count,
TotalPages = (int)Math.Ceiling((double)responses.Count / info.ItemsPerPage),
Items = responses.Skip((info.CurrentPage - 1) * info.ItemsPerPage).Take(info.ItemsPerPage)
});
}
public static IMongoQueryable <T> Apply <T>(this IMongoQueryable <T> queryable, IOrderBy <T>?specification)
{
if (specification == null)
{
return(queryable);
}
var orderByExpression = specification.OrderByExpression;
return(specification.SortDirection == SortDirection.Ascending ? queryable.OrderBy(orderByExpression) : queryable.OrderByDescending(orderByExpression));
}
