public async Task <PaginatedResult <AutoPartProjection> > GetAutoParts( AutoPartsFilter filter, AutoPartsSortingOption sorting = AutoPartsSortingOption.Name, SortingDirection direction = SortingDirection.Ascending) { if (filter == null) { throw new ArgumentNullException($"Parameter {nameof(filter)} of type {nameof(AutoPartsFilter)} cannot be null."); } var query = PrepareGetAutoPartsQuery(filter); var items = await query .ApplyOrderByExpressionFromDictionary(autoPartsSortingExpressions, sorting, direction) .GetPartition(filter.ItemsToSkip, filter.ItemsToTake) .ProjectTo <AutoPartProjection>(mapper.ConfigurationProvider) .ToArrayAsync(); var totalNumberOfItems = await query .CountAsync(); return(new PaginatedResult <AutoPartProjection> { Items = items, TotalNumberOfItems = totalNumberOfItems }); }
private void RenderTitleCell( SortingDirection sortDirection, int sortIndex, string iconFilename, string iconAltText) { IBocColumnRenderer renderer = new BocSimpleColumnQuirksModeRenderer(new FakeResourceUrlFactory(), _bocListQuirksModeCssClassDefinition); renderer.RenderTitleCell(_renderingContext, sortDirection, sortIndex); var document = Html.GetResultDocument(); var th = Html.GetAssertedChildElement(document, "th", 0); Html.AssertAttribute(th, "class", _bocListQuirksModeCssClassDefinition.TitleCell, HtmlHelperBase.AttributeValueCompareMode.Contains); Html.AssertAttribute(th, "class", c_columnCssClass, HtmlHelperBase.AttributeValueCompareMode.Contains); Assert.Less(0, th.ChildNodes.Count); var sortCommandLink = Html.GetAssertedChildElement(th, "a", 0); Html.AssertAttribute(sortCommandLink, "id", List.ClientID + "_0_SortCommand"); Html.AssertTextNode(sortCommandLink, Column.ColumnTitleDisplayValue + HtmlHelper.WhiteSpace, 0); var sortOrderSpan = Html.GetAssertedChildElement(sortCommandLink, "span", 1); Html.AssertAttribute( sortOrderSpan, "class", _bocListQuirksModeCssClassDefinition.SortingOrder, HtmlHelperBase.AttributeValueCompareMode.Contains); var sortIcon = Html.GetAssertedChildElement(sortOrderSpan, "img", 0); Html.AssertAttribute(sortIcon, "src", iconFilename, HtmlHelperBase.AttributeValueCompareMode.Contains); Html.AssertAttribute(sortIcon, "alt", iconAltText); Html.AssertTextNode(sortOrderSpan, HtmlHelper.WhiteSpace + (sortIndex + 1), 1); }
/// <summary> /// Configure default sorting value for object type /// </summary> /// <typeparam name="TToProperty">Type default value configured for</typeparam> /// <param name="toPredicate">Property for default sorting</param> /// <param name="sortingDirection">Sorting direction</param> public FilterBuilder <TFromEntity, TToEntity> Default <TToProperty>( Expression <Func <TToEntity, TToProperty> > toPredicate, SortingDirection sortingDirection = SortingDirection.Asc) { //var defaultName = $"{typeof(TToEntity).FullName}.Default"; var defaultName = $"{typeof(TFromEntity).FullName}.Default"; var toMember = toPredicate.Body as MemberExpression; var propertyPath = GetPropertyPath(toPredicate.Body as MemberExpression); // create filter setting which stores all data about filter var filterSetting = new FilterSetting { Name = defaultName, PropertyPath = propertyPath, OperandType = toMember.Member.DeclaringType, ParameterType = toMember.Type, OperatorBetween = OperatorBetween.None, MethodName = Method.Equal, SortingDirection = sortingDirection }; _filterSetting.Add(defaultName, filterSetting); return(this); }
public virtual void RenderTitleCell( BocColumnRenderingContext <TBocColumnDefinition> renderingContext, SortingDirection sortingDirection, int orderIndex) { ArgumentUtility.CheckNotNull("renderingContext", renderingContext); string cssClassTitleCell = CssClasses.TitleCell; if (!string.IsNullOrEmpty(renderingContext.ColumnDefinition.CssClass)) { cssClassTitleCell += " " + renderingContext.ColumnDefinition.CssClass; } renderingContext.Writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClassTitleCell); renderingContext.Writer.RenderBeginTag(HtmlTextWriterTag.Th); RenderTitleCellMarkers(renderingContext); RenderBeginTagTitleCellSortCommand(renderingContext); RenderTitleCellText(renderingContext); if (renderingContext.Control.IsClientSideSortingEnabled || renderingContext.Control.HasSortingKeys) { RenderTitleCellSortingButton(renderingContext, sortingDirection, orderIndex); } RenderEndTagTitleCellSortCommand(renderingContext.Writer); renderingContext.Writer.RenderEndTag(); }
public void When_ListView_Creating_Sort_CollectionSource(SortingDirection sortingDirection, int first, int last) { using var application = PositionInListViewModuleModule().Application; var positionInListView = application.Model.ToReactiveModule <IModelReactiveModulesPositionInListView>() .PositionInListView.ListViewItems.AddNode <IModelPositionInListViewListViewItem>(); positionInListView.ListView = application.Model.BOModel.GetClass(typeof(PIL)).DefaultListView; positionInListView.SortingDirection = sortingDirection; var listViewColumn = positionInListView.ListView.Columns[nameof(PIL.Name)]; listViewColumn.SortOrder = 0; listViewColumn.SortOrder = ColumnSortOrder.Ascending; var objectSpace = application.CreateObjectSpace(); var pil1 = objectSpace.CreateObject <PIL>(); pil1.Name = "c"; var pil2 = objectSpace.CreateObject <PIL>(); pil2.Name = "a"; var pil3 = objectSpace.CreateObject <PIL>(); pil3.Name = "b"; objectSpace.CommitChanges(); var listView = application.NewView(positionInListView.ListView).AsListView(); application.CreateViewWindow().SetView(listView); var objects = listView.CollectionSource.Objects <PIL>().Select(pil => pil.Name).ToArray(); objects[first].ShouldBe(pil1.Name); objects[1].ShouldBe(pil2.Name); objects[last].ShouldBe(pil3.Name); }
/// <summary> /// Maps property of filter object to certain object typed stored in database /// </summary> /// <typeparam name="TFromProperty">Property type to bind from</typeparam> /// <typeparam name="TToProperty">Property type to bind to</typeparam> /// <param name="fromPredicate">Property to bind from</param> /// <param name="toPredicate">Property to bind to</param> /// <param name="operatorBetween">Operator between conditions in db query</param> /// <param name="method">Method to call for property</param> /// <param name="sorting">Sorting type</param> public FilterBuilder <TFromEntity, TToEntity> Map <TFromProperty, TToProperty>( Expression <Func <TFromEntity, TFromProperty> > fromPredicate, Expression <Func <TToEntity, TToProperty> > toPredicate, OperatorBetween operatorBetween, Method method, SortingDirection sortingDirection = SortingDirection.Asc) { // get full property names var fromPropertyName = GetFullPropertyName(fromPredicate); var toMember = toPredicate.Body as MemberExpression; var propertyPath = GetPropertyPath(toPredicate.Body as MemberExpression); // create filter setting which stores all data about filter var filterSetting = new FilterSetting { Name = fromPropertyName, PropertyPath = propertyPath, OperandType = toMember.Member.DeclaringType, ParameterType = toMember.Type, OperatorBetween = operatorBetween, MethodName = method, SortingDirection = sortingDirection }; _filterSetting.Add(fromPropertyName, filterSetting); return(this); }
/// <summary> /// Classic Select /// </summary> /// <remarks> /// Sorts to the right, picks up the smallest/largest (depending on if it's desc or asc) /// and puts it from left to right /// </remarks> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sorting"></param> /// <returns></returns> public static SwappingSortingResult <T> SortUsingClassicSelect <T>(this T[] source, SortingDirection sorting = SortingDirection.Ascending) where T : struct, IComparable <T> { if (null == source) { throw new ArgumentNullException(nameof(source)); } var iterations = 0; var swaps = 0; for (var i = 0; i < source.Length - 1; i++) { for (var j = i + 1; j < source.Length; j++) { if (Helpers.ShoudSwap(source[i], source[j], sorting)) { Helpers.Swap(ref source[i], ref source[j]); swaps++; } iterations++; } } return(new SwappingSortingResult <T>(source, iterations, swaps)); }
/// <summary> /// Orders a <see cref="IQueryable"/> by given sorting. Order expression is being taken from sortingExpressions dictionary. /// If <see cref="SortingDirectionAttribute" /> is not provided on the sorting enum value the default sorting order is Ascending /// </summary> /// <typeparam name="TSource"> /// <see cref="IQueryable"/> generic type parameter /// </typeparam> /// <typeparam name="TSortingEnum"> /// Enum type which represents sorting option /// </typeparam> /// <param name="source"></param> /// <param name="sortingExpressions">Dictionary of expressions of sorting options</param> /// <param name="sorting">Enum value which represents sorting option</param> /// <param name="sortingDirection">Enum value which represents order of sorting options</param> public static IQueryable <TSource> ApplyOrderByExpressionFromDictionary <TSource, TSortingEnum>( this IQueryable <TSource> source, IReadOnlyDictionary <TSortingEnum, Expression <Func <TSource, object> > > sortingExpressions, TSortingEnum sorting, SortingDirection sortingDirection = SortingDirection.Descending ) where TSortingEnum : struct, IConvertible { var sortingType = typeof(TSortingEnum); if (!sortingType.IsEnum) { throw new ArgumentException($"{nameof(TSortingEnum)} must be an enumerated type"); } if (!sortingExpressions.ContainsKey(sorting)) { return(source); } var sortingExpression = sortingExpressions[sorting]; if (sortingDirection == SortingDirection.Ascending) { return(source.OrderBy(sortingExpression) .AsQueryable()); } return(source.OrderByDescending(sortingExpression) .AsQueryable()); }
public static double[] BubbleSort(double[] array, SortingDirection direction) { // A comparison cycle of the i-th element with subsequent elements of the array. for (int i = 0; i < array.Length - 1; i++) { for (int j = i + 1; j < array.Length; j++) { // Sort the elements of the array in ascending or descending order depending on the selected sorting direction. switch (direction) { case SortingDirection.Asc: // If the i-th element of the array is greater than the j-th element. if (array[i] > array[j]) { // Swap elements which passed order condition. Helper.Swap(array, i, j); } break; case SortingDirection.Desc: // If the i-th element of the array is less than the j-th element. if (array[i] < array[j]) { // Swap elements which passed order condition. Helper.Swap(array, i, j); } break; } } } return(array); }
/// <summary> /// Classic Insert sorting algorithm. Variation to reduce if statements /// </summary> /// <remarks>Sorts to the left</remarks> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sorting"></param> /// <returns></returns> public static SwappingSortingResult <T> SortUsingClassiccInsertNoIfs <T>(this T[] source, SortingDirection sorting = SortingDirection.Ascending) where T : struct, IComparable <T> { if (null == source) { throw new ArgumentNullException(nameof(source)); } var iterations = 0; var swaps = 0; for (var i = 1; i < source.Length; i++) { var j = i; while (j > 0 && Helpers.ShoudSwap(source[j - 1], source[j], sorting)) { Helpers.Swap(ref source[j - 1], ref source[j]); j--; swaps++; iterations++; } } return(new SwappingSortingResult <T>(source, iterations, swaps)); }
private void RememberCriteria(string propertyName, SortingDirection providerKind, Type propertyType) { MemberInfo property = this.type.GetProperty(propertyName, propertyType); MemberExpression propertyExpression = Expression.MakeMemberAccess(parameter, property); sortingСriteria.Add(new Tuple <SortingDirection, MemberExpression>(providerKind, propertyExpression)); }
public UserScoreIndex(int IndexId, string IndexName, SortingDirection SortingDirection) { this.IndexId = IndexId; this.IndexName = IndexName; this.SortingDirection = SortingDirection; this.Tree = new RedBlackTreeWithStats <UserScore>(this); this.UserScoresByUserId = new Dictionary <uint, UserScore>(); }
public static void SwapIfNeeded <T>(ref T left, ref T right, SortingDirection sorting, Action onSwap = null) where T : struct, IComparable <T> { if (ShoudSwap(left, right, sorting)) { Swap(ref left, ref right); onSwap?.Invoke(); } }
/// <summary> /// Classic merge sort /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sorting"></param> /// <returns></returns> public static SwappingSortingResult <T> SortUsingClassicMerge <T>(this T[] source, SortingDirection sorting = SortingDirection.Ascending) where T : struct, IComparable <T> { if (null == source) { throw new ArgumentNullException(nameof(source)); } return(null); }
private void Sort(object columnName) { if (CanSort(columnName)) { sortDirection = sortingColumn == (string)columnName && sortDirection == SortingDirection.Ascendung ? sortDirection = SortingDirection.Descending : sortDirection = SortingDirection.Ascendung; sortingColumn = (string)columnName; ResetPageing(); } }
public UserScoreIndex this[string IndexName] { get { lock (this) { return(Indices[IndiceIdsByName.GetOrCreate(IndexName, () => { SortingDirection SortingDirection = SortingDirection.Invalid; var IndexNameMatch = new Regex(@"^([\+\-])[^:]+(:(\d+))?$", RegexOptions.Compiled).Match(IndexName); if (!IndexNameMatch.Success) { throw(new Exception("Invalid Index Name '" + IndexName + "'")); } var DirectionString = IndexNameMatch.Groups[1].Value; var CappedCountString = IndexNameMatch.Groups[3].Value; int CappedCount = -1; if (DirectionString == "+") { SortingDirection = SortingDirection.Ascending; } if (DirectionString == "-") { SortingDirection = SortingDirection.Descending; } if (CappedCountString.Length > 0) { CappedCount = int.Parse(CappedCountString); } if (SortingDirection == SortingDirection.Invalid) { throw(new Exception("The index must be called '-IndexName' or '+IndexName' wether is a descending index or ascending index.")); } var Index = new UserScoreIndex(Indices.Count, IndexName, SortingDirection); Index.CappedCount = CappedCount; //Index.Tree.CappedToNumberOfElements = CappedCount; Indices.Add(Index); Console.WriteLine( "Created Indexd: '{0}' :: IndexId({1}), Direction({2}), CappedCount({3})", IndexName, Index.IndexId, Enum.GetName(typeof(SortingDirection), SortingDirection), CappedCount ); return Index.IndexId; })]); } } }
public Task <List <DBRecord> > SortByAsync(string column, SortingDirection direction) { List <DBRecord> sortedRecords = new List <DBRecord>(records); Task <List <DBRecord> > task = Task <List <DBRecord> > .Factory.StartNew(() => { RecordComparer comparer = new RecordComparer(column, direction); sortedRecords.Sort(comparer); return(sortedRecords); }); return(task); }
private SingleChart GetElectricityChart(string id, string countryCode, string yearConfig, SortingDirection sortingDirection) { SingleChart result = null; Dictionary<string, Dictionary<string, List<string>>> config; DatabaseRepository db; IList<GetValuesResult> data; IList<int> years; int requestedCountryId; List<GetIndicatorsInfoResult> indicatorList; List<GetCountriesInfo_Result> countryList; List<GetSupportedIndicatorsResult> supportedIndicatorList; InitChartData(id, countryCode, yearConfig, false, true, true, out db, out data, out years, out requestedCountryId, out indicatorList, out countryList, out supportedIndicatorList, out config); var chartInfo = db.GetChartInfo(id); if (chartInfo != null) { var countries = countryList.ToDictionary(c => c.CountryId); var dataDictionary = data.ToDictionary( d => new Tuple<int, int, int>(d.CountryId, d.IndicatorId, d.Year), d => d.IndicatorValue); var supportedIndicatorIds = supportedIndicatorList.Select(s => s.SupportedIndicatorId).Distinct().ToDictionary(i => i); var cleanedData = data.Where(d => !supportedIndicatorIds.ContainsKey(d.IndicatorId)).ToList(); List<int> categoryIds; if (sortingDirection != SortingDirection.None) { GetCategoryOrder(requestedCountryId, cleanedData, countries, countryList, sortingDirection == SortingDirection.Desc, out categoryIds); } else { categoryIds = data.Select(d => d.CountryId).Distinct().OrderBy(cId => countries[cId].CountryType).ToList(); } List<string> cats; List<ChartSeries> sers; ConvertToSeries(cleanedData, categoryIds, countryList.ToDictionary(y => y.CountryId, y => y.Name), g => g.Year, SeriesType.Bar, years.ToDictionary(k => k, k => k.ToString()), g => g.CountryId, d => new Point { Value = d }, out cats, out sers); result = years.Count > 0 ? CreateChart(chartInfo, years.First(), years.Last(), cats, sers) : CreateChart(chartInfo); SetStartOrEndValue(result, PointToSet.Min); SetStartOrEndValue(result, PointToSet.Max); } return result; }
private static QueryMethod GetQueryMethod(SortingDirection direction, bool isFirst) { if (isFirst) { return direction == SortingDirection.Descending ? QueryMethod.OrderByDescending : QueryMethod.OrderBy; } return direction == SortingDirection.Descending ? QueryMethod.ThenByDescending : QueryMethod.ThenBy; }
private static QueryMethod GetQueryMethod(SortingDirection direction, bool isFirst) { if (isFirst) { return(direction == SortingDirection.Descending ? QueryMethod.OrderByDescending : QueryMethod.OrderBy); } return(direction == SortingDirection.Descending ? QueryMethod.ThenByDescending : QueryMethod.ThenBy); }
/// <summary> /// Fired when the Sorting Direction is changed update the indicators state. /// </summary> /// <param name="control"><see cref="GridSortIndicator"/> to update.</param> /// <param name="direction">New <see cref="SortingDirection"/> to set indication to.</param> protected virtual void OnSortingDirectionChanged(GridSortIndicator control, SortingDirection direction) { if (direction == SortingDirection.Asc) { control.uc_Polygon_Asc.Visibility = Visibility.Visible; control.uc_Polygon_Desc.Visibility = Visibility.Collapsed; } else { control.uc_Polygon_Asc.Visibility = Visibility.Collapsed; control.uc_Polygon_Desc.Visibility = Visibility.Visible; } }
private DataTable SortDataByBirthDate(DataTable inputData, SortingDirection direction) { switch (direction) { case SortingDirection.Ascending: return(SortByAscending(inputData, null)); case SortingDirection.Descending: return(SortByDescending(inputData, null)); default: return(inputData); } }
private FiltersWithSorting GetFiltersWithSortingFromJson(JObject json) { var sorting = json["sorting"].ToString(); var name = json["name"].ToString(); var gameDates = json["gameDates"].ToString(); var remainingShips = json["remainingShips"].ToString() == "" ? -1 : json["remainingShips"].ToObject <int>(); var gameTurns = json["gameTurns"].ToString() == "" ? -1 : json["gameTurns"].ToObject <int>(); var sortingItemElements = sorting.Split('/'); var datesItems = gameDates.Split(" - "); SortingDirection sortingDirection = sortingItemElements[0] switch { "desc" => SortingDirection.Descending, "asc" => SortingDirection.Ascending }; SortingType sortingType = sortingItemElements[1] switch { "ship" => SortingType.RemainingShipsSorting, "date" => SortingType.DateSorting }; DateTime firstDate; DateTime secondDate; List <IFilter> filters = new List <IFilter>(); if (DateTime.TryParse(datesItems[0], out firstDate) && DateTime.TryParse(datesItems[1], out secondDate)) { filters.Add(new DateFilter(firstDate, secondDate)); } if (!string.IsNullOrEmpty(name)) { filters.Add(new PlayerFilter(name)); } if (remainingShips != -1) { filters.Add(new RemainingShipFilter(remainingShips)); } if (gameTurns != -1) { filters.Add(new GameTurnFilter(gameTurns)); } return(new FiltersWithSorting() { Filters = filters, Sorting = new SortingItem(sortingType, sortingDirection) }); } } }
// TODO: Proper exception handling private async Task SortTask(SortingDirection dir) { UpdateStatusText($"Sorting by {selectedColumn}..."); try { DBInterface.db.records = await DBInterface.db.SortByAsync(selectedColumn, dir); UpdateStatusText("Ready"); } catch (Exception) { UpdateStatusText("Cannot sort!"); } await UpdateDBGrid(); }
protected virtual void RenderTitleCell( BocColumnRenderingContext <TBocColumnDefinition> renderingContext, SortingDirection sortingDirection, int orderIndex) { ArgumentUtility.CheckNotNull("renderingContext", renderingContext); string cssClassTitleCell = CssClasses.TitleCell; if (!string.IsNullOrEmpty(renderingContext.ColumnDefinition.CssClass)) { cssClassTitleCell += " " + renderingContext.ColumnDefinition.CssClass; } renderingContext.Writer.AddAttribute(HtmlTextWriterAttribute.Class, cssClassTitleCell); if (_renderingFeatures.EnableDiagnosticMetadata) { var columnItemID = renderingContext.ColumnDefinition.ItemID; if (!string.IsNullOrEmpty(columnItemID)) { renderingContext.Writer.AddAttribute(DiagnosticMetadataAttributes.ItemID, columnItemID); } var columnTitle = renderingContext.ColumnDefinition.ColumnTitleDisplayValue; if (!string.IsNullOrEmpty(columnTitle)) { renderingContext.Writer.AddAttribute(DiagnosticMetadataAttributes.Content, HtmlUtility.StripHtmlTags(columnTitle)); } var oneBasedCellIndex = renderingContext.VisibleColumnIndex + 1; renderingContext.Writer.AddAttribute(DiagnosticMetadataAttributesForObjectBinding.BocListCellIndex, oneBasedCellIndex.ToString()); renderingContext.Writer.AddAttribute( DiagnosticMetadataAttributesForObjectBinding.BocListColumnHasDiagnosticMetadata, HasDiagnoticMetadata.ToString().ToLower()); } renderingContext.Writer.RenderBeginTag(HtmlTextWriterTag.Th); RenderTitleCellMarkers(renderingContext); RenderBeginTagTitleCellSortCommand(renderingContext); RenderTitleCellText(renderingContext); if (renderingContext.Control.IsClientSideSortingEnabled || renderingContext.Control.HasSortingKeys) { RenderTitleCellSortingButton(renderingContext, sortingDirection, orderIndex); } RenderEndTagTitleCellSortCommand(renderingContext); renderingContext.Writer.RenderEndTag(); }
private IQueryable <T> ExecuteSorting(IQueryable <T> rows, GridStateModel gridState) { if (gridState.FilterState == null) { return(rows); } SortingDirection sortingDirection = gridState.FilterState.SortingDirection; string sortingColumn = gridState.FilterState.SortingColumn; Type sortingColumnType = gridState.FilterState.SortingPropertyType; if (string.IsNullOrWhiteSpace(sortingColumn) || sortingDirection == SortingDirection.Undefined) { return(rows); } // If the source type is Interface, which inherits another Interface, and the property belongs to this base Interface, // 'Expression' will throw an error. Then, sorting needs to be done by this base Interface type. Type sortingType = this.GetExpressionType(sortingColumn); // If the source type is Interface, and if the property, by which sorting is executing, is not declared on the source type, // but on the Interfaces that this source Interface inherits, than the sorting must be done in the Interface which declares // the property by which sorting is executing object sortingRows = this.CastSourceRowsToTheProperExpressionType(sortingType, rows); ParameterExpression sortingParameter = Expression.Parameter(sortingType, "p"); Expression parameterExpression = Expression.PropertyOrField(sortingParameter, sortingColumn); LambdaExpression sortingExpression = Expression.Lambda(parameterExpression, new[] { sortingParameter }); string sortingMethodName = string.Empty; switch (sortingDirection) { case SortingDirection.Ascending: sortingMethodName = "OrderBy"; break; case SortingDirection.Descending: sortingMethodName = "OrderByDescending"; break; } MethodInfo sortingMethod = typeof(Queryable).GetMethods().Where(m => m.Name.Equals(sortingMethodName)).Where(m => m.GetParameters().Length == 2).Single(); MethodInfo genericSortingMethod = sortingMethod.MakeGenericMethod(new[] { sortingType, parameterExpression.Type }); object sortedRows = genericSortingMethod.Invoke(null, new object[] { rows, sortingExpression }); return(this.CastRowsToTheSourceType(sortingType, sortedRows)); }
public static void Sort(XPBaseCollection collection, string property, SortingDirection direction) { bool isSortingAdded = false; foreach (SortProperty sortProperty in collection.Sorting) { if (sortProperty.Property.Equals(CriteriaOperator.Parse(property))) { isSortingAdded = true; } } if (!isSortingAdded) { collection.Sorting.Add(new SortProperty(property, direction)); } }
internal void ParsesCorrectly(string query, string[] properties, SortingDirection[] directions) { var context = new SortingContext(GetQuery(query)); var expected = properties.Zip(directions, (s, d) => new { Name = s, Direction = d }).ToList(); var actual = context.Properties.Select(p => new { p.Name, p.Direction }).ToList(); Assert.Equal(expected, actual); }
private SortingCollection GetSorting(IEnumerable <GridViewColumnState> sortedColumns, bool isAlwaysSorted) { SortingCollection sorting = new SortingCollection(); foreach (GridViewColumnState sortedColumn in sortedColumns) { SortingDirection sortingDirection = GetSortingDirection(sortedColumn.SortOrder); SortProperty sortProperty = new SortProperty(sortedColumn.FieldName, sortingDirection); sorting.Add(sortProperty); } if (sorting.Count == 0 && isAlwaysSorted) { SortProperty sortProperty = new SortProperty(ClassInfo.KeyProperty.Name, SortingDirection.Ascending); sorting.Add(sortProperty); } return(sorting); }
public ComparisonStep( string propertyName, SortingDirection direction = SortingDirection.Ascending) { this.Property = typeof(Task).GetProperty( propertyName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase); this.Direction = direction; if (this.Property == null) { throw new TaskManException( Messages.CannotSortNoSuchProperty, propertyName); } }
private void IsSorted(int[] sortedInput, SortingDirection sortingDirection) { if (sortingDirection == SortingDirection.Ascending) { for (int i = 0; i < sortedInput.Length - 1; i++) { Assert.LessOrEqual(sortedInput[i], sortedInput[i + 1], "Ascending Sorting is Failed! There is Item in sorted sequence which is more than next one."); } } if (sortingDirection == SortingDirection.Descending) { for (int i = 0; i < sortedInput.Length - 1; i++) { Assert.GreaterOrEqual(sortedInput[i], sortedInput[i + 1], "Descending Sorting is Failed! There is Item in sorted sequence which is less than next one."); } } }
/// <summary> /// Adds sorting to query according to parameters from UI /// </summary> /// <param name="sortField">The sort field.</param> /// <param name="sortDirection">The sort direction.</param> /// <param name="query">The query to change.</param> /// <returns>IQueryable{BonusAggregate}.</returns> public IQueryable<BonusAggregate> BuildQuery(string sortField, SortingDirection sortDirection, IQueryable<BonusAggregate> query) { switch (sortField) { case "EmployeeLastName": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.Employee.LastName) : query.OrderByDescending(x => x.Employee.LastName); break; case "Date": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.Date) : query.OrderByDescending(x => x.Date); break; case "Amount": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.Amount) : query.OrderByDescending(x => x.Amount); break; case "Comment": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.Comment) : query.OrderByDescending(x => x.Comment); break; case "IsActive": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.IsActive) : query.OrderByDescending(x => x.IsActive); break; case "Ulc": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.Ulc) : query.OrderByDescending(x => x.Ulc); break; case "Dlc": query = sortDirection == SortingDirection.Asc ? query.OrderBy(x => x.Dlc) : query.OrderByDescending(x => x.Dlc); break; default: query = query.OrderByDescending(x => x.BonusId); break; } return query; }
private IResourceUrl GetImageUrl(SortingDirection sortingDirection) { // Button Asc -> Button Desc -> No Button switch (sortingDirection) { case SortingDirection.Ascending: return(ResourceUrlFactory.CreateThemedResourceUrl(typeof(BocColumnRendererBase <>), ResourceType.Image, c_sortAscendingIcon)); case SortingDirection.Descending: return(ResourceUrlFactory.CreateThemedResourceUrl(typeof(BocColumnRendererBase <>), ResourceType.Image, c_sortDescendingIcon)); case SortingDirection.None: return(null); default: throw new ArgumentOutOfRangeException("sortingDirection"); } }
public static SortingCollection GetListViewSorting(IModelListView modelListView) { List <SortProperty> sorting = new List <SortProperty>(modelListView.Columns.Count); foreach (IModelColumn column in modelListView.Columns) { if (column.SortOrder != ColumnSortOrder.None && column.SortIndex >= 0) { SortingDirection direction = SortingDirection.Ascending; if (column.SortOrder == ColumnSortOrder.Descending) { direction = SortingDirection.Descending; } sorting.Insert(column.SortIndex, new SortProperty(column.PropertyName, direction)); } } return(new SortingCollection(sorting.ToArray())); }
private SingleChart GetContractEnforcementTimeChart(string id, string countryCode, string yearConfig, SortingDirection sortingDirection) { SingleChart result = null; Dictionary<string, Dictionary<string, List<string>>> config; DatabaseRepository db; IList<GetValuesResult> data; IList<int> years; int requestedCountryId; List<GetIndicatorsInfoResult> indicatorList; List<GetCountriesInfo_Result> countryList; List<GetSupportedIndicatorsResult> supportedIndicatorList; InitChartData(id, countryCode, yearConfig, true, true, false, out db, out data, out years, out requestedCountryId, out indicatorList, out countryList, out supportedIndicatorList, out config); var chartInfo = db.GetChartInfo(id); if (chartInfo != null) { var countries = countryList.ToDictionary(c => c.CountryId); var dataDictionary = data.ToDictionary( d => new Tuple<int, int, int>(d.CountryId, d.IndicatorId, d.Year), d => d.IndicatorValue); var supportedIndicatorIds = supportedIndicatorList.Select(s => s.SupportedIndicatorId).Distinct().ToDictionary(i => i); var cleanedData = data.Where(d => !supportedIndicatorIds.ContainsKey(d.IndicatorId)).ToList(); var categoryIds = new List<int>(); switch (sortingDirection) { case SortingDirection.None: categoryIds = data.Select(d => d.CountryId).Distinct().OrderBy(cId => countries[cId].CountryType).ToList(); break; case SortingDirection.Asc: case SortingDirection.Desc: GetCategoryOrder(requestedCountryId, cleanedData, countries, countryList, sortingDirection == SortingDirection.Desc, out categoryIds); break; } List<string> cats; List<ChartSeries> sers; ConvertToSeries(cleanedData, categoryIds, countryList.ToDictionary(y => y.CountryId, y => y.Name), g => g.Year, SeriesType.Bar, years.ToDictionary(k => k, k => k.ToString()), g => g.CountryId, d => new AdditionalDataPoint { Value = d, AdditionalLabel = null }, out cats, out sers); foreach (var serie in sers) { for (int i = 0; i < serie.Values.Count; i++) { var point = serie.Values[i] as AdditionalDataPoint; decimal? rank; if ( dataDictionary.TryGetValue( new Tuple<int, int, int>(countryList[i].CountryId, supportedIndicatorIds.First().Key, serie.Id), out rank)) { point.AdditionalLabel = String.Format("Rank: {0}", ((int?)Math.Round(rank.Value)).ToStrWithSuffix()); } } } result = years.Count > 0 ? CreateChart(chartInfo, years.First(), years.Last(), cats, sers) : CreateChart(chartInfo); SetStartOrEndValue(result, PointToSet.Min); SetStartOrEndValue(result, PointToSet.Max); } return result; }
//2. Create an overload of method #1 that provides an ascending or descending sorted List<Int32> of all numbers based on an ascending/descending parameter. public List<Int32> GetInts(SortingDirection direction) { var tmpdata = new List<Int32>(mData); tmpdata.Sort(); if (direction == SortingDirection.DESCENDING) tmpdata.Reverse(); return tmpdata; }