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 IOrderedMongoQueryable <Device> SortSource(IMongoQueryable <Device> source)
{
IOrderedMongoQueryable <Device> orderedSource = source.OrderBy(e => e.Id);
string property = string.Empty;
bool alreadyOrdered = false;
bool asc = true;
foreach (var item in Sort)
{
property = stringToPropertyName.FirstOrDefault(e => e.Key == item || e.Key == item.Substring(1)).Value.Trim();
asc = !item.StartsWith("-");
if (alreadyOrdered)
{
orderedSource = asc ? OrderThenAsc(orderedSource, property) : OrderThenDesc(orderedSource, property);
}
else
{
orderedSource = asc ? OrderAsc(orderedSource, property) : OrderDesc(orderedSource, property);
alreadyOrdered = true;
}
}
return(orderedSource);
}
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));
}
/// <summary>
/// List documents
/// </summary>
/// <typeparam name="Tkey">Parameter type</typeparam>
/// <param name="orderBy">Parameter orderBy</param>
/// <param name="filter">`Parameter filter</param>
/// <returns>List documents</returns>
public IList <T> List <Tkey>(Expression <Func <T, Tkey> > orderBy, Expression <Func <T, bool> > filter = null)
{
IMongoQueryable <T> query = Collection.AsQueryable();
return((filter != null)
? query.Where(filter).OrderBy(orderBy).ToList()
: query.OrderBy(orderBy).ToList());
}
/// <summary>
/// List documents
/// </summary>
/// <typeparam name="Tkey">Parameter type</typeparam>
/// <param name="orderBy">Parameter orderBy</param>
/// <param name="filter">`Parameter filter</param>
/// <returns>List documents</returns>
public async Task <IList <T> > ListAsync <Tkey>(Expression <Func <T, Tkey> > orderBy, Expression <Func <T, bool> > filter = null)
{
IMongoQueryable <T> query = Collection.AsQueryable();
return((filter != null)
? await query.Where(filter).OrderBy(orderBy).ToListAsync()
: await query.OrderBy(orderBy).ToListAsync());
}
public static IMongoQueryable <T> ApplyOrdering <T>(this IMongoQueryable <T> query, string propertyName, bool descending)
{
if (!Regex.IsMatch(propertyName ?? string.Empty, "^[a-zA-Z]+(.[a-zA-Z]+)?$"))
{
return(query);
}
return((IMongoQueryable <T>)query.OrderBy($"{propertyName} {(descending ? "DESC" : "ASC")}"));
}
public TRepositoryType OrderBy <TKey>(Expression <Func <TType, TKey> > expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
_query = _query.OrderBy(expression);
return(GetSelf());
}
public IEnumerable <TEntity> GetAll(params ISorting[] sortingColumns)
{
IMongoQueryable <TEntity> query = GetSet();
if (sortingColumns != null && sortingColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortingColumns);
}
return(query.ToList());
}
public async Task <IList <TEntity> > ListAsync <Tkey>(Expression <Func <TEntity, Tkey> > orderBy, Expression <Func <TEntity, bool> > filter = null)
{
IMongoQueryable <TEntity> query = _collection.AsQueryable();
if (filter != null)
{
return(await query.Where(filter).OrderBy(orderBy).ToListAsync());
}
return(await query.OrderBy(orderBy).ToListAsync());
}
public IEnumerable <TEntity> AllMatching(ISpecification <TEntity> specification, params ISorting[] sortingColumns)
{
IMongoQueryable <TEntity> query = GetSet().Where(specification.SatisfiedBy());
if (sortingColumns != null && sortingColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortingColumns);
}
return(query);
}
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 static IMongoQueryable <Book> SearchQuery(this IMongoQueryable <Book> collection,
string query)
{
if (string.IsNullOrWhiteSpace(query))
{
return(collection.OrderBy(x => x.Title));
}
return(collection.Where(x => x.Title.ToLowerInvariant()
.Contains(query.ToLowerInvariant())));
}
public TEntity GetFirst(Expression <Func <TEntity, bool> > filter, params ISorting[] sortColumns)
{
IMongoQueryable <TEntity> query = filter == null?GetSet() : GetSet().Where(filter);
if (sortColumns != null && sortColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns);
}
return(query.FirstOrDefault());
}
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));
}
public QueryResult <QueryContractCall> ContractCall(string address, string filterAddress, int?offset, int limit)
{
IMongoQueryable <CirrusContractTable> totalQuary = mongoDb.CirrusContractTable.AsQueryable()
.Where(q => q.ToAddress == address);
if (filterAddress != null)
{
totalQuary = totalQuary.Where(q => q.FromAddress == filterAddress);
}
int total = totalQuary.Count();
IMongoQueryable <CirrusContractTable> cirrusContract = mongoDb.CirrusContractTable.AsQueryable()
.Where(q => q.ToAddress == address);
if (filterAddress != null)
{
cirrusContract = cirrusContract.Where(q => q.FromAddress == filterAddress);
}
int itemsToSkip = offset ?? (total < limit ? 0 : total - limit);
cirrusContract = cirrusContract
.OrderBy(b => b.BlockIndex)
.Skip(itemsToSkip)
.Take(limit);
var res = cirrusContract.ToList();
IEnumerable <QueryContractCall> transactions = res.Select(item => new QueryContractCall
{
Success = item.Success,
MethodName = item.MethodName,
ToAddress = item.NewContractAddress,
GasUsed = item.GasUsed,
GasPrice = item.GasPrice,
Amount = item.Amount,
ContractBalance = item.ContractBalance,
FromAddress = item.FromAddress,
Error = item.Error,
BlockIndex = item.BlockIndex,
TransactionId = item.TransactionId
});
return(new QueryResult <QueryContractCall>
{
Items = transactions,
Offset = itemsToSkip,
Limit = limit,
Total = total
});
}
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 IEnumerable <TEntity> GetFiltered(Expression <Func <TEntity, bool> > filter, params ISorting[] sortColumns)
{
if (filter == null)
{
throw new ArgumentException("Filter expression cannot be null", nameof(filter));
}
IMongoQueryable <TEntity> query = GetSet().Where(filter);
if (sortColumns != null && sortColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns);
}
return(query);
}
public Task <TEntity> GetFirstAsync(Expression <Func <TEntity, bool> > filter, params ISorting[] sortingColumns)
{
IMongoQueryable <TEntity> query = GetSet();
if (filter != null)
{
query = query.Where(filter);
}
if (sortingColumns != null && sortingColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortingColumns);
}
return(query.FirstOrDefaultAsync());
}
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));
}
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 IEnumerable <TEntity> GetPaged(Expression <Func <TEntity, bool> > filter, int pageIndex, int pageCount, params ISorting[] sortColumns)
{
IMongoQueryable <TEntity> query = GetSet();
if (filter != null)
{
query = query.Where(filter);
}
if (sortColumns != null && sortColumns.Length > 0)
{
query = (IOrderedMongoQueryable <TEntity>)query.OrderBy(sortColumns);
}
if (pageCount > 0)
{
int skip = (pageIndex - 1) * pageCount;
return(query.Skip(skip).Take(pageCount));
}
return(query);
}
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));
}
}
public override IOrderedMongoQueryable <Termo> OrdernarPadrao(IMongoQueryable <Termo> query)
{
return(query.OrderBy(c => c.Nome));
}
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);
}
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 IOrderedMongoQueryable <Telemetry> SortSource(IMongoQueryable <Telemetry> source)
{
return(source.OrderBy(e => e.OccuredAt));
}
public override IMongoQueryable <LogDocument> Sort(IMongoQueryable <LogDocument> logs) => logs.OrderBy(l => l.Date);
