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