private string GetSortUrl(string columnName, GridSortDirection?direction) { //switch direction for link: GridSortDirection newDir = direction == GridSortDirection.Ascending ? GridSortDirection.Descending : GridSortDirection.Ascending; //determine current url: var builder = new CustomQueryStringBuilder(_settings.Context.Request.QueryString); string url = builder.GetQueryStringExcept(new[] { GridPager.DefaultPageQueryParameter, _settings.ColumnQueryParameterName, _settings.DirectionQueryParameterName }); if (string.IsNullOrEmpty(url)) { url = "?"; } else { url += "&"; } return(string.Format("{0}{1}={2}&{3}={4}", url, _settings.ColumnQueryParameterName, columnName, _settings.DirectionQueryParameterName, ((int)newDir).ToString(CultureInfo.InvariantCulture))); }
public IQueryable <T> ApplyThenBy(IQueryable <T> items, GridSortDirection direction) { var ordered = items as IOrderedQueryable <T>; switch (direction) { case GridSortDirection.Ascending: if (_comparer == null) { return(ordered.ThenBy(_expression)); } else { return(ordered.ThenBy(_expression, _comparer)); } case GridSortDirection.Descending: if (_comparer == null) { return(ordered.ThenByDescending(_expression)); } else { return(ordered.ThenByDescending(_expression, _comparer)); } default: throw new ArgumentOutOfRangeException("direction"); } }
private string GetBy(GridSortDirection direction) { string result = ""; // get column name List <string> names = new List <string>(); Expression expression = _expression.Body; while (expression.NodeType != ExpressionType.Parameter) { names.Add(((MemberExpression)expression).Member.Name); expression = ((MemberExpression)expression).Expression; } for (int i = names.Count - 1; i >= 0; i--) { result += names[i]; if (i != 0) { result += "/"; } } switch (_initialDirection) { case GridSortDirection.Ascending: return(result); case GridSortDirection.Descending: return(result + " desc"); default: throw new ArgumentOutOfRangeException(); } }
private void LoadGrid() { //Get search results from server var documentList = GetDocumentList(); //bind to gridView if (documentList != null) { if (!string.IsNullOrEmpty(GridSortExpression)) { if (!string.IsNullOrEmpty(GridSortDirection)) { if (GridSortDirection.ToLower() == "asc") { documentList.ApplySort(GridSortExpression, ListSortDirection.Ascending); } else { documentList.ApplySort(GridSortExpression, ListSortDirection.Descending); } } } gvSearchResults.AutoGenerateColumns = false; gvSearchResults.DataSource = documentList; gvSearchResults.DataBind(); } }
private bool ValidateSorting <T, TNext>(TestGrid grid, Func <TestModel, T> orderExpression, string columnName, GridSortDirection direction, Func <TestModel, TNext> orderExpression2, string columnName2, GridSortDirection?direction2) { var payload = new ColumnOrderValue(columnName, direction, grid.Settings.SortSettings.SortValues.Count + 1); grid.Query.AddParameter(ColumnOrderValue.DefaultSortingQueryParameter, payload.ToString()); grid.Settings = new QueryStringGridSettingsProvider(grid.Query); IOrderedEnumerable <TestModel> etalonCollection; switch (direction) { case GridSortDirection.Ascending: etalonCollection = _repo.GetAll().OrderBy(orderExpression); break; case GridSortDirection.Descending: etalonCollection = _repo.GetAll().OrderByDescending(orderExpression); break; default: throw new ArgumentOutOfRangeException("direction"); } if (orderExpression2 != null && !string.IsNullOrWhiteSpace(columnName2) && direction2.HasValue) { payload = new ColumnOrderValue(columnName2, direction2.Value, grid.Settings.SortSettings.SortValues.Count + 1); grid.Query.AddParameter(ColumnOrderValue.DefaultSortingQueryParameter, payload.ToString()); grid.Settings = new QueryStringGridSettingsProvider(grid.Query); switch (direction2.Value) { case GridSortDirection.Ascending: etalonCollection = _repo.GetAll().OrderBy(orderExpression2); break; case GridSortDirection.Descending: etalonCollection = _repo.GetAll().OrderByDescending(orderExpression2); break; default: throw new ArgumentOutOfRangeException("direction"); } } IEnumerable <TestModel> resultCollection = grid.GetItemsToDisplay(); if (!ValidateCollectionsTheSame(resultCollection, etalonCollection)) { return(false); } return(true); }
public override IGridColumn<T> SortInitialDirection(GridSortDirection direction) { if (string.IsNullOrEmpty(_grid.Settings.SortSettings.ColumnName)) { IsSorted = true; Direction = direction; } return this; }
protected async Task TitleButtonClicked() { //switch direction for link: GridSortDirection newDir = Column.Direction == GridSortDirection.Ascending ? GridSortDirection.Descending : GridSortDirection.Ascending; await GridComponent.GetSortUrl(SortingSettings.ColumnQueryParameterName, Column.Name, SortingSettings.DirectionQueryParameterName, ((int)newDir).ToString(CultureInfo.InvariantCulture)); }
private void RefreshColumn() { //Columns string currentSortColumn = Context.Request.QueryString[ColumnQueryParameterName] ?? string.Empty; ColumnName = currentSortColumn; if (string.IsNullOrEmpty(currentSortColumn)) { Direction = GridSortDirection.Ascending; } }
private void RefreshColumn() { //Columns string currentSortColumn = Query[ColumnQueryParameterName].ToString() ?? string.Empty; ColumnName = currentSortColumn; if (string.IsNullOrEmpty(currentSortColumn)) { Direction = GridSortDirection.Ascending; } }
private void RefreshColumn() { //Columns string currentSortColumn = Context.Request.Query.GetValue("ColumnQueryParameterName"); ColumnName = currentSortColumn; if (string.IsNullOrEmpty(currentSortColumn)) { Direction = GridSortDirection.Ascending; } }
private bool ValidateSorting <T, TNext>(TestGrid grid, Func <TestModel, T> orderExpression, string columnName, GridSortDirection direction, Func <TestModel, TNext> thenByExpression, GridSortDirection?thenByDirection) { var settingsMock = new Mock <IGridSettingsProvider>(); settingsMock.Setup(s => s.SortSettings.ColumnName).Returns(columnName); settingsMock.Setup(s => s.SortSettings.Direction).Returns(direction); settingsMock.Setup(s => s.FilterSettings).Returns(new QueryStringFilterSettings(_query)); settingsMock.Setup(s => s.SearchSettings).Returns(new QueryStringSearchSettings(_query)); grid.Settings = settingsMock.Object; IEnumerable <TestModel> resultCollection = _grid.GetItemsToDisplay(); IOrderedEnumerable <TestModel> etalonCollection; switch (direction) { case GridSortDirection.Ascending: etalonCollection = _repo.GetAll().OrderBy(orderExpression); break; case GridSortDirection.Descending: etalonCollection = _repo.GetAll().OrderByDescending(orderExpression); break; default: throw new ArgumentOutOfRangeException("direction"); } if (thenByExpression != null) { switch (thenByDirection) { case GridSortDirection.Ascending: etalonCollection = etalonCollection.ThenBy(thenByExpression); break; case GridSortDirection.Descending: etalonCollection = etalonCollection.ThenByDescending(thenByExpression); break; default: throw new ArgumentOutOfRangeException("thenByDirection"); } } if (!ValidateCollectionsTheSame(resultCollection, etalonCollection)) { return(false); } return(true); }
public override IGridColumn <T> SortInitialDirection(GridSortDirection direction) { if (string.IsNullOrEmpty(_grid.Settings.SortSettings.ColumnName)) { IsSorted = true; Direction = direction; // added to enable initial sorting _grid.Settings.SortSettings.ColumnName = Name; _grid.Settings.SortSettings.Direction = direction; } return(this); }
private bool ValidateSorting <T, TNext>(TestGrid grid, Func <TestModel, T> orderExpression, string columnName, GridSortDirection direction, Func <TestModel, TNext> thenByExpression, GridSortDirection?thenByDirection) { grid.AddQueryParameter(((QueryStringSortSettings)grid.Settings.SortSettings) .ColumnQueryParameterName, columnName); grid.AddQueryParameter(((QueryStringSortSettings)grid.Settings.SortSettings) .DirectionQueryParameterName, direction.ToString("d")); grid.UpdateGrid().Wait(); IEnumerable <TestModel> resultCollection = grid.GetItemsToDisplay(); IOrderedEnumerable <TestModel> etalonCollection; switch (direction) { case GridSortDirection.Ascending: etalonCollection = _repo.GetAll().OrderBy(orderExpression); break; case GridSortDirection.Descending: etalonCollection = _repo.GetAll().OrderByDescending(orderExpression); break; default: throw new ArgumentOutOfRangeException("direction"); } if (thenByExpression != null) { switch (thenByDirection) { case GridSortDirection.Ascending: etalonCollection = etalonCollection.ThenBy(thenByExpression); break; case GridSortDirection.Descending: etalonCollection = etalonCollection.ThenByDescending(thenByExpression); break; default: throw new ArgumentOutOfRangeException("thenByDirection"); } } if (!ValidateCollectionsTheSame(resultCollection, etalonCollection)) { return(false); } return(true); }
private void RefreshDirection() { //Direction string currentDirection = Context.Request.QueryString[DirectionQueryParameterName] ?? string.Empty; if (string.IsNullOrEmpty(currentDirection)) { Direction = GridSortDirection.Ascending; return; } GridSortDirection dir; Enum.TryParse(currentDirection, true, out dir); Direction = dir; }
public IQueryable <T> ApplyOrder(IQueryable <T> items, GridSortDirection direction) { switch (direction) { case GridSortDirection.Ascending: return(items.OrderBy(_expression)); case GridSortDirection.Descending: return(items.OrderByDescending(_expression)); default: throw new ArgumentOutOfRangeException("direction"); } }
private void RefreshDirection() { //Direction string currentDirection = Context.Request.Query.GetValue(DirectionQueryParameterName); if (string.IsNullOrEmpty(currentDirection)) { Direction = GridSortDirection.Ascending; return; } GridSortDirection dir; Enum.TryParse(currentDirection, true, out dir); Direction = dir; }
private void RefreshDirection() { //Direction string currentDirection = Query[DirectionQueryParameterName].ToString() ?? string.Empty; if (string.IsNullOrEmpty(currentDirection)) { Direction = GridSortDirection.Ascending; return; } GridSortDirection dir; Enum.TryParse(currentDirection, true, out dir); Direction = dir; }
public void ApplyOrder(IDataQueryable <T> items, GridSortDirection direction) { switch (direction) { case GridSortDirection.Ascending: items.OrderList.Clear(); items.OrderList.Add(ColumnOrder <T> .NewColumnOrder(_expression)); break; case GridSortDirection.Descending: items.OrderList.Clear(); items.OrderList.Add(ColumnOrder <T> .NewColumnOrder(_expression, OrderDirection.Descending)); break; default: throw new ArgumentOutOfRangeException("direction"); } }
public IQueryable <T> ApplyOrder(IQueryable <T> items, GridSortDirection direction) { var existingOrders = OrderByCollectionVisitor.GetOrderBysFromQueryable(items); var orderToApply = OrderByCollectionVisitor.GetOrderByFromExpression(_expression); if (existingOrders.Any(prop => prop == orderToApply)) { // order was already applied, so skip applying it return(items); } switch (direction) { case GridSortDirection.Ascending: return(items.OrderBy(_expression)); case GridSortDirection.Descending: return(items.OrderByDescending(_expression)); default: throw new ArgumentOutOfRangeException("direction"); } }
private string GetSortUrl(string columnName, GridSortDirection? direction) { //switch direction for link: GridSortDirection newDir = direction == GridSortDirection.Ascending ? GridSortDirection.Descending : GridSortDirection.Ascending; //determine current url: var builder = new CustomQueryStringBuilder(_settings.Context.Request.QueryString); string url = builder.GetQueryStringExcept(new[] { GridPager.DefaultPageQueryParameter, _settings.ColumnQueryParameterName, _settings.DirectionQueryParameterName }); if (string.IsNullOrEmpty(url)) url = "?"; else url += "&"; return string.Format("{0}{1}={2}&{3}={4}", url, _settings.ColumnQueryParameterName, columnName, _settings.DirectionQueryParameterName, ((int) newDir).ToString(CultureInfo.InvariantCulture)); }
public ThenByColumnOrderer(Expression <Func <T, TKey> > expression, GridSortDirection initialDirection) { _expression = expression; _initialDirection = initialDirection; }
public IGridHtmlOptions <T> WithInitialSorting(Expression <Func <T, object> > expression, GridSortDirection direction) { if (IsNoSorted) { _source.Settings.SortSettings.ColumnName = PropertiesHelper.BuildColumnNameFromExpression(expression); _source.Settings.SortSettings.Direction = direction; } return(this); }
public override IGridColumn <T> SortInitialDirection(GridSortDirection direction) { IsSorted = true; Direction = direction; return(this); }
public abstract IGridColumn <T> SortInitialDirection(GridSortDirection direction);
public void Add(string name, GridSortDirection direction, int id) { Add(new ColumnOrderValue(name, direction, id)); }
public DefaultOrderColumnCollection(string name, GridSortDirection direction, int id) : this() { Add(new ColumnOrderValue(name, direction, id)); }
public string GetThenBy(GridSortDirection direction) { return(GetBy(direction)); }
public void ApplyOrder(IDataQueryable <T> items, GridSortDirection direction) { ApplyOrder(items); }
public IQueryable <T> ApplyThenBy(IQueryable <T> items, GridSortDirection direction) { return(Apply(items)); }
public IQueryable <T> ApplyOrder(IQueryable <T> items, GridSortDirection direction) { return(ApplyOrder(items)); }
public ColumnOrderValue(string name, GridSortDirection direction, int id) { ColumnName = name; Direction = direction; Id = id; }
//public override IGridColumn<T> SetFilterWidgetType(string typeName, object widgetData) //{ // return this; //Do nothing //} //public override IGridColumn<T> SetFilterWidgetType(string typeName) //{ // return this; //Do nothing //} public override IGridColumn <T> SortInitialDirection(GridSortDirection direction) { return(this); //Do nothing }
public ThenByColumnOrderer(Expression <Func <T, TKey> > expression, IComparer <TKey> comparer, GridSortDirection initialDirection) { _expression = expression; _comparer = comparer; _initialDirection = initialDirection; }