public static bool HasAnyJoins <TEntity>(this QueryClause <TEntity> query)
where TEntity : IQueryableEntity
{
query.GuardAgainstNull(nameof(query));
return(query.JoinedEntities
.Any(je => je.Join.Exists()));
}
public static QueryClause <TEntity> WithSearchOptions <TEntity>(this QueryClause <TEntity> query,
SearchOptions options)
where TEntity : IQueryableEntity
{
query.GuardAgainstNull(nameof(query));
options.GuardAgainstNull(nameof(options));
if (options.Offset > ResultOptions.DefaultOffset)
{
query.Skip(options.Offset);
}
if (options.Limit > ResultOptions.DefaultLimit)
{
query.Take(options.Limit);
}
if (options.Sort.By.HasValue())
{
var propertyName = options.Sort.By;
var propertyExpression = GetPropertyExpression <TEntity>(propertyName);
if (propertyExpression != null)
{
query.OrderBy(propertyExpression, options.Sort.Direction == SortDirection.Ascending
? OrderDirection.Ascending
: OrderDirection.Descending);
}
}
if (options.Filter.Fields.Any())
{
foreach (var field in options.Filter.Fields)
{
var propertyExpression = GetPropertyExpression <TEntity>(field);
if (propertyExpression != null)
{
query.Select(propertyExpression);
}
}
}
return(query);
}
public static List <QueryEntity> FetchAllIntoMemory <TQueryableEntity>(this QueryClause <TQueryableEntity> query,
IRepository repository,
RepositoryEntityMetadata metadata,
Func <Dictionary <string, IReadOnlyDictionary <string, object> > > getPrimaryEntities,
Func <QueriedEntity, Dictionary <string, IReadOnlyDictionary <string, object> > > getJoinedEntities)
where TQueryableEntity : IQueryableEntity
{
repository.GuardAgainstNull(nameof(repository));
query.GuardAgainstNull(nameof(query));
metadata.GuardAgainstNull(nameof(metadata));
getPrimaryEntities.GuardAgainstNull(nameof(getPrimaryEntities));
getJoinedEntities.GuardAgainstNull(nameof(getJoinedEntities));
var take = query.GetDefaultTake(repository);
if (take == 0)
{
return(new List <QueryEntity>());
}
var primaryEntities = getPrimaryEntities();
if (!primaryEntities.HasAny())
{
return(new List <QueryEntity>());
}
var joinedContainers = query.JoinedEntities
.Where(je => je.Join.Exists())
.ToDictionary(je => je.EntityName, je => new
{
Collection = getJoinedEntities(je),
JoinedEntity = je
});
List <KeyValuePair <string, IReadOnlyDictionary <string, object> > > joinedEntities = null;
if (!joinedContainers.Any())
{
joinedEntities = primaryEntities
.Select(pe => new KeyValuePair <string, IReadOnlyDictionary <string, object> >(pe.Key, pe.Value))
.ToList();
}
else
{
foreach (var joinedContainer in joinedContainers)
{
var joinedEntity = joinedContainer.Value.JoinedEntity;
var join = joinedEntity.Join;
var rightEntities = joinedContainer.Value.Collection
.ToDictionary(e => e.Key, e => e.Value);
joinedEntities = join
.JoinResults(primaryEntities, rightEntities,
joinedEntity.Selects.ProjectSelectedJoinedProperties());
}
}
var results = joinedEntities?.AsQueryable();
var orderBy = query.ToDynamicLinqOrderByClause();
var skip = query.GetDefaultSkip();
if (query.Wheres.Any())
{
var whereBy = query.Wheres.ToDynamicLinqWhereClause();
results = results
.Where(whereBy);
}
return(results
.OrderBy(orderBy)
.Skip(skip)
.Take(take)
.Select(sel => new KeyValuePair <string, IReadOnlyDictionary <string, object> >(sel.Key, sel.Value))
.CherryPickSelectedProperties(query)
.Select(ped => QueryEntity.FromProperties(ped.Value, metadata))
.ToList());
}
