public BsGridPagerBuilder(BsPagerModel pager, BsPagerSettings settings, BsGridBaseRepositorySettings baseSettings)
{
this.renderer = new BsPagerBaseRenderer(this);
this.pager = pager;
this.settings = settings;
this.baseSettings = baseSettings;
}
/// <summary>
/// Creates GridModel based on Query, OrderQuery and MapQuery
/// </summary>
/// <param name="settings">Settings</param>
/// <param name="count">Total records</param>
/// <returns>Wrapper model</returns>
public BsGridModel <TRow> ToBsGridViewModel(BsGridBaseRepositorySettings settings, out int count)
{
var grid = ToBsGridViewModel(settings);
count = grid.Pager == null ? 0 : grid.Pager.TotalRecords;
return(grid);
}
public BsGridModel <TRow> ToBsGridViewModel <TValue>(BsGridBaseRepositorySettings settings, out int count, Expression <Func <TEntity, TValue> > uniqueIdSelector)
{
var grid = ToBsGridViewModel(settings, uniqueIdSelector);
count = grid.Pager == null ? 0 : grid.Pager.TotalRecords;
return(grid);
}
public long Count(BsGridBaseRepositorySettings settings)
{
this.settings = settings;
var basicQuery = this.Query();
var totalRecords = basicQuery.Select(x => false).Count();
return(totalRecords);
}
/// <summary>
/// Creates GridModel based on Query, OrderQuery and MapQuery
/// </summary>
/// <param name="page">Requested page number</param>
/// <param name="pageSize">Page size - number of records on requested page</param>
/// <returns></returns>
public BsGridModel <TRow> ToBsGridViewModel(int page, int pageSize)
{
var gridRepositorySettings = new BsGridBaseRepositorySettings
{
Page = page,
PageSize = pageSize
};
return(this.ToBsGridViewModel(gridRepositorySettings));
}
/// <summary>
/// Creates GridModel based on Query, OrderQuery and MapQuery
/// </summary>
/// <param name="settings">Requested settings</param>
/// <returns>Grid model</returns>
public virtual BsGridModel <TRow> ToBsGridViewModel <TValue>(BsGridBaseRepositorySettings settings, Expression <Func <TEntity, TValue> > uniqueIdSelector)
{
this.settings = settings;
var result = new BsGridModel <TRow>();
//creates basic query
var basicQuery = this.Query();
//add column order
result.BaseSettings.OrderColumns = settings.OrderColumns;
//add orderable columns
result.BaseSettings.OrderableColumns = settings.OrderableColumns;
this.orderedQueryBuilder = new OrderedQueryBuilder <TRow>(this.settings.OrderableColumns);
if (this.settings.GoTo.HasValue)
{
this.SetNoOffsetResult(result, basicQuery, settings, uniqueIdSelector);
}
else
{
this.SetResult(result, basicQuery, settings, uniqueIdSelector);
}
if (settings.DetailsAll || settings.DetailsCount > 0)
{
for (var i = 0; i < result.Pager.CurrentPageRecords; i++)
{
if (settings.HasDetails(i))
{
var row = result.Items.ElementAt(i);
this.FillDetails(row);
}
}
}
//sets base settings
result.BaseSettings = this.settings.GetBase();
return(result);
}
public BsGridPagerBuilder BaseSettings(BsGridBaseRepositorySettings baseSettings)
{
this.baseSettings = baseSettings;
return(this);
}
private void SetNoOffsetResult <TValue>(BsGridModel <TRow> result, IQueryable <TEntity> basicQuery, BsGridBaseRepositorySettings settings, Expression <Func <TEntity, TValue> > uniqueIdSelector)
{
var pager = new BsPagerModel
{
PageSize = settings.PageSize
};
IEnumerable <TRow> finalQuery = new List <TRow>();
pager.GoTo = settings.GoTo.Value;
if (settings.GoTo.Value == BsDirectionType.Last)
{
this.SwitchOrderType(result);
}
var orderedPagerQuery = this.OrderAndPaginate(basicQuery, uniqueIdSelector);
if (settings.GoTo.Value == BsDirectionType.Last)
{
this.SwitchOrderType(result);
}
var pagedQuery = this.OrderQuery(orderedPagerQuery.Take(pager.PageSize));
pagedQuery = this.OrderByUniqueId(pagedQuery, uniqueIdSelector);
finalQuery = this.MapQuery(pagedQuery);
result.Items = finalQuery.ToList();
result.Pager = pager;
result.Pager.CurrentPageRecords = result.Items.Count();
result.Pager.TotalRecords = result.Pager.CurrentPageRecords;
}
private void SetResult <TValue>(BsGridModel <TRow> result, IQueryable <TEntity> basicQuery, BsGridBaseRepositorySettings settings, Expression <Func <TEntity, TValue> > uniqueIdSelector)
{
var totalRecords = basicQuery.Select(x => false).Count();
if (totalRecords > 0)
{
var pager = new BsPagerModel(totalRecords, this.settings.PageSize, this.settings.Page);
IEnumerable <TRow> finalQuery = null;
if (totalRecords > 1)
{
var orderedQuery = this.OrderQuery(basicQuery);
if (settings.OrderableColumns.Any(c => c.Type == BsOrderType.Descending))
{
orderedQuery = orderedQuery.ThenByDescending(uniqueIdSelector);
}
else
{
orderedQuery = orderedQuery.ThenBy(uniqueIdSelector);
}
var pagedQuery = orderedQuery.Skip(pager.PageSize * (pager.CurrentPage - 1)).Take(pager.PageSize);
finalQuery = this.MapQuery(pagedQuery);
}
else
{
finalQuery = this.MapQuery(basicQuery);
}
// get items for current page
result.Items = finalQuery.ToList();
//sets pager
pager.CurrentPageRecords = result.Items.Count();
result.Pager = pager;
}
else
{
result.Items = new List <TRow>();
}
}
/// <summary>
/// Creates GridModel based on Query, OrderQuery and MapQuery
/// </summary>
/// <param name="settings">Requested settings</param>
/// <returns>Grid model</returns>
public virtual BsGridModel <TRow> ToBsGridViewModel(BsGridBaseRepositorySettings settings)
{
this.settings = settings;
var result = new BsGridModel <TRow>();
//creates basic query
var basicQuery = this.Query();
//performs count
var totalRecords = basicQuery.Select(x => false).Count();
//add column order
result.BaseSettings.OrderColumns = settings.OrderColumns;
//add orderable columns
result.BaseSettings.OrderableColumns = settings.OrderableColumns;
if (totalRecords > 0)
{
var pager = new BsPagerModel(totalRecords, this.settings.PageSize, this.settings.Page);
IEnumerable <TRow> finalQuery = null;
if (totalRecords > 1)
{
this.orderedQueryBuilder = new OrderedQueryBuilder <TRow>(this.settings.OrderableColumns);
var orderedQuery = this.OrderQuery(basicQuery);
var pagedQuery = orderedQuery.Skip(pager.PageSize * (pager.CurrentPage - 1)).Take(pager.PageSize);
finalQuery = this.MapQuery(pagedQuery);
}
else
{
finalQuery = this.MapQuery(basicQuery);
}
// get items for current page
result.Items = finalQuery.ToList();
//sets pager
pager.CurrentPageRecords = result.Items.Count();
result.Pager = pager;
if (settings.DetailsAll || settings.DetailsCount > 0)
{
for (var i = 0; i < pager.CurrentPageRecords; i++)
{
if (settings.HasDetails(i))
{
var row = result.Items.ElementAt(i);
this.FillDetails(row);
}
}
}
}
else
{
result.Items = new List <TRow>();
}
//sets base settings
result.BaseSettings = this.settings.GetBase();
return(result);
}
public BsGridModel <TRow> ToBsGridViewModel(BsGridBaseRepositorySettings baseSettings, TRow row, bool getDetails)
{
this.settings = baseSettings;
return(ToBsGridViewModel(row, getDetails));
}
public BsGridModel <TRow> ToBsGridViewModel <TValue>(BsGridBaseRepositorySettings baseSettings, List <TRow> rows, Expression <Func <TRow, TValue> > rowExpression, List <BsGridRowData <TValue> > rowsSettings)
{
this.settings = baseSettings;
return(ToBsGridViewModel <TValue>(rows, rowExpression, rowsSettings));
}
/// <summary>
/// Paginates the result using the direction the orderQueryable
/// </summary>
/// <typeparam name="TValue"></typeparam>
/// <param name="query"></param>
/// <param name="uniqueIdFunc"></param>
/// <param name="gridSettings"></param>
/// <returns></returns>
public virtual IQueryable <TEntity> PaginateBy <TValue>(IQueryable <TEntity> query, Expression <Func <TEntity, TValue> > uniqueIdFunc, BsGridBaseRepositorySettings gridSettings)
{
if (gridSettings.OrderableColumns != null && gridSettings.OrderableColumns.Any())
{
var pe = Expression.Parameter(typeof(TEntity), "x");
var orderColumn = gridSettings.OrderableColumns.LastOrDefault();
if (gridSettings.GoTo.HasValue && (gridSettings.GoTo.Value == BsDirectionType.Next || gridSettings.GoTo.Value == BsDirectionType.Prev))
{
var parameterSetVisitor = new ParameterReplaceVisitor();
uniqueIdFunc = Expression.Lambda <Func <TEntity, TValue> >(parameterSetVisitor.ReplaceParameter(uniqueIdFunc.Body, pe), pe);
var propertyType = this.GetNoOffsetPropertyType(orderColumn);
var expressionMembers = this.GetExpressionMembers(propertyType, orderColumn, pe);
var uniqueIdConstant = Expression.Constant(Convert.ChangeType(gridSettings.UniqueID, typeof(TValue)), typeof(TValue));
Expression sortingKeyExpr, sortingKeyEqExpr, uniqueIdExpr;
if (gridSettings.GoTo.Value == BsDirectionType.Prev ^ orderColumn.Type == BsOrderType.Descending)
{
sortingKeyExpr = Expression.LessThan(expressionMembers.Left, expressionMembers.Right);
sortingKeyEqExpr = Expression.Equal(expressionMembers.Left, expressionMembers.Right);
uniqueIdExpr = Expression.LessThan(uniqueIdFunc.Body, uniqueIdConstant);
}
else
{
sortingKeyExpr = Expression.GreaterThan(expressionMembers.Left, expressionMembers.Right);
sortingKeyEqExpr = Expression.Equal(expressionMembers.Left, expressionMembers.Right);
uniqueIdExpr = Expression.GreaterThan(uniqueIdFunc.Body, uniqueIdConstant);
}
var predicateBody = Expression.Or(sortingKeyExpr, Expression.AndAlso(sortingKeyEqExpr, uniqueIdExpr));
var whereCallExpression = Expression.Call(
typeof(Queryable),
"Where",
new[] { query.ElementType },
query.Expression,
Expression.Lambda <Func <TEntity, bool> >(predicateBody, new[] { pe })
);
query = query.Provider.CreateQuery <TEntity>(whereCallExpression);
}
}
return(query);
}
/// <summary> /// Query ordering. To be used before grid paging /// </summary> /// <param name="query"></param> /// <returns></returns> public abstract IOrderedQueryable <TEntity> OrderQuery(IQueryable <TEntity> query, BsGridBaseRepositorySettings gridSettings = null);
/// <summary>
/// Creates Ordered query based on stored expressions and delegates.
/// For row columns that have identical names with db columns, the order is made automatically
/// </summary>
/// <param name="query">Query that will be ordered</param>
/// <param name="defaultOrderFunc">Default order row column. The query must be ordered before take/skip</param>
/// <returns>Ordered query</returns>
public virtual IOrderedQueryable <TEntity> Order(IQueryable <TEntity> query, Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > defaultOrderFunc, BsGridBaseRepositorySettings gridSettings = null)
{
//throw exception if defaultOrder is not asc or desc
if (defaultOrderFunc == null)
{
throw new Exception("you must implement a func for default order");
}
IOrderedQueryable <TEntity> orderedQuery = defaultOrderFunc(query);
if (this.columnsOrder != null && this.columnsOrder.Any())
{
this.columnsOrder.Reverse();
//order dict desc and order query based on Order priority
foreach (var item in this.columnsOrder)
{
var name = item.Name;
if (this.expressionSettings.ContainsKey(name))
{
var criteria = this.expressionSettings[name];
if (item.Type == BsOrderType.Ascending)
{
if (gridSettings == null || !gridSettings.GoTo.HasValue || gridSettings.GoTo.Value != BsDirectionType.Prev)
{
orderedQuery = criteria.OrderBy(orderedQuery);
}
else
{
orderedQuery = criteria.OrderByDescending(orderedQuery);
}
}
else if (item.Type == BsOrderType.Descending)
{
if (gridSettings == null || !gridSettings.GoTo.HasValue || gridSettings.GoTo.Value != BsDirectionType.Prev)
{
orderedQuery = criteria.OrderByDescending(orderedQuery);
}
else
{
orderedQuery = criteria.OrderBy(orderedQuery);
}
}
continue;
}
if (this.delegateSettings.ContainsKey(name))
{
orderedQuery = this.delegateSettings[name](orderedQuery, item.Type);
continue;
}
if (item.Type == BsOrderType.Ascending)
{
if (gridSettings == null || !gridSettings.GoTo.HasValue || gridSettings.GoTo.Value != BsDirectionType.Prev)
{
orderedQuery = orderedQuery.OrderBy(name);
}
else
{
orderedQuery = orderedQuery.OrderByDescending(name);
}
}
else if (item.Type == BsOrderType.Descending)
{
if (gridSettings == null || !gridSettings.GoTo.HasValue || gridSettings.GoTo.Value != BsDirectionType.Prev)
{
orderedQuery = orderedQuery.OrderByDescending(name);
}
else
{
orderedQuery = orderedQuery.OrderBy(name);
}
}
}
}
return(orderedQuery);
}
