internal static async Task <ICollection <TModel> > GetAsync <TModel, TData>(this IStore store, IMapper mapper,
Expression <Func <TModel, bool> > filter = null,
Expression <Func <IQueryable <TModel>, IQueryable <TModel> > > queryFunc = null,
SelectExpandDefinition selectExpandDefinition = null)
where TModel : BaseModel
where TData : BaseData
{
return(mapper.ProjectTo
(
await store.GetQueryableAsync
(
Getfilter(),
GetQueryFunc()
),
null,
GetIncludes()
)
.UpdateQueryable(selectExpandDefinition.GetExpansions(typeof(TModel)), mapper)
.ToList());
Expression <Func <TModel, object> >[] GetIncludes()
=> selectExpandDefinition?.GetExpansionSelectors <TModel>().ToArray() ?? new Expression <Func <TModel, object> >[]
{
};
Func <IQueryable <TData>, IQueryable <TData> > GetQueryFunc()
=> mapper.MapExpression <Expression <Func <IQueryable <TData>, IQueryable <TData> > > >(queryFunc)?.Compile();
Expression <Func <TData, bool> > Getfilter()
=> mapper.MapExpression <Expression <Func <TData, bool> > >(filter);
}
public void ShouldNotThrowifExpandedMemberIsLiteral()
{
var expression = new SelectExpandDefinition
{
ExpandedItems = new List <SelectExpandItem>
{
new SelectExpandItem
{
MemberName = "Name"
}
}
}.GetExpansionSelectors <Department>();
}
public async Task <ICollection <TModel> > GetAsync <TModel, TData>(Expression <Func <TModel, bool> > filter = null, Expression <Func <IQueryable <TModel>, IQueryable <TModel> > > queryFunc = null, SelectExpandDefinition selectExpandDefinition = null)
where TModel : BaseModel
where TData : BaseData
{
return(await _store.GetAsync <TModel, TData>
(
_mapper,
filter,
queryFunc,
selectExpandDefinition
));
}
internal static async Task <TReturn> QueryAsync <TModel, TData, TModelReturn, TDataReturn, TReturn>(this IStore store, IMapper mapper,
Expression <Func <IQueryable <TModel>, TModelReturn> > queryFunc = null,
ICollection <Expression <Func <IQueryable <TModel>, IIncludableQueryable <TModel, object> > > > includeProperties = null,
SelectExpandDefinition selectExpandDefinition = null)
where TModel : BaseModel
where TData : BaseData
{
//Map the expressions
Expression <Func <IQueryable <TData>, TDataReturn> > mappedQueryFunc = mapper.MapExpression <Expression <Func <IQueryable <TData>, TDataReturn> > >(queryFunc);
ICollection <Expression <Func <IQueryable <TData>, IIncludableQueryable <TData, object> > > > includes = mapper.MapIncludesList <Expression <Func <IQueryable <TData>, IIncludableQueryable <TData, object> > > >(includeProperties);
//Call the store
TDataReturn result = await store.QueryAsync(mappedQueryFunc?.Compile(),
includes?.Select(i => i.Compile()).ToList());
if (typeof(TReturn) == typeof(TDataReturn))
{
return((TReturn)(object)result);
}
if (typeof(TReturn).IsIQueryable() && typeof(TDataReturn).IsIQueryable())
{
return(GetProjection(typeof(TReturn).GetUnderlyingElementType()));
}
return(mapper.Map <TDataReturn, TReturn>(result));
TReturn GetProjection(Type elementType)
=> (TReturn)mapper.ProjectTo
(
(IQueryable)result,
elementType,
selectExpandDefinition
)
.UpdateQueryable(elementType, selectExpandDefinition.GetExpansions(elementType), mapper);
}
private static Expression <Func <TModel, object> >[] GetIncludes <TModel>(SelectExpandDefinition selectExpandDefinition) where TModel : class
=> selectExpandDefinition.GetExpansionSelectors <TModel>().ToArray() ?? new Expression <Func <TModel, object> >[]
{
};
public static async Task <TModelReturn> QueryAsync <TModel, TData, TModelReturn>(this IStore store, IMapper mapper,
Expression <Func <IQueryable <TModel>, TModelReturn> > queryFunc,
ICollection <Expression <Func <IQueryable <TModel>, IIncludableQueryable <TModel, object> > > > includeProperties = null,
SelectExpandDefinition selectExpandDefinition = null)
where TModel : BaseModel
where TData : BaseData
=> await store.QueryAsync <TModel, TData, TModelReturn, TModelReturn, TModelReturn>(mapper, queryFunc, includeProperties, selectExpandDefinition);
private static IQueryable <TDest> _ProjectTo <TDest>(IMapper mapper, IQueryable source, SelectExpandDefinition selectExpandDefinition = null) where TDest : class => mapper.ProjectTo <TDest>(source, null, GetIncludes <TDest>(selectExpandDefinition));
public static IQueryable ProjectTo(this IMapper mapper, IQueryable source, Type destType, SelectExpandDefinition selectExpandDefinition = null)
=> (IQueryable)"_ProjectTo".GetGenericMethodInfo().MakeGenericMethod
(
destType
).Invoke(null, new object[] { mapper, source, selectExpandDefinition });
private async static Task <TModel> QueryEntity <TModel, TData>(IContextRepository repository,
IExpressionPart filterExpression, SelectExpandDefinition selectExpandDefinition = null)
where TModel : BaseModel
where TData : BaseData
=> (
await repository.GetAsync <TModel, TData>
(
(Expression <Func <TModel, bool> >)filterExpression.Build(),
null,
selectExpandDefinition
)
).FirstOrDefault();
private static Task <TModelReturn> Query <TModel, TData, TModelReturn, TDataReturn>(IContextRepository repository,
IExpressionPart queryExpression,
SelectExpandDefinition selectExpandDefinition = null)
where TModel : BaseModel
where TData : BaseData
=> repository.QueryAsync <TModel, TData, TModelReturn, TDataReturn>
(
(Expression <Func <IQueryable <TModel>, TModelReturn> >)queryExpression.Build(),
selectExpandDefinition
);
private static async Task <DataSourceResult> GetGroupedDataSourceResult <TModel, TData>(this DataSourceRequest request, IContextRepository contextRepository, bool getAggregates, SelectExpandDefinition selectExpandDefinition = null, ICollection <Expression <Func <IQueryable <TModel>, IIncludableQueryable <TModel, object> > > > includeProperties = null)
where TModel : BaseModel
where TData : BaseData
{
Expression <Func <IQueryable <TModel>, AggregateFunctionsGroup> > aggregatesExp = getAggregates ? QueryableExtensionsEx.CreateAggregatesExpression <TModel>(request) : null;
Expression <Func <IQueryable <TModel>, int> > totalExp = QueryableExtensionsEx.CreateTotalExpression <TModel>(request);
Expression <Func <IQueryable <TModel>, IEnumerable <AggregateFunctionsGroup> > > groupedExp = QueryableExtensionsEx.CreateGroupedDataExpression <TModel>(request);
return(new DataSourceResult
{
Data = await contextRepository.QueryAsync <TModel, TData, IEnumerable <AggregateFunctionsGroup>, IEnumerable <AggregateFunctionsGroup>, IEnumerable <AggregateFunctionsGroupModel <TModel> > >(groupedExp, selectExpandDefinition, includeProperties),
AggregateResults = getAggregates
? (await contextRepository.QueryAsync <TModel, TData, AggregateFunctionsGroup, AggregateFunctionsGroup, AggregateFunctionsGroupModel <TModel> >(aggregatesExp, selectExpandDefinition))
?.GetAggregateResults(request.Aggregates.SelectMany(a => a.Aggregates))
: null,
Total = await contextRepository.QueryAsync <TModel, TData, int, int>(totalExp, selectExpandDefinition)
});
}
/// <summary>
/// Get DataSource Result
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TData"></typeparam>
/// <param name="request"></param>
/// <param name="contextRepository"></param>
/// <param name="selectExpandDefinition"></param>
/// <param name="includeProperties"></param>
/// <returns></returns>
public static async Task <DataSourceResult> GetDataSourceResult <TModel, TData>(this DataSourceRequest request, IContextRepository contextRepository, SelectExpandDefinition selectExpandDefinition = null, ICollection <Expression <Func <IQueryable <TModel>, IIncludableQueryable <TModel, object> > > > includeProperties = null)
where TModel : BaseModel
where TData : BaseData
=> request.Groups != null && request.Groups.Count > 0
? await request.GetGroupedDataSourceResult <TModel, TData>(contextRepository, request.Aggregates != null && request.Aggregates.Count > 0, selectExpandDefinition, includeProperties)
: await request.GetUngroupedDataSourceResult <TModel, TData>(contextRepository, request.Aggregates != null && request.Aggregates.Count > 0, selectExpandDefinition);
public async Task <TReturn> QueryAsync <TModel, TData, TModelReturn, TDataReturn, TReturn>(Expression <Func <IQueryable <TModel>, TModelReturn> > queryFunc, SelectExpandDefinition selectExpandDefinition = null,
ICollection <Expression <Func <IQueryable <TModel>, IIncludableQueryable <TModel, object> > > > includeProperties = null)
where TModel : BaseModel
where TData : BaseData
{
return(await _store.QueryAsync <TModel, TData, TModelReturn, TDataReturn, TReturn>(
_mapper,
queryFunc,
includeProperties,
selectExpandDefinition));
}
