/// <summary>
/// Get an IQueryable of parents matching a supplied IQueryable of children for this relationship.
/// </summary>
/// <typeparam name="TParent">The type of the parent IEntity</typeparam>
/// <param name="children">An IQueryable of children</param>
/// <param name="options">An optional AggregateOptions object</param>
public IMongoQueryable <TParent> ParentsQueryable <TParent>(IMongoQueryable <TChild> children, AggregateOptions options = null) where TParent : IEntity
{
if (typeof(TParent) == typeof(TChild))
{
throw new InvalidOperationException("Both parent and child types cannot be the same");
}
if (isInverse)
{
return(children
.Join(
JoinQueryable(options),
c => c.ID,
j => j.ParentID,
(_, j) => j)
.Join(
DB.Collection <TParent>(db),
j => j.ChildID,
p => p.ID,
(_, p) => p)
.Distinct());
}
else
{
return(children
.Join(
JoinQueryable(options),
c => c.ID,
j => j.ChildID,
(_, j) => j)
.Join(
DB.Collection <TParent>(db),
j => j.ParentID,
p => p.ID,
(_, p) => p)
.Distinct());
}
}
public static PaginatedItems <T> Paginate <T>(this IMongoQueryable <T> source, int rowsPerPage = 0, int pageNumber = 1)
{
if (rowsPerPage == 0)
{
return(new PaginatedItems <T>
{
PageCount = 1,
TotalItemsCount = source.Count(),
Items = source
});
}
var skip = Math.Max(0, pageNumber - 1) * rowsPerPage;
var totalCount = source.Count();
var pageCount = (int)Math.Ceiling((double)totalCount / rowsPerPage);
return(new PaginatedItems <T>
{
PageCount = pageCount,
TotalItemsCount = totalCount,
Items = source.Skip(skip).Take(rowsPerPage)
});
}
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, int page = 1, int resultsPerPage = 10)
{
if (page <= 10)
{
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);
var data = await collection.Limit(page, resultsPerPage).ToListAsync();
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
public static async Task <PagedResult <T> > PaginateAsync <T, TKey>(this IMongoQueryable <T> collection, int resultsPerPage = 10)
where T : IIdentifiable <TKey>
{
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var result = await collection
.Take(resultsPerPage + 1)
.ToListAsync();
var hasNextData = result.Count > resultsPerPage;
if (result.Count > 1 && hasNextData)
{
result.RemoveAt(result.Count - 1);
}
var last = result.LastOrDefault();
return(PagedResult <T> .Create(result, result.Count, last?.Id.ToString(), hasNextData));
}
public MJoin(IMongoQueryable <T1> source1, IMongoQueryable <T2> source2, string source1OnField, string source2OnField, QueryDocument filter, List <KeyValuePair <string, string> > source1Projection, List <KeyValuePair <string, string> > source2Projection)
{
// PropertyDescriptor fld1 = TypeDescriptor.GetProperties(typeof(T1)).Find(source1OnField, true);
//PropertyDescriptor fld2 = TypeDescriptor.GetProperties(typeof(T2)).Find(source2OnField, true);
//var fld1 = typeof(T1).GetProperty(source1OnField);
//var fld2 = typeof(T2).GetProperty(source2OnField);
PropertyDescriptor fld1 = TypeDescriptor.GetProperties(typeof(Student)).Find("ClassId", true);
DynamicProperty dfld1 = new DynamicProperty("ClassId", fld1.PropertyType);
PropertyDescriptor fld2 = TypeDescriptor.GetProperties(typeof(ClassRoom)).Find("Id", true);
DynamicProperty dfld2 = new DynamicProperty("Id", fld2.PropertyType);
var zz = from s1Item in source1 join s2Item in source2 on dfld1 equals dfld2 into grp select s1Item;
var cc = zz.Count();
BlockProvider = zz;
}
public async Task <StaticPagedList <T> > PaginationAsync <TKey>(int pageIndex, int pageSize, Expression <Func <T, TKey> > orderBy, bool isOrderByAsc = true, Expression <Func <T, bool> > where = null)
{
long num;
long num1 = (long)0;
IMongoQueryable <T> mongoQueryable = IMongoCollectionExtensions.AsQueryable <T>(this.Collection);
num = (where != null ? await this.CountAsync(where) : await this.CountAsync());
num1 = num;
if (where != null)
{
mongoQueryable = MongoQueryable.Where <T>(mongoQueryable, where);
}
if (isOrderByAsc)
{
mongoQueryable = MongoQueryable.Take <T>(MongoQueryable.Skip <T>(MongoQueryable.OrderBy <T, TKey>(mongoQueryable, orderBy), (pageIndex - 1) * pageSize), pageSize);
}
else
{
mongoQueryable = MongoQueryable.Take <T>(MongoQueryable.Skip <T>(MongoQueryable.OrderByDescending <T, TKey>(mongoQueryable, orderBy), (pageIndex - 1) * pageSize), pageSize);
}
StaticPagedList <T> staticPagedList = new StaticPagedList <T>(mongoQueryable.ToList <T>(), pageIndex, pageSize, (int)num1);
return(staticPagedList);
}
public override void GetResult(IMongoQueryable <Order> collection)
{
var timer = Stopwatch.StartNew();
var query = collection.GroupBy(x => x.Service.Name)
.Select(x => new
{
Service = x.Key,
OrderCount = x.Count()
}
)
.OrderByDescending(x => x.OrderCount)
.ToList();
timer.Stop();
foreach (var item in query)
{
Console.WriteLine($"Service: {item.Service} OrderCount: {item.OrderCount}");
}
Console.WriteLine($"Execute time: {timer.ElapsedMilliseconds}");
Thread.Sleep(5000);
}
///<inheritdoc cref="MongoPaginationService.Paginate{T}(IMongoQueryable{T}, int, int, Func{IMongoQueryable{T}, int})"/>
public static IPaginationResult <IMongoQueryable <T> > Paginate <T>(this IMongoQueryable <T> query, int page, int pageSize, Func <IMongoQueryable <T>, int> countFunction)
{
var entriesCount = countFunction(query);
return(CreateResult(page, pageSize, query, entriesCount));
}
public MongoCollectionWrapper(IMongoCollection <TKey> collection, IMongoQueryable <TKey> queryable)
{
Collection = collection ?? throw new ArgumentNullException(nameof(collection));
Queryable = queryable ?? throw new ArgumentNullException(nameof(queryable));
}
public static IAsyncQueryable <T> AsAsync <T>(this IMongoQueryable <T> queryable)
{
return(new MongoAsyncQueryable <T>(queryable));
}
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);
}
protected virtual IMongoQueryable <DocumentWithoutContent> ApplyFilterForGetAll(
IMongoQueryable <Document> query,
Guid?projectId,
string name,
string version,
string languageCode,
string fileName,
string format,
DateTime?creationTimeMin,
DateTime?creationTimeMax,
DateTime?lastUpdatedTimeMin,
DateTime?lastUpdatedTimeMax,
DateTime?lastSignificantUpdateTimeMin,
DateTime?lastSignificantUpdateTimeMax,
DateTime?lastCachedTimeMin,
DateTime?lastCachedTimeMax,
CancellationToken cancellationToken = default)
{
if (projectId.HasValue)
{
query = query.Where(d => d.ProjectId == projectId.Value);
}
if (name != null)
{
query = query.Where(d => d.Name != null && d.Name.Contains(name));
}
if (version != null)
{
query = query.Where(d => d.Version != null && d.Version == version);
}
if (languageCode != null)
{
query = query.Where(d => d.LanguageCode != null && d.LanguageCode == languageCode);
}
if (fileName != null)
{
query = query.Where(d => d.FileName != null && d.FileName.Contains(fileName));
}
if (creationTimeMin.HasValue)
{
query = query.Where(d => d.CreationTime.Date >= creationTimeMin.Value.Date);
}
if (creationTimeMax.HasValue)
{
query = query.Where(d => d.CreationTime.Date <= creationTimeMax.Value.Date);
}
if (lastUpdatedTimeMin.HasValue)
{
query = query.Where(d => d.LastUpdatedTime.Date >= lastUpdatedTimeMin.Value.Date);
}
if (lastUpdatedTimeMax.HasValue)
{
query = query.Where(d => d.LastUpdatedTime.Date <= lastUpdatedTimeMax.Value.Date);
}
if (lastSignificantUpdateTimeMin.HasValue)
{
query = query.Where(d => d.LastSignificantUpdateTime != null && d.LastSignificantUpdateTime.Value.Date >= lastSignificantUpdateTimeMin.Value.Date);
}
if (lastSignificantUpdateTimeMax.HasValue)
{
query = query.Where(d => d.LastSignificantUpdateTime != null && d.LastSignificantUpdateTime.Value.Date <= lastSignificantUpdateTimeMax.Value.Date);
}
if (lastCachedTimeMin.HasValue)
{
query = query.Where(d => d.LastCachedTime.Date >= lastCachedTimeMin.Value.Date);
}
if (lastCachedTimeMax.HasValue)
{
query = query.Where(d => d.LastCachedTime.Date <= lastCachedTimeMax.Value.Date);
}
return(query.Select(x => new DocumentWithoutContent
{
Id = x.Id,
ProjectId = x.ProjectId,
Name = x.Name,
Version = x.Version,
LanguageCode = x.LanguageCode,
FileName = x.FileName,
Format = x.Format,
CreationTime = x.CreationTime,
LastUpdatedTime = x.LastUpdatedTime,
LastSignificantUpdateTime = x.LastSignificantUpdateTime,
LastCachedTime = x.LastCachedTime
}));
}
private static IPaginationResult <IMongoQueryable <T> > CreateResult <T>(int page, int pageSize, IMongoQueryable <T> query, int entriesCount)
{
return(new PaginationResult <IMongoQueryable <T> >(page, pageSize, query.Skip((page - 1) * pageSize).Take(pageSize), entriesCount));
}
public static IOrderedMongoQueryable <T> Sort <T>(this IMongoQueryable <T> source, IMongoSorter <T> sorter)
{
return(sorter.SortSource(source));
}
public static IMongoQueryable <TResult> Filter <TSource, TResult>(this IMongoQueryable <TSource> source, IMongoFilter <TSource, TResult> filter)
{
return(filter.FilterSource(source));
}
public MongoFrameworkQueryProvider(IMongoDbConnection connection, IMongoQueryable <TOutput> underlyingQueryable)
{
Connection = connection;
UnderlyingQueryable = underlyingQueryable;
}
public MongoFrameworkQueryProvider(IMongoQueryable <TOutput> underlyingQueryable)
{
UnderlyingQueryable = underlyingQueryable;
}
///<inheritdoc cref="MongoPaginationService.PaginateAsync{T}(IMongoQueryable{T}, int, int)" />
public static async Task <IPaginationResult <IMongoQueryable <T> > > PaginateAsync <T>(this IMongoQueryable <T> query, int page, int pageSize)
{
var entriesCount = await query.CountAsync();
return(CreateResult(page, pageSize, query, entriesCount));
}
public static async Task <IPaginationResult <IMongoQueryable <T> > > PaginateAsync <T>(this IMongoQueryable <T> query, int page, int pageSize, Func <IMongoQueryable <T>, Task <int> > asyncCountFunction)
{
var entriesCount = await asyncCountFunction(query);
return(CreateResult(page, pageSize, query, entriesCount));
}
public static IMongoQueryable <T> Limit <T>(this IMongoQueryable <T> collection, PagedQueryBase query) => collection.Limit(query.Page, query.Results);
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, PagedQueryBase query) => await collection.PaginateAsync(query.Page, query.Results);
public static async Task <PagedResults <TEntity> > PaginateAsync <TEntity, TQuery>(this IMongoQueryable <TEntity> collection,
TQuery query) where TQuery : IPagedQuery
=> await collection.PaginateAsync <TEntity, TQuery>(query.Page, query.ResultsPerPage, query.OrderBy, query.SortOrder);
public Set(IMongoDatabase database)
{
this.collection = database.GetCollection <TEntity>(typeof(TEntity).Name);
this.internalQueryable = collection.AsQueryable();
}
private static async Task <PagedResults <TEntity> > PaginateAsync <TEntity, TQuery>(this IMongoQueryable <TEntity> collection,
int page, int resultsPerPage, string orderbyKey, SortOrder sortOrder)
{
page = page <= 0 ? 1 : page;
resultsPerPage = resultsPerPage <= 0 ? 10 : resultsPerPage;
var isEmpty = await collection.AnyAsync() == false;
if (isEmpty)
{
return(PagedResults <TEntity> .Empty);
}
var totalResults = await collection.CountAsync();
var totalPages = (int)(totalResults / resultsPerPage) + 1;
var skip = (page - 1) * resultsPerPage;
var data = await collection.OrderData(orderbyKey, sortOrder).Skip(skip).Take(resultsPerPage).ToListAsync();
return(PagedResults <TEntity> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
public static IMongoQueryable <T> ActiveRegisters <T>(this IMongoQueryable <T> queryable)
where T : Entity
{
return(queryable.Where(new ActiveRegisters <T>()));
}
internal static IQueryable <T> ToQueryable <T>(this IMongoQueryable <T> source)
{
return(source);
}
private static IMongoQueryable <UserModel> ApplyFilters(GetAllUsersQuery filters, IMongoQueryable <UserModel> query)
{
if (!string.IsNullOrWhiteSpace(filters.Gender))
{
query = query.Where(u => u.Gender == filters.Gender);
}
if (!string.IsNullOrWhiteSpace(filters.RoleName))
{
query = query.Where(u => u.RoleName == filters.RoleName);
}
if (!string.IsNullOrWhiteSpace(filters.Username))
{
query = query.Where(u => u.Username == filters.Username);
}
return(query);
}
public static IMongoQueryable <T> BaseFilter <T>(this IMongoQueryable <T> queryable) where T : BaseMongoCollection
{
queryable = queryable.Where(x => x.IsDeleted == null || x.IsDeleted == false);
return(queryable);
}
public static IAsyncQueryable AsAsync(this IMongoQueryable queryable)
{
return(new MongoAsyncQueryable(queryable));
}
public IList <StoredEvent> ObterEventos(string aggregateId)
{
IMongoQueryable <StoredEvent> query = _collection.AsQueryable();
return(query.Where(x => x.AggregatedId == aggregateId).OrderBy(x => x.DataOcorrencia).ToList());
}
