private static Expression <Func <T, bool> > GetGroupExpression <T>(DataFilterGroup paramGroup, DataFilter <T> filter)
where T : BaseModel
{
bool startParam = !(paramGroup.Type == FilterGroupType.Or &&
(paramGroup.ParamGroupList.Any() || paramGroup.ParamList.Any()));
Expression <Func <T, bool> > expressions = PredicateBuilder.New <T>(startParam);
paramGroup.ParamList.ForEach(param =>
{
Expression <Func <T, bool> > expression;
DataFilterQueryExpression <T> customExpression = filter.CustomQueryExpressionList.FirstOrDefault(x => x.Field == param.Field);
if (customExpression != null)
{
expression = customExpression.Expression;
}
else
{
expression = FilterExpressionProvider.CreateExpression <T>(param);
}
expressions = IncludeExpression(expressions, expression, paramGroup.Type);
});
paramGroup.ParamGroupList.ForEach(group =>
{
Expression <Func <T, bool> > expression = GetGroupExpression <T>(group, filter);
expressions = IncludeExpression(expressions, expression, paramGroup.Type);
});
return(expressions);
}
private static IQueryable <T> GetFilteredQuery <T>(IQueryable <T> queryable, DataFilterGroup rootParamGroup, DataFilter <T> filter)
where T : BaseModel
{
Expression <Func <T, bool> > predicate = GetGroupExpression <T>(rootParamGroup, filter);
return(queryable.AsExpandable().Where(predicate));
}
public static DataFilter <T> ListByFilter <T>(
this BaseDataAccess <T> dataAccess, DataFilter <T> filter)
where T : BaseModel
{
DataFilterGroup rootParamGroup = filter.ParamGroup;
IQueryable <T> filteredQuery = GetFilteredQuery(dataAccess.GetBaseQueryable(), rootParamGroup, filter);
if (filter.CustomQueryExpression != null)
{
filteredQuery = filteredQuery.Where(filter.CustomQueryExpression);
}
filteredQuery = GetOrderedQuery(filteredQuery, filter);
if (filter.Paginated)
{
int skipSize = (filter.Page - 1) * filter.PageSize;
filter.Data = filteredQuery.Skip(skipSize).Take(filter.PageSize).ToList();
}
else
{
filter.Data = filteredQuery.ToList();
}
filter.TotalCount = filteredQuery.Count();
return(filter);
}
public DataFilter <TBaseModel> GetDataFilterBase <TBaseModel>(
Dictionary <string, string> fieldMap = null, Dictionary <string, string> fieldMapOr = null)
where TBaseModel : BaseModel
{
DataFilter <TBaseModel> filter = new DataFilter <TBaseModel>();
filter.PageSize = pageSize;
filter.Page = page;
filter.OrderByDirection = orderByDirection != null && orderByDirection.ToLower().Equals("desc") ? "DESC" : "ASC";
if (fieldMap != null)
{
fields.ForEach(field =>
{
if (fieldMap.ContainsKey(field.field))
{
filter.AddParam(fieldMap[field.field], field.type, field.argument);
}
});
}
if (fieldMapOr != null)
{
fieldMapOr.ToList().ForEach(map =>
{
DataFilterGroup group = new DataFilterGroup(FilterGroupType.Or);
fields.Where(x => x.field == map.Key).ToList().ForEach(field =>
{
group.AddParam(map.Value, field.type, field.argument);
});
filter.AddGroup(group);
});
}
return(filter);
}
public void AddGroup(DataFilterGroup group)
{
ParamGroupList.Add(group);
}
public DataFilter <TModel> AddGroup(DataFilterGroup group)
{
ParamGroup.AddGroup(group);
return(this);
}
