public async Task <ActionResult <Paged <CategoryBuyDto> > > GetPagedCategories( [FromQuery] PagingParams pagingParams, [FromQuery] SortParams sortParams, string filter) { var query = await _repository.GetPagedCategoriesAsync(pagingParams, sortParams, filter); return(new Paged <CategoryBuyDto>(query)); }
private void AddSortParams(string sortQueryParam, int startIndex) { List <char> separators = SeparatorsFromFilterQueryParam(sortQueryParam); char placeFiller = '»'; separators.Insert(0, placeFiller); string[] sortings = sortQueryParam.Substring(startIndex).Split(new char[] { ',', ';' }); for (int i = 0; i < sortings.Count(); i++) { Item sItem; if (sortings[i].Contains("-")) { sItem = new Item(sortings[i], "-" + sortings[i].Substring(4)); } else { sItem = new Item(sortings[i], sortings[i].Substring(3)); } Sort.Add(sItem); SortParams.Add(sItem.Key, sItem.Value); } }
public async Task <ActionResult <IEnumerable <NewYork> > > GetAllDataSort(SortParams sortParams) { ISearchResponse <NewYork> searchResponse; if (sortParams.SortBy == "asc") { searchResponse = await _client.SearchAsync <NewYork>(s => s .From(sortParams.SkipCount) .Size(sortParams.MaxResultCount) .Query(q => q .MatchAll() ) .Sort(s => s.Ascending(sortParams.SortParameter)) ); } else { searchResponse = await _client.SearchAsync <NewYork>(s => s .From(sortParams.SkipCount) .Size(sortParams.MaxResultCount) .Query(q => q .MatchAll() ) .Sort(s => s.Descending(sortParams.SortParameter)) ); } if (searchResponse.IsValid) { return(searchResponse.Documents.ToList()); } return(null); }
public async Task <ActionResult <Paged <ProductRemainDto> > > GetPagedProductRemains( [FromQuery] PagingParams pagingParams, [FromQuery] SortParams sortParams, string filter) { var query = await _repository.GetPagedProductRemainsAsync(pagingParams, sortParams, filter); return(new Paged <ProductRemainDto> (query)); }
public async Task <ActionResult <Paged <SupplierListDto> > > GetPagedSuppliers( [FromQuery] PagingParams pagingParams, [FromQuery] SortParams sortParams, string filter) { var query = await _repository.GetPagedSuppliersAsync(pagingParams, sortParams, filter); return(new Paged <SupplierListDto> (query)); }
public async Task TestGetPageSortedByOneField() { // arrange var dummy1 = await _persistence.CreateAsync(null, _dummy1); var dummy2 = await _persistence.CreateAsync(null, _dummy2); var dummy3 = await _persistence.CreateAsync(null, _dummy3); // keys: Key 1, Key 2, Key 3 var sortParams = new SortParams() { new SortField("key", false) }; // result -> 3 (Key 3), 2 (Key 2), 1 (Key 1) // act var result = await _persistence.GetAsync(null, null, null, sortParams); // assert Assert.NotNull(result); Assert.Equal(3, result.Data.Count); Assert.Equal(dummy3.Key, result.Data[0].Key); Assert.Equal(dummy2.Key, result.Data[1].Key); Assert.Equal(dummy1.Key, result.Data[2].Key); }
public async Task TestGetPageByProjectionAndSortedByMultipleFields() { // arrange var dummy1 = await _persistence.CreateAsync(null, _dummy1); var dummy2 = await _persistence.CreateAsync(null, _dummy2); var dummy3 = await _persistence.CreateAsync(null, _dummy3); // keys: Key 1, Key 2, Key 3 // dummy_type: not_dummy, dummy, dummy var sortParams = new SortParams() { new SortField("dummy_type", false), new SortField("key", false) }; // result -> 1 (not dummy, Key 1), 3 (dummy, Key 3), 2 (dummy, Key 2) var projection = ProjectionParams.FromValues("key"); // act dynamic result = await _persistence.GetAsync(null, null, null, sortParams, projection); // assert Assert.NotNull(result); Assert.Equal(3, result.Data.Count); Assert.Equal(dummy1.Key, result.Data[0].key); Assert.Equal(dummy3.Key, result.Data[1].key); Assert.Equal(dummy2.Key, result.Data[2].key); }
public async Task <ActionResult <Paged <ProductsBySupplierDto> > > GetPagedProductsNotAdded( int supplierId, [FromQuery] PagingParams pagingParams, [FromQuery] SortParams sortParams, string filter) { var query = await _repository.GetPagedProductsNotAddedAsync(supplierId, pagingParams, sortParams, filter); return(new Paged <ProductsBySupplierDto> (query)); }
private void ClickSortColumn(string columnName) { SortInfoItem resultItem = null; foreach (SortInfoItem item in SortParams) { if (item.ColumnName.Equals(columnName)) { resultItem = item; break; } } if (resultItem == null) { SortParams.Insert(0, new SortInfoItem(SortType.Asc, columnName)); } else if (resultItem.ItemSortType == SortType.Asc && SortParams.IndexOf(resultItem) == 0) { resultItem.ItemSortType = SortType.Desc; } else { SortParams.Remove(resultItem); SortParams.Insert(0, new SortInfoItem(SortType.Asc, columnName)); } }
public async Task <PagedList <SupplierDebtDto> > GetPagedSupplierDebtAsync( PagingParams pagingParams, SortParams sortParams, string filter) { var source = _context.Set <Supplier> () .AsNoTracking() .GroupBy(s => new { s.PersonId, SupplierName = s.FirstName + " " + s.LastName, MainPhotoUrl = s.Photos.FirstOrDefault(p => p.IsMain == true).PhotoUrl }, (key, element) => new SupplierDebtDto { SupplierId = key.PersonId, SupplierName = key.SupplierName, MainPhotoUrl = key.MainPhotoUrl, Debt = element.Sum(e => e.Orders.Sum(o => o.ProductOrders.Sum(po => po.Quantity * po.Price * (1 + po.Tax)) - (o.Payments.Count() == 0 ? 0 : o.Payments.Sum(p => p.Amount)))) }) .Where(o => o.Debt > 0); switch (sortParams.SortOrder) { case "asc": switch (sortParams.SortColumn) { case "supplierName": source = source.OrderBy(s => s.SupplierName); break; case "debt": source = source.OrderBy(s => s.Debt); break; } break; case "desc": switch (sortParams.SortColumn) { case "supplierName": source = source.OrderByDescending(s => s.SupplierName); break; case "debt": source = source.OrderByDescending(s => s.Debt); break; } break; default: source = source.OrderBy(s => s.SupplierName); break; } if (!String.IsNullOrEmpty(filter)) { source = source.Where(s => s.SupplierName.ToLower().Contains(filter.ToLower())); } return(await PagedList <SupplierDebtDto> .CreateAsync(source, pagingParams.PageIndex, pagingParams.PageSize)); }
public async Task <DataPage <CustomerV1> > GetCustomersAsync( string correlationId, FilterParams filter, PagingParams paging, SortParams sort) { using (Instrument(correlationId, "customers.get_customers")) { return(await _controller.GetCustomersAsync(correlationId, filter, paging, sort)); } }
public async Task <ActionResult <Paged <OrderSellListDto> > > GetPagedOrders( [FromQuery] PagingParams pagingParams, [FromQuery] SortParams sortParams, [FromQuery] OrderSellQuery query, string filter) { var orders = await _repository.GetPagedOrdersAsync(pagingParams, sortParams, query, filter); return(new Paged <OrderSellListDto>(orders)); }
protected virtual SortDefinition <T> ComposeSort(SortParams sortParams) { sortParams = sortParams ?? new SortParams(); var builder = Builders <T> .Sort; return(builder.Combine(sortParams.Select(field => field.Ascending ? builder.Ascending(field.Name) : builder.Descending(field.Name)))); }
public void TestOptionalSortParams() { var schema = new SortParamsSchema(); var sortParams = new SortParams(new[] { new SortField() }); var results = schema.Validate(sortParams); Assert.Empty(results); }
public void TestNonEmptySortParams() { var schema = new SortParamsSchema(); var sortParams = new SortParams(new [] { new SortField("field1"), new SortField("field2", false) }); var results = schema.Validate(sortParams); Assert.Empty(results); }
public void TestEmptySortParams() { var schema = new SortParamsSchema(); var sortParams = new SortParams(); var results = schema.Validate(sortParams); Assert.Empty(results); }
public async Task <PagedList <ProductsBySupplierDto> > GetPagedProductsAsync( int supplierId, PagingParams pagingParams, SortParams sortParams, string filter) { var source = _context.PersonProducts .AsNoTracking() .Where(pp => pp.PersonId == supplierId) .ProjectToType <ProductsBySupplierDto> (); switch (sortParams.SortOrder) { case "asc": switch (sortParams.SortColumn) { case "productName": source = source.OrderBy(p => p.ProductName); break; case "specification": source = source.OrderBy(p => p.Specification); break; case "categoryName": source = source.OrderBy(p => p.CategoryName); break; } break; case "desc": switch (sortParams.SortColumn) { case "productName": source = source.OrderByDescending(p => p.ProductName); break; case "specification": source = source.OrderByDescending(p => p.Specification); break; case "categoryName": source = source.OrderByDescending(p => p.CategoryName); break; } break; default: source = source.OrderBy(c => c.ProductName); break; } if (!string.IsNullOrEmpty(filter)) { source = source.Where(p => (p.ProductName + p.CategoryName).ToLower().Contains(filter.ToLower())); } return(await PagedList <ProductsBySupplierDto> .CreateAsync(source, pagingParams.PageIndex, pagingParams.PageSize)); }
public void SortByColumn(object sender, RoutedEventArgs routedEventArgs) { var columnHeader = sender as GridViewColumnHeader; if (columnHeader == null) { return; } bool isAsc = true; if (columnHeader.Tag == null) { columnHeader.Tag = 0; } else { columnHeader.Tag = (int)columnHeader.Tag == 1 ? 0 : 1; isAsc = (int)columnHeader.Tag == 1 ? false : true; } var gridViewColumns = columnHeader.Parent as GridViewHeaderRowPresenter; if (gridViewColumns == null) { return; } for (int i = 0; i < gridViewColumns.Columns.Count; i++) { var header = gridViewColumns.Columns[i].Header as GridViewColumnHeader; if (header == null) { continue; } if (header.Content != columnHeader.Content) { header.Tag = null; } else { if (Columns != null && Columns.Count > i && Columns[i] != null) { var sortParam = new SortParams(Columns[i].BoundProperty, isAsc); if (ItemsSource is ISortableCollection) { ((ISortableCollection)ItemsSource).Sort(sortParam); } } } } }
public async Task <PagedList <ProductRemainDto> > GetPagedProductRemainsAsync( PagingParams pagingParams, SortParams sortParams, string filter) { var source = _context.Set <ProductSell> () .AsNoTracking() .ProjectToType <ProductRemainDto> () .Where(p => p.Remain != 0); switch (sortParams.SortOrder) { case "asc": switch (sortParams.SortColumn) { case "productName": source = source.OrderBy(p => p.ProductName); break; case "specification": source = source.OrderBy(p => p.Specification); break; case "remain": source = source.OrderBy(p => p.Remain); break; } break; case "desc": switch (sortParams.SortColumn) { case "productName": source = source.OrderByDescending(p => p.ProductName); break; case "specification": source = source.OrderByDescending(p => p.Specification); break; case "remain": source = source.OrderBy(p => p.Remain); break; } break; default: source = source.OrderBy(c => c.ProductName); break; } if (!string.IsNullOrEmpty(filter)) { source = source.Where(p => p.ProductName.ToLower().Contains(filter.ToLower())); } return(await PagedList <ProductRemainDto> .CreateAsync(source, pagingParams.PageIndex, pagingParams.PageSize)); }
public void GetArtists(SortParams sort, XDataReceived userCallback) { var args = new JObject(); if (sort != null) { args.Add(sort.ToJObject().Children()); } _Client.GetData("AudioLibrary.GetArtists", args, GetArtistsCallback, userCallback); }
public IActionResult Search( [FromQuery] SearchParams searchParams, [FromQuery] PagerParams pagerParams, [FromQuery] SortParams sortParams ) { var userId = _user.GetCurrentUserId(); var result = _noteService.Search(searchParams, sortParams); var count = result.Count(); var notes = result.Select(x => new { x.Id, x.Name, x.Description, x.Price, x.Semester, x.PageCount, x.PreviewUrl, owned = x.AuthorId == userId || x.Buyers.Any(xd => xd.UserId == userId), Author = new { Id = x.AuthorId, Name = x.Author.UserName }, Course = new { Id = x.CourseId, x.Course.Name }, University = new { Id = x.Course.UniversityId, x.Course.University.Name }, Voivodeship = new { Id = x.Course.University.VoivodeshipId, x.Course.University.Voivodeship.Name } }); return(Ok(new { Pager = new PagerResult { Size = pagerParams.Size, Page = pagerParams.Page, Count = count, Pages = (int)Math.Ceiling(count / (float)pagerParams.Size) }, Notes = notes .Skip((pagerParams.Page - 1) * pagerParams.Size) .Take(pagerParams.Size) })); }
public static SortParams GetSortParams(HttpRequest request) { var sort = new SortParams(); var parser = FilterParams.FromString(ExtractFromQuery("sort", request)); foreach (var sortParam in parser) { sort.Add(new SortField(sortParam.Key, Convert.ToBoolean(sortParam.Value))); } return(sort); }
public void GetSongsByAlbum(int albumId, SortParams sort, XDataReceived userCallback, Action <List <Song> > actionCallback) { var args = new JObject { new JProperty("albumid", albumId), new JProperty("fields", _AllSongFields) }; if (sort != null) { args.Add(sort.ToJObject().Children()); } _Client.GetData("AudioLibrary.GetSongs", args, GetSongsCallback, userCallback); }
public void GetAlbums(SortParams sort, XDataReceived userCallback) { var args = new JObject(); args.Add(new JProperty("fields", _AllAlbumFields)); if (sort != null) { args.Add(sort.ToJObject().Children()); } _Client.GetData("AudioLibrary.GetAlbums", args, GetAlbumsCallback, userCallback); }
public void GetAlbumsByArtist(int artistId, SortParams sort, XDataReceived userCallback) { var args = new JObject { new JProperty("artistid", artistId), new JProperty("fields", _AllAlbumFields) }; if (sort != null) { args.Add(sort.ToJObject().Children()); } _Client.GetData("AudioLibrary.GetAlbums", args, GetAlbumsCallback, userCallback); }
public void GetSeasons(int tvShowId, SortParams sort, XDataReceived userCallback) { var args = new JObject { new JProperty("tvshowid", tvShowId), new JProperty("fields", _AllSeasonFields) }; if (sort != null) { args.Add(sort.ToJObject().Children()); } _Client.GetData("VideoLibrary.GetSeasons", args, GetSeasonsCallback, userCallback); }
public void GetTvShows(SortParams sort, XDataReceived userCallback) { var args = new JObject { new JProperty("fields", _AllTvShowFields) }; if (sort != null) { args.Add(sort.ToJObject().Children()); } _Client.GetData("VideoLibrary.GetTvShows", args, GetTvShowsCallback, userCallback); }
public async Task <IActionResult> TestData([FromQuery] List <string> sort) { await _context.Database.EnsureCreatedAsync(); var query = _context.People.AsQueryable(); var sortParams = new SortParams(); sortParams.SortProperties.AddRange(sort); var processed = _processor.ApplySorting(query, sortParams); return(Ok(await processed.ToListAsync())); }
public void It_Should_Create_Sort_Params_From_Array_Of_Sort_Fields() { var parameters = SortParams.FromValue(new List <object> { new SortField("field1"), new SortField("field2", false), new SortField("field3", false) }); Assert.Equal(3, parameters.Count); Assert.Equal("field1", parameters[0].Name); Assert.Equal("field2", parameters[1].Name); Assert.Equal("field3", parameters[2].Name); }
private ICommand MakeGetContractsCommand() { return(new Command( "get_contracts", new ObjectSchema() .WithOptionalProperty("filter", new FilterParamsSchema()) .WithOptionalProperty("paging", new PagingParamsSchema()) .WithOptionalProperty("sort", new SortParamsSchema()), async(correlationId, parameters) => { var filter = FilterParams.FromValue(parameters.Get("filter")); var paging = PagingParams.FromValue(parameters.Get("paging")); var sort = SortParams.FromValue(parameters.Get("sort")); return await _controller.GetContractsAsync(correlationId, filter, paging, sort); })); }