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; }