/// <summary> /// Adds sort by a property which describes by <paramref name="func"/> in <paramref name="direction"/> order. /// </summary> public SortSettingsBuilder <TEntity> AddOrderBy(LambdaExpression func, SortOrder direction) { var rule = new SortRule(direction, func); sortRules.Add(rule); return(this); }
public void Setup(string name, SortRule sortRule, Action <string> onElementDoubleClick) { m_foldoutName = name; SetFoldoutName(name); m_sortRule = sortRule; m_onElementDoubleClick = onElementDoubleClick; }
public void Orders_Test() { var ci = GetContainer(); IOrderRepository rep = ci.Resolve <IOrderRepository>(); bool isExists = rep.Exists(o => o.OrderNo.Equals("66666588888")); Console.WriteLine(isExists); int total = 0; var sorts = new SortRule[1]; sorts[0] = new SortRule() { PropertyName = "OrderNo", IsDesc = false }; var pagedList = rep.FindPageList(new PagedQuery() { PageIndex = 2, PageSize = 2 }, null, sorts); var orders = pagedList.Rows; foreach (var order in orders) { Console.WriteLine(order.OrderNo); } Console.WriteLine("total:" + total); }
private SelectQueryDefinition BuildSort(Select select) { var sort = Sort.RELEVANCE; if (!select.Sort.Any()) { SortRule sortOneCreateDate = new SortRule { Field = "createdondate", FieldType = FieldTypeEnum.DATETIME, Descending = false }; select.Sort.Add(sortOneCreateDate); } var sortFields = new List <SortField>(); foreach (var rule in select.Sort) { int sortfieldtype; string sortFieldPrefix = ""; Sortfieldtype(rule.FieldType, out sortfieldtype, ref sortFieldPrefix); if (rule.Field == "createdondate") { rule.Field = "$createdondate"; } sortFields.Add(new SortField(sortFieldPrefix + rule.Field, sortfieldtype, rule.Descending)); } sort = new Sort(sortFields.ToArray()); Sort = sort; return(this); }
private static Sort BuildSort(Select select) { var sortFields = new List <SortField>(); if (!select.Sort.Any()) { // if no sorting is specified, then sort on score and on sortOnCreateDate sortFields.Add(SortField.FIELD_SCORE); var sortOnCreateDate = new SortRule { Field = "createdondate", FieldType = FieldTypeEnum.DATETIME, Descending = false }; select.Sort.Add(sortOnCreateDate); } foreach (var rule in select.Sort) { int sortfieldtype; string sortFieldPrefix = ""; Sortfieldtype(rule.FieldType, out sortfieldtype, ref sortFieldPrefix); if (rule.Field == "createdondate") { rule.Field = "$createdondate"; } sortFields.Add(new SortField(sortFieldPrefix + rule.Field, sortfieldtype, rule.Descending)); } var sort = new Sort(sortFields.ToArray()); return(sort); }
public void SortOrder_Success <TKey>( SortRule <IEntity <TKey>, TKey> sortRule, SortOrder expectedSortOrder) { // Arrange & Act & Assert Assert.Equal(expectedSortOrder, sortRule?.SortOrder); }
public List <Item> Sort(List <Item> source, List <POINT> used, int length) { SortRule rule = new SortRule(Config); List <Item> clone = new List <Item>(); source.ForEach(x => clone.Add((Item)x.Clone())); List <Item> item_1x1 = clone.Where(x => x.w * x.h == 1).ToList(); item_1x1 = item_1x1.OrderBy(s => s, rule).ToList(); List <POINT> free = new List <POINT>(); var temp = item_1x1.Select(x => x.point).ToList(); foreach (POINT _temp in temp) { used.Remove(_temp); } int index = 0; for (int x = 0; x < length; x++) { for (int y = 0; y < length; y++) { if (Config.Direction == "Vertical") { if (used.Where(a => a.X == x && a.Y == y).Any()) { continue; } } else { if (used.Where(a => a.X == y && a.Y == x).Any()) { continue; } } if (index < item_1x1.Count) { if (Config.Direction == "Vertical") { item_1x1[index].point = new POINT(x, y); } else { item_1x1[index].point = new POINT(y, x); } index++; } } } List <Item> resoult = new List <Item>(); resoult.AddRange(item_1x1); resoult.AddRange(source.Where(x => x.w * x.h != 1).ToList()); return(resoult); }
public void IsValid_Success <TEntity, TKey>( SortRule <TEntity, TKey> sortRule, bool expectedResult) where TEntity : class, IEntity <TKey> { // Arrange & Act & Assert Assert.Equal(expectedResult, sortRule?.IsValid); }
private static string GetSortingMethodName(SortRule sortRule, bool initialSorting) { if (initialSorting) { return(sortRule.SortDirection == Shared.Framework.DataSource.SortOrder.Desc ? OrderByDescendingMethod : OrderByMethod); } return(sortRule.SortDirection == Shared.Framework.DataSource.SortOrder.Desc ? ThenByDescendingMethod : ThenByMethod); }
public void explicit_default_sort() { var definition = new GridDefinition <Case>(); definition.ShowViewLink(x => x.Condition); definition.SortBy = SortRule <Case> .Descending(x => x.Created); definition.SortBy.FieldName.ShouldEqual("Created"); definition.SortBy.IsAscending.ShouldBeFalse(); }
public void Sort_Success() { // Arrange var sort = new SortRule <FakeEntity, int>(); // Act _queryParameters.Sort = sort; // Assert Assert.Equal(sort, _queryParameters.Sort); }
public DrawScheduler() : base(new LinearScheduler <IDrawTask>(), x => new DrawTask(x)) { _scheduler = (LinearScheduler <IDrawTask>)Scheduler; var sortRule = new SortRule <IDrawTask, float>(Scheduler.Tasks, x => x.RenderDepth, Comparer <float> .Default, (x, h) => x.RenderDepthChanged += h, (x, h) => x.RenderDepthChanged -= h) { Weight = 10f, MustBeApplied = true }; Scheduler.Rules.Add(sortRule); }
public static SortRule CreateSortRule(FieldConfig config, string cultureCode, string field, bool descending) { var fieldConfig = GetField(config, field); var cultureSuffix = fieldConfig != null && fieldConfig.MultiLanguage ? "." + cultureCode : string.Empty; var indexType = GetFieldType(fieldConfig != null ? fieldConfig.IndexType : string.Empty); var rule = new SortRule() { Field = field + cultureSuffix, FieldType = indexType, Descending = descending }; return(rule); }
private IQueryable <TEntity> ApplySortSettingsIfExist <TEntity>(IQueryable <TEntity> queryable, QueryParameters parameters) where TEntity : Entity { if (parameters.SortSettings != null && parameters.SortSettings.SortRules != null && parameters.SortSettings.SortRules.Any()) { SortRule initialSortingRule = parameters.SortSettings.SortRules.First(); queryable = ApplySortingRule(queryable, initialSortingRule, true); queryable = parameters.SortSettings.SortRules.Skip(1) .Aggregate(queryable, (current, sortRule) => ApplySortingRule(current, sortRule)); } return(queryable); }
public void do_override_sorting_if_no_sorting_exists() { var rule = SortRule <Case> .Ascending(x => x.Condition); var request = new GridDataRequest() { SortColumn = null, SortAscending = false }; rule.ApplyDefaultSorting(request); request.SortColumn.ShouldEqual("Condition"); request.SortAscending.ShouldBeTrue(); }
public void do_not_override_sorting_if_it_exists() { var rule = SortRule <Case> .Ascending(x => x.Condition); var request = new GridDataRequest() { SortColumn = "different", SortAscending = false }; rule.ApplyDefaultSorting(request); request.SortColumn.ShouldEqual("different"); request.SortAscending.ShouldBeFalse(); }
public static List <T> ToNumberList <T>(this string[] data, SortRule sortDirection = SortRule.NoSort) { if (data == null || !data.Any()) { throw new ArgumentNullException(nameof(data)); } return(typeof(T).Name switch { "Int16" => data.Select(x => short.Parse(x)).Sort(sortDirection) as List <T>, "Int32" => data.Select(x => int.Parse(x)).Sort(sortDirection) as List <T>, "Int64" => data.Select(x => long.Parse(x)).Sort(sortDirection) as List <T>, "Decimal" => data.Select(x => decimal.Parse(x)).Sort(sortDirection) as List <T>, "Single" => data.Select(x => float.Parse(x)).Sort(sortDirection) as List <T>, _ => throw new ArgumentException($"A non-numeric type was attempted to be converted. Requested Type: {typeof(T).Name}. Accepted types: short, int, long, decimal and float.", nameof(data)), });
public static SortRule CreateSortRule(FieldConfig parentFieldConfig, string cultureCode, string field, bool descending) { var fieldConfig = GetField(parentFieldConfig, field); var cultureSuffix = fieldConfig != null && fieldConfig.MultiLanguage ? "." + cultureCode : string.Empty; var indexType = GetFieldType(fieldConfig != null ? fieldConfig.IndexType : string.Empty); if (field == JsonMappingUtils.FIELD_TIMESTAMP) { indexType = FieldTypeEnum.DATETIME; } var rule = new SortRule() { Field = field + cultureSuffix, FieldType = indexType, Descending = descending }; return(rule); }
public SortRuleTests() { _sortRule = new SortRule <FakeEntity, int>(); }
public void SortDescending(Expression <Func <TEntity, object> > property) { _definition.SortBy = SortRule <TEntity> .Descending(property); }
private IQueryable <TEntity> ApplySortingRule <TEntity>(IQueryable <TEntity> queryable, SortRule sortRule, bool initialSorting = false) where TEntity : Entity { string methodName = GetSortingMethodName(sortRule, initialSorting); MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName, new[] { typeof(TEntity), sortRule.Expression .ReturnType }, queryable.Expression, Expression.Quote(sortRule.Expression)); return(queryable.Provider.CreateQuery <TEntity>(resultExp)); }