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