private InvokeResult <(IEnumerable <Condition> conditions, IEnumerable <Sort> sorts)> CreateMunrosQuery(
IEnumerable <HillCategory> hillCategories = null,
SortDirectionType heightSortDirectionType = SortDirectionType.None,
SortDirectionType nameSortDirectionType = SortDirectionType.None,
double?heightMinMetres = null,
double?heightMaxMetres = null)
=> _invokeHandler.Invoke(() =>
public InvokeResult <IEnumerable <MunroModel> > GetMunrosByQuery(
IEnumerable <HillCategory> hillCategories = null,
SortDirectionType heightSortDirectionType = SortDirectionType.None,
SortDirectionType nameSortDirectionType = SortDirectionType.None,
double?heightMinMetres = null,
double?heightMaxMetres = null,
int?limit = null)
=> _invokeHandler.Invoke(() =>
{
var queryResult = this.CreateMunrosQuery(
hillCategories,
heightSortDirectionType,
nameSortDirectionType,
heightMinMetres,
heightMaxMetres);
if (!queryResult.IsSuccess)
{
return(InvokeResult <IEnumerable <MunroModel> > .Fail(queryResult.Code));
}
var munros = _munrosRepository.GetAll();
var result =
_munroService.GetMunrosByQuery(munros, queryResult.Result.conditions, queryResult.Result.sorts,
limit);
return(result);
});
private static IEnumerable <OrderByInfo> ParseOrderBy(string orderColumn, SortDirectionType orderDirection)
{
if (String.IsNullOrEmpty(orderColumn))
{
yield break;
}
string[] items = orderColumn.Split(',');
bool initial = true;
foreach (string item in items)
{
string[] pair = item.Trim().Split(' ');
if (pair.Length > 2)
{
throw new ArgumentException(String.Format("Invalid OrderBy string '{0}'. Order By Format: Property, Property2 ASC, Property2 DESC", item));
}
string prop = pair[0].Trim();
if (String.IsNullOrEmpty(prop))
{
throw new ArgumentException("Invalid Property. Order By Format: Property, Property2 ASC, Property2 DESC");
}
yield return(new OrderByInfo {
PropertyName = prop, Direction = orderDirection, Initial = initial
});
initial = false;
}
}
/// <summary>
/// 按照指定的规则排序
/// </summary>
/// <param name="orderByProperty"></param>
/// <param name="direction"></param>
public void Sort(OrderByPropertyType orderByProperty, SortDirectionType direction)
{
T[] objArray = this.ToArray();
Array.Sort(objArray, delegate(T x, T y)
{
int result = 0;
switch (orderByProperty)
{
case OrderByPropertyType.FullPath:
result = x.FullPath.CompareTo(y.FullPath);
break;
case OrderByPropertyType.GlobalSortID:
result = x.GlobalSortID.CompareTo(y.GlobalSortID);
break;
case OrderByPropertyType.Name:
result = x.Name.CompareTo(y.Name);
break;
}
if (direction == SortDirectionType.Descending)
{
result = -result;
}
return(result);
});
this.Clear();
this.CopyFrom(objArray);
}
/// <summary>
/// To the list.
/// </summary>
/// <param name="array">The array.</param>
/// <param name="sortDirectionType">Type of the sort direction.</param>
/// <param name="removeDuplicates">if set to <c>true</c> [remove duplicates].</param>
public static List <string> ToList(this Array array, SortDirectionType sortDirectionType = SortDirectionType.None, bool removeDuplicates = false)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
var list = new List <string>(array.Length);
for (var i = 0; i < array.Length; i++)
{
var s = array.GetValue(i).ToString();
if (removeDuplicates)
{
if (!list.Contains(s))
{
list.Add(s);
}
}
else
{
list.Add(s);
}
}
return(sortDirectionType switch
{
SortDirectionType.None => list,
SortDirectionType.Ascending => list.OrderBy(x => x).ToList(),
SortDirectionType.Descending => list.OrderByDescending(x => x).ToList(),
_ => throw new SwitchCaseDefaultException(sortDirectionType)
});
public void ConvertEnumToArray <T>(
T dummyForT,
int expectedCount,
DropDownFirstItemType dropDownFirstItemType,
bool useDescriptionAttribute,
bool includeDefault,
SortDirectionType sortDirectionType,
bool byFlagIncludeBase,
bool byFlagIncludeCombined)
where T : Enum
{
// Arrange
var enumType = dummyForT.GetType();
// Act
var actual = EnumHelper.ConvertEnumToArray(
enumType,
dropDownFirstItemType,
useDescriptionAttribute,
includeDefault,
sortDirectionType,
byFlagIncludeBase,
byFlagIncludeCombined);
// Assert
actual.Should().NotBeNull().And.HaveCount(expectedCount);
}
public void SortTable(int expected, string sortOnColumn, SortDirectionType sortDirection)
{
// Arrange
var dt = GenerateTestTable();
// Act
var actual = dt.SortTable(sortOnColumn, sortDirection);
dt.Dispose();
// Assert
actual.Should().NotBeNull().And.BeOfType <DataTable>();
actual.Rows.Should().HaveCount(expected);
var sortOnColumnArray = (
from DataRow row
in actual.Rows
select row[sortOnColumn].ToString())
.ToArray();
if (sortDirection == SortDirectionType.Ascending)
{
sortOnColumnArray.Should().Equal("Brian", "Christoff", "David", "Janet", "Melanie", "Sam");
}
else
{
sortOnColumnArray.Should().Equal("Sam", "Melanie", "Janet", "David", "Christoff", "Brian");
}
}
public void ChangeSortMethod(SortCriteria sortBy, SortDirectionType sortDirection)
{
if (CurrentBrowserViewModel is BaseDirectoryViewerViewModel <FI, DI, FSI> )
{
var dirVM = (CurrentBrowserViewModel as BaseDirectoryViewerViewModel <FI, DI, FSI>).EmbeddedDirectoryViewModel;
dirVM.SortBy = sortBy;
dirVM.SortDirection = sortDirection == SortDirectionType.sortAssending ?
ListSortDirection.Ascending : ListSortDirection.Descending;
}
}
public void ToList(string[] expected, string[] input, SortDirectionType sortDirectionType, bool removeDuplicates)
{
// Act
var actual = input.ToList(sortDirectionType, removeDuplicates);
// Assert
actual.Should()
.NotBeNull()
.And.HaveCount(expected.Length)
.And.Contain(expected);
}
private static string GetSortMethodName(SortDirectionType sortDirect)
{
switch (sortDirect)
{
case SortDirectionType.Ascending:
return("OrderBy");
case SortDirectionType.Descending:
return("OrderByDescending");
default:
return("");
}
}
public void ToArray <T>(
T dummyForT,
int expectedCount,
DropDownFirstItemType dropDownFirstItemType,
bool useDescriptionAttribute,
bool includeDefault,
SortDirectionType sortDirectionType,
bool byFlagIncludeBase,
bool byFlagIncludeCombined) where T : Enum
{
// ReSharper disable once UnusedVariable
object dummyAssignment = dummyForT;
// Act
var actual = Enum <T> .ToArray(dropDownFirstItemType, useDescriptionAttribute, includeDefault, sortDirectionType, byFlagIncludeBase, byFlagIncludeCombined);
// Assert
actual.Should().NotBeNull().And.HaveCount(expectedCount);
}
public static void ChangeSortMethod <FI, DI, FSI>(
this System.Collections.ObjectModel.ObservableCollection <NavigationItemViewModel <FI, DI, FSI> > collection,
SortCriteria sortBy, System.ComponentModel.ListSortDirection sortDirection)
where FI : FSI
where DI : FSI
{
System.Windows.Data.ListCollectionView dataView =
(System.Windows.Data.ListCollectionView)
(System.Windows.Data.CollectionViewSource.GetDefaultView(collection));
dataView.SortDescriptions.Clear();
dataView.CustomSort = null;
SortDirectionType direction = sortDirection == System.ComponentModel.ListSortDirection.Ascending ?
SortDirectionType.sortAssending : SortDirectionType.sortDescending;
dataView.CustomSort = new EntryComparer <FI, DI, FSI>(sortBy, direction)
{
IsFolderFirst = true
};
}
/// <summary>
/// 排序
/// </summary>
/// <param name="orderByProperty">排序属性，<seealso cref="OrderByPropertyType"/>。</param>
/// <param name="direction">排序方式，<seealso cref="SortDirectionType"/>。</param>
public void Sort(OrderByPropertyType orderByProperty, SortDirectionType direction)
{
T[] objArray = new T[this.Count];
Items.CopyTo(objArray, 0);
Array.Sort(objArray, delegate(T x, T y)
{
int result = 0;
switch (orderByProperty)
{
case OrderByPropertyType.FullPath:
result = x.FullPath.CompareTo(y.FullPath);
break;
case OrderByPropertyType.GlobalSortID:
result = x.GlobalSortID.CompareTo(y.GlobalSortID);
break;
case OrderByPropertyType.Name:
result = x.Name.CompareTo(y.Name);
break;
}
if (direction == SortDirectionType.Descending)
{
result = -result;
}
return(result);
});
Items.Clear();
for (int i = 0; i < objArray.Length; i++)
{
Items.Add(objArray[i]);
}
}
public static IOrderedQueryable <T> OrderBy <T>(this IQueryable <T> current, SortDirectionType sortDirect, string field)
{
var modelType = typeof(T);
var methodName = GetSortMethodName(sortDirect);
// Генерируем x => x.Name
var param = Expression.Parameter(modelType, "x");
var property = Expression.Property(param, field);
var lambdaProperty = Expression.Lambda(property, param);
var methodInfo = typeof(Queryable).GetMethods(BindingFlags.Public | BindingFlags.Static).FirstOrDefault(x => x.Name == methodName &&
x.GetParameters().Length == 2 &&
x.GetGenericArguments().Length == 2);
var genericMethod = methodInfo.MakeGenericMethod(modelType, property.Type);
var commonParam = Expression.Parameter(typeof(IQueryable <T>), "y");
// Генерируем вызов метода OrderBy или OrderByDescending
var exp = Expression.Call(genericMethod, commonParam, lambdaProperty);
var a = Expression.Lambda <Func <IQueryable <T>, IOrderedQueryable <T> > >(exp, commonParam);
return(a.Compile()(current));
}
/// <summary>
/// To the array.
/// </summary>
/// <param name="array">The array.</param>
/// <param name="sortDirectionType">Type of the sort direction.</param>
/// <param name="removeDuplicates">if set to <c>true</c> [remove duplicates].</param>
public static Array ToArray(this Array array, SortDirectionType sortDirectionType = SortDirectionType.None, bool removeDuplicates = false)
{
return(ToList(array, sortDirectionType, removeDuplicates).ToArray());
}
public ProvincesList(ProvinceListSortField sort, SortDirectionType dir, Dictionary<ProvinceListFilter, string> filters)
{
}
public TransactionsList(TransactionsListSortField sort, SortDirectionType dir, Dictionary<TransactionsListFilter, string> filters)
{
}
/// <summary>
/// Convenience constructor
/// </summary>
/// <param name="sortDirection">Direction of the sort</param>
/// <param name="propertyPath">Property path used for this field order</param>
///
public FieldOrderType(SortDirectionType sortDirection, BasePathToElementType propertyPath)
{
this.orderField = sortDirection;
this.itemField = propertyPath;
}
//sorts cameras by Camera3D::drawDepth - used for PIP screen layout - see ScreenManager
public void SortByDepth(SortDirectionType sortDirectionType)
{
this.cameraList.Sort(new CameraDepthComparer(sortDirectionType));
}
public EntryComparer(SortCriteria criteria, SortDirectionType direction)
{
SortBy = criteria;
SortDirection = direction;
}
/// <summary>
/// Sorts the table.
/// </summary>
/// <param name="dataTable">The data table.</param>
/// <param name="sortOnColumn">The sort on column.</param>
/// <param name="sortDirection">The sort direction.</param>
public static DataTable SortTable(this DataTable dataTable, string sortOnColumn, SortDirectionType sortDirection)
{
if (dataTable == null)
{
throw new ArgumentNullException(nameof(dataTable));
}
if (string.IsNullOrEmpty(sortOnColumn))
{
throw new ArgumentNullOrDefaultException(nameof(sortOnColumn));
}
var sortExpression = sortDirection == SortDirectionType.Ascending
? sortOnColumn + " ASC"
: sortOnColumn + " DESC";
return(FilterTable(dataTable, string.Empty, sortExpression));
}
public static IQueryable <T> OrderBy <T>(this IQueryable <T> collection, string orderColumn, SortDirectionType orderDirection)
{
return(ParseOrderBy(orderColumn, orderDirection).Aggregate(collection, ApplyOrderBy));
}
public InventoryList(InventoryListSortField sort, SortDirectionType dir, Dictionary<InventoryListFilter, string> filters)
{
}
public CameraDepthComparer(SortDirectionType sortDirectionType)
{
this.sortDirectionType = sortDirectionType;
}
public SortField(string expression, SortDirectionType direction)
{
SortDirection = direction;
SortExpression = expression;
}
public ProvincesList(ProvinceListSortField sort, SortDirectionType dir, Dictionary <ProvinceListFilter, string> filters)
{
}
public RelationshipTypeList(RelationshipTypeListSortField sort, SortDirectionType dir, Dictionary<ProvinceListFilter, string> filters)
{
}
public SortField(string expression, SortDirectionType direction)
{
SortDirection = direction;
SortExpression = expression;
}
public RelationshipTypeList(RelationshipTypeListSortField sort, SortDirectionType dir, Dictionary <ProvinceListFilter, string> filters)
{
}
public TransactionsList(TransactionsListSortField sort, SortDirectionType dir, Dictionary <TransactionsListFilter, string> filters)
{
}
public static IQueryable <TSource> OrderWithDirectionBy <TSource, TKey>(this IQueryable <TSource> source, bool isFirst, SortDirectionType direction, Expression <Func <TSource, TKey> > selector)
{
return(!isFirst
? direction == SortDirectionType.Ascending
? ((IOrderedQueryable <TSource>)source).ThenBy(selector)
: ((IOrderedQueryable <TSource>)source).ThenByDescending(selector)
: direction == SortDirectionType.Ascending
? source.OrderBy(selector)
: source.OrderByDescending(selector));
}
public InventoryList(InventoryListSortField sort, SortDirectionType dir, Dictionary <InventoryListFilter, string> filters)
{
}
