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