public virtual SpecificationDbQuery <TEntity> SpecificationQuery(
IncludeSpecification <TEntity> includeSpecification,
FilterSpecification <TEntity> filterSpecification,
OrderBySpecification <TEntity> orderBySpecification,
int?skip = null,
int?take = null,
bool getFullGraph = false)
{
var specification = new SpecificationDbQuery <TEntity>(context).Include(includeSpecification).Where(filterSpecification).OrderBy(orderBySpecification);
if (skip.HasValue)
{
specification = specification.Skip(skip.Value);
}
if (take.HasValue)
{
specification = specification.Take(take.Value);
}
if (getFullGraph)
{
specification = specification.FullGraph();
}
return(specification);
}
public virtual PagedList <TDto> Search(
IncludeSpecification <TDto> includeSpecification,
FilterSpecification <TDto> filterSpecification,
OrderBySpecification <TDto> orderBySpecification,
int?pageNo = null,
int?pageSize = null,
bool getFullGraph = false)
{
var filterConverted = filterSpecification.Map <TEntity>(Mapper);
if (!OrderByMapper.ValidOrderByFor <TDto, TEntity>(orderBySpecification.OrderByString))
{
throw new BadRequestException(Messages.OrderByInvalid);
}
//Ideally OrderByMapper could also convert Expressions but it only handles strings.
var orderByConverted = string.IsNullOrEmpty(orderBySpecification.OrderByString) ? orderBySpecification.Map <TEntity>(Mapper) : orderBySpecification.Map <TEntity>(OrderByMapper);
var includesConverted = includeSpecification.Map <TEntity>(Mapper);
int?skip = null;
if (pageNo.HasValue && pageSize.HasValue)
{
skip = (pageNo.Value - 1) * pageSize.Value;
}
var entityList = Repository.SpecificationQuery(includesConverted, filterConverted, orderByConverted, skip, pageSize, GetFullGraph || getFullGraph).ToCountList();
var entities = entityList.ToList();
var dtoList = new PagedList <TDto>(entities.Select(Mapper.Map <TEntity, TDto>).ToList(), entityList.TotalCount, pageNo ?? 1, pageSize ?? entityList.TotalCount);
return(dtoList);
}
protected override void IncludeNavigations(
IncludeSpecification includeSpecification,
Type resultType,
LambdaExpression accessorLambda,
bool querySourceRequiresTracking)
{
throw new NotImplementedException("MyProvider does not support .Include()");
}
protected override void IncludeNavigations(IncludeSpecification includeSpecification, Type resultType, Expression accessorExpression, bool querySourceRequiresTracking)
{
SelectorIncludeInjectingExpressionVisitor includeExpressionVisitor
= new SelectorIncludeInjectingExpressionVisitor(
includeSpecification,
accessorExpression,
querySourceRequiresTracking);
Expression = includeExpressionVisitor.Visit(Expression);
}
public SelectorIncludeInjectingExpressionVisitor(
IncludeSpecification includeSpecification,
IMaterializerFactory materializerFactory,
Expression accessorExpression,
bool querySourceRequiresTracking)
{
_includeSpecification = includeSpecification;
_materializerFactory = materializerFactory;
_accessorExpression = accessorExpression;
_querySourceRequiresTracking = querySourceRequiresTracking;
}
public InMemoryIncludeExpressionVisitor(
[NotNull] IMaterializerFactory materializerFactory,
[NotNull] ILinqOperatorProvider linqOperatorProvider,
[NotNull] IncludeSpecification includeSpecification,
[NotNull] Expression accessorExpression,
bool querySourceRequiresTracking)
{
_materializerFactory = materializerFactory;
_linqOperatorProvider = linqOperatorProvider;
_includeSpecification = includeSpecification;
_accessorExpression = accessorExpression;
_querySourceRequiresTracking = querySourceRequiresTracking;
}
public SelectorIncludeInjectingExpressionVisitor(
[NotNull] IncludeSpecification includeSpecification,
[NotNull] IMaterializerFactory materializerFactory,
[NotNull] QueryCompilationContext queryCompilationContext,
[NotNull] Expression accessorExpression,
bool querySourceRequiresTracking)
{
_includeSpecification = includeSpecification;
_materializerFactory = materializerFactory;
_queryCompilationContext = queryCompilationContext;
_accessorExpression = accessorExpression;
_querySourceRequiresTracking = querySourceRequiresTracking;
}
protected override void IncludeNavigations(
IncludeSpecification includeSpecification,
Type resultType,
LambdaExpression accessorLambda,
bool querySourceRequiresTracking)
{
Check.NotNull(includeSpecification, nameof(includeSpecification));
Check.NotNull(resultType, nameof(resultType));
Check.NotNull(accessorLambda, nameof(accessorLambda));
var keyComparerParameter = Expression.Parameter(typeof(IIncludeKeyComparer), "keyComparer");
MethodInfo includeMethod;
var resultItemTypeInfo = resultType.GetTypeInfo();
if (resultItemTypeInfo.IsGenericType &&
(resultItemTypeInfo.GetGenericTypeDefinition() == typeof(IGrouping <,>) ||
resultItemTypeInfo.GetGenericTypeDefinition() == typeof(IAsyncGrouping <,>)))
{
includeMethod
= _includeGroupedMethodInfo.MakeGenericMethod(
resultType.GenericTypeArguments[0],
resultType.GenericTypeArguments[1]);
}
else
{
includeMethod = _includeMethodInfo.MakeGenericMethod(resultType);
}
Expression
= Expression.Call(
includeMethod,
QueryContextParameter,
Expression,
Expression.Constant(includeSpecification),
accessorLambda,
Expression.Constant(
includeSpecification.NavigationPath
.Select(n =>
{
var targetType = n.GetTargetType();
var materializer = _materializerFactory.CreateMaterializer(targetType);
return(new RelatedEntitiesLoader(targetType, materializer.Compile()));
})
.ToArray()),
Expression.Constant(querySourceRequiresTracking));
}
protected override void IncludeNavigations(
IncludeSpecification includeSpecification,
Type resultType,
LambdaExpression accessorLambda,
bool querySourceRequiresTracking)
{
Check.NotNull(includeSpecification, nameof(includeSpecification));
Check.NotNull(resultType, nameof(resultType));
Check.NotNull(accessorLambda, nameof(accessorLambda));
var primaryKeyParameter = Expression.Parameter(typeof(EntityKey));
var relatedKeyFactoryParameter = Expression.Parameter(typeof(Func <ValueBuffer, EntityKey>));
var navigationPath = includeSpecification.NavigationPath;
Expression
= Expression.Call(
_includeMethodInfo.MakeGenericMethod(resultType),
QueryContextParameter,
Expression,
Expression.Constant(navigationPath),
accessorLambda,
Expression.NewArrayInit(
typeof(RelatedEntitiesLoader),
navigationPath.Select(
n =>
{
var targetType = n.GetTargetType();
var materializer
= new MaterializerFactory(
QueryCompilationContext
.EntityMaterializerSource)
.CreateMaterializer(targetType);
return(Expression.Lambda <RelatedEntitiesLoader>(
Expression.Call(
_getRelatedValueBuffersMethodInfo,
QueryContextParameter,
Expression.Constant(targetType),
primaryKeyParameter,
relatedKeyFactoryParameter,
materializer),
primaryKeyParameter,
relatedKeyFactoryParameter));
})),
Expression.Constant(querySourceRequiresTracking));
}
private static IEnumerable<IGrouping<TKey, TOut>> IncludeGrouped<TKey, TOut>(
QueryContext queryContext,
IEnumerable<IGrouping<TKey, TOut>> groupings,
IncludeSpecification includeSpecification,
Func<TOut, object> accessorLambda,
IReadOnlyList<RelatedEntitiesLoader> relatedEntitiesLoaders,
bool querySourceRequiresTracking)
{
return groupings.Select(g =>
new IncludeGrouping<TKey, TOut>(
queryContext,
g,
includeSpecification.NavigationPath,
accessorLambda,
relatedEntitiesLoaders,
querySourceRequiresTracking));
}
private static TEntity IncludeEntity <TEntity>(
QueryContext queryContext,
TEntity source,
IncludeSpecification includeSpecification,
IReadOnlyList <IRelatedEntitiesLoader> relatedEntitiesLoaders,
bool querySourceRequiresTracking)
{
queryContext.QueryBuffer
.Include(
queryContext,
source,
includeSpecification.NavigationPath,
relatedEntitiesLoaders,
querySourceRequiresTracking);
return(source);
}
public virtual async Task <PagedList <TDto> > SearchAsync(
IncludeSpecification <TDto> includeSpecification,
FilterSpecification <TDto> filterSpecification,
OrderBySpecification <TDto> orderBySpecification,
int?pageNo = null,
int?pageSize = null,
bool getFullGraph = false,
CancellationToken cancellationToken = default(CancellationToken))
{
await AuthorizeResourceOperationAsync(ResourceCollectionsCore.CRUD.Operations.Read, ResourceCollectionsCore.CRUD.Operations.ReadOwner);
var filterConverted = filterSpecification.Map <TEntity>(Mapper);
if (!OrderByMapper.ValidOrderByFor <TDto, TEntity>(orderBySpecification.OrderByString))
{
throw new BadRequestError(Messages.OrderByInvalid);
}
//Ideally OrderByMapper could also convert Expressions but it only handles strings.
var orderByConverted = string.IsNullOrEmpty(orderBySpecification.OrderByString) ? orderBySpecification.Map <TEntity>(Mapper) : orderBySpecification.Map <TEntity>(OrderByMapper);
var includesConverted = includeSpecification.Map <TEntity>(Mapper);
int?skip = null;
if (pageNo.HasValue && pageSize.HasValue)
{
skip = (pageNo.Value - 1) * pageSize.Value;
}
var entityList = await Repository.SpecificationQuery(includesConverted, filterConverted, orderByConverted, skip, pageSize, GetFullGraph || getFullGraph).ToCountListAsync(cancellationToken).ConfigureAwait(false);
var entities = entityList.ToList();
foreach (var entity in entities)
{
await AuthorizeResourceOperationAsync(entity, ResourceCollectionsCore.CRUD.Operations.Read, ResourceCollectionsCore.CRUD.Operations.ReadOwner);
}
var dtoList = new PagedList <TDto>(entities.Select(Mapper.Map <TEntity, TDto>).ToList(), entityList.TotalCount, pageNo ?? 1, pageSize ?? entityList.TotalCount);
return(dtoList);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected override void IncludeNavigations(
IncludeSpecification includeSpecification,
Type resultType,
Expression accessorExpression,
bool querySourceRequiresTracking)
{
Check.NotNull(includeSpecification, nameof(includeSpecification));
Check.NotNull(resultType, nameof(resultType));
var includeExpressionVisitor
= new InMemoryIncludeExpressionVisitor(
_materializerFactory,
LinqOperatorProvider,
includeSpecification,
accessorExpression,
querySourceRequiresTracking);
Expression = includeExpressionVisitor.Visit(Expression);
}
private static TEntity IncludeCollection <TEntity>(
QueryContext queryContext,
TEntity source,
IncludeSpecification includeSpecification,
IReadOnlyList <IRelatedEntitiesLoader> relatedEntitiesLoaders,
bool querySourceRequiresTracking)
{
foreach (var entity in (IEnumerable)source)
{
queryContext.QueryBuffer
.Include(
queryContext,
entity,
includeSpecification.NavigationPath,
relatedEntitiesLoaders,
querySourceRequiresTracking);
}
return(source);
}
private static IEnumerable<TResult> Include<TResult>(
QueryContext queryContext,
IEnumerable<TResult> source,
IncludeSpecification includeSpecification,
Func<TResult, object> accessorLambda,
IReadOnlyList<IRelatedEntitiesLoader> relatedEntitiesLoaders,
bool querySourceRequiresTracking)
{
foreach (var result in source)
{
var entityOrCollection = accessorLambda.Invoke(result);
if (includeSpecification.IsEnumerableTarget)
{
foreach (var entity in (IEnumerable)entityOrCollection)
{
queryContext.QueryBuffer
.Include(
queryContext,
entity,
includeSpecification.NavigationPath,
relatedEntitiesLoaders,
querySourceRequiresTracking);
}
}
else
{
queryContext.QueryBuffer
.Include(
queryContext,
entityOrCollection,
includeSpecification.NavigationPath,
relatedEntitiesLoaders,
querySourceRequiresTracking);
}
yield return result;
}
}
private static IEnumerable <TResult> Include <TResult>(
QueryContext queryContext,
IEnumerable <TResult> source,
IncludeSpecification includeSpecification,
IReadOnlyList <IRelatedEntitiesLoader> relatedEntitiesLoaders,
bool querySourceRequiresTracking)
{
foreach (var result in source)
{
if (includeSpecification.IsEnumerableTarget)
{
foreach (var entity in (IEnumerable)result)
{
queryContext.QueryBuffer
.Include(
queryContext,
entity,
includeSpecification.NavigationPath,
relatedEntitiesLoaders,
querySourceRequiresTracking);
}
}
else
{
queryContext.QueryBuffer
.Include(
queryContext,
result,
includeSpecification.NavigationPath,
relatedEntitiesLoaders,
querySourceRequiresTracking);
}
yield return(result);
}
}
public static IEnumerable <T> LoadRelatedData <T>(IEnumerable <T> values, IncludeSpecification includeSpecification)
{
return(LoadData(values.ToList(), includeSpecification.NavigationPath).Cast <T>());
}
public static IEnumerable <T> LoadRelatedData <T>(IEnumerable <T> values, IncludeSpecification includeSpecification)
{
foreach (INavigation nav in includeSpecification.NavigationPath)
{
IEntityType t;
IClrPropertyGetter[] objProps;
IClrPropertyGetter[] refObjProps;
if (nav.IsDependentToPrincipal())
{
t = nav.ForeignKey.PrincipalEntityType;
objProps = nav.ForeignKey.Properties.Select(x => x.GetGetter()).ToArray();
refObjProps = nav.ForeignKey.PrincipalKey.Properties.Select(x => x.GetGetter()).ToArray();
}
else
{
t = nav.ForeignKey.DeclaringEntityType;
objProps = nav.ForeignKey.PrincipalKey.Properties.Select(x => x.GetGetter()).ToArray();
refObjProps = nav.ForeignKey.Properties.Select(x => x.GetGetter()).ToArray();
}
if (objProps.Count() != refObjProps.Count())
{
return(values);
}
IClrPropertySetter valueSetter = nav.GetSetter();
if (nav.IsCollection())
{
foreach (T obj in values)
{
object[] objValues = objProps.Select(x => x.GetClrValue(obj)).ToArray();
valueSetter.SetClrValue(obj, cache.Filter(t.ClrType, x =>
{
int result = 0;
object[] refValues = refObjProps.Select(y => y.GetClrValue(x)).ToArray();
if (refValues.Count() == objValues.Count())
{
for (int i = 0; i < refValues.Count(); i++)
{
if (Equals(objValues[i], refValues[i]))
{
result++;
}
}
}
return(result == refValues.Count());
}));
}
}
else
{
foreach (T obj in values)
{
object[] objValues = objProps.Select(x => x.GetClrValue(obj)).ToArray();
IList matching = cache.Filter(t.ClrType, x =>
{
int result = 0;
object[] refValues = refObjProps.Select(y => y.GetClrValue(x)).ToArray();
if (refValues.Count() == objValues.Count())
{
for (int i = 0; i < refValues.Count(); i++)
{
if (Equals(objValues[i], refValues[i]))
{
result++;
}
}
}
return(result == refValues.Count());
});
if (matching.Count > 0)
{
valueSetter.SetClrValue(obj, matching[0]);
}
}
}
}
return(values);
}
public SelectorIncludeInjectingExpressionVisitor(IncludeSpecification _includeSpecification, Expression _accessorExpression, bool _querySourceRequiresTracking)
{
includeSpecification = _includeSpecification;
accessorExpression = _accessorExpression;
querySourceRequiresTracking = _querySourceRequiresTracking;
}
