public PagedResponse <RatingResponse> CreateProductRatingsPaginatedResponse(
int productId,
PaginationFilter pagination,
GetAllRatingsFilter filter,
SortingFilter sorting,
List <RatingResponse> response)
{
var nextPage = pagination.PageNumber >= 1
? uriService.GetProductRatingUri(productId,
new PaginationQuery(pagination.PageNumber + 1, pagination.PageSize),
filter,
sorting)
.ToString()
: null;
var previousPage = pagination.PageNumber - 1 >= 1
? uriService.GetProductRatingUri(productId,
new PaginationQuery(pagination.PageNumber - 1, pagination.PageSize),
filter,
sorting)
.ToString()
: null;
return(CreatePaginatedResponse(pagination, sorting, response, nextPage, previousPage));
}
private static PagedResponse <T> CreatePaginatedResponse <T>(
PaginationFilter pagination,
SortingFilter sortingFilter,
List <T> response,
string nextPage,
string previousPage)
{
return(new PagedResponse <T>
{
Data = response,
Metadata = new Metadata
{
Pagination = new Pagination
{
PageNumber = pagination.PageNumber >= 1
? pagination.PageNumber
: (int?)null,
PageSize = pagination.PageSize >= 1
? pagination.PageSize
: (int?)null,
NextPage = response.Count > 0
? nextPage
: null,
PreviousPage = previousPage
},
SortedBy = SortedBy(sortingFilter)
}
});
}
private string GenerateKey(
GetAllProductsFilter filter,
PaginationFilter pagination,
SortingFilter sortingFilter)
{
return(MyModelCacheKey.GeneratePaginationQuery(pagination)
.GenerateProductFilterQuery(filter)
.GenerateSortingQuery(sortingFilter));
}
public async Task <IActionResult> Search([FromQuery] PaginationFilter paginationFilter, string title, [FromQuery] SortingFilter sortingFilter, [FromQuery] string filterBy)
{
var validPaginationFilter = new PaginationFilter(paginationFilter.PageNumber, paginationFilter.PageSize);
var validSortingFilter = new SortingFilter(sortingFilter.SortField, sortingFilter.Ascending);
var posts = await _postService.SearchAsync(title, validPaginationFilter.PageNumber, validPaginationFilter.PageSize, validSortingFilter.SortField, validSortingFilter.Ascending, filterBy);
return(Ok(new Response <IEnumerable <PostDto> >(posts)));
}
public async Task <IActionResult> GetAll([FromQuery] PaginationFilter paginationFilter, [FromQuery] SortingFilter sortingFilter, [FromQuery] string filterBy = "")
{
var validPaginationFilter = new PaginationFilter(paginationFilter.PageNumber, paginationFilter.PageSize);
var validSortingFilter = new SortingFilter(sortingFilter.SortField, sortingFilter.Ascending);
var posts = await _postService.GetAllPostAsync(validPaginationFilter.PageNumber, validPaginationFilter.PageSize, validSortingFilter.SortField, validSortingFilter.Ascending, filterBy);
var totalRecords = await _postService.GetAllPostsCountAsync(filterBy);
return(Ok(PaginationHelper.CreatePagedResponse(posts, validPaginationFilter, totalRecords)));
}
private static string SortingBuilder(SortingFilter sorting)
{
var sortBuilder = new StringBuilder();
foreach (var sort in sorting.Sortings)
{
sortBuilder.Append($"{sort.Name}+{SortingConstants.DirectionsDictionary[sort.Direction]}");
}
return(sortBuilder.ToString());
}
public async Task <IActionResult> GetAll(int projectId, SortingFilter sortingFilter)
{
if (!IsCurrentUserInProject(projectId))
{
return(Unauthorized());
}
var all = this.mapper.Map <IEnumerable <UserStoryAllViewmodel> >
(await userStoryService.GetAllAsync(projectId, sortingFilter));
return(View(all));
}
public Task <List <Rating> > GetAllAsync(
GetAllRatingsFilter filter,
PaginationFilter pagination,
SortingFilter sortingFilter)
{
IQueryable <Rating> queryable = Context.Ratings;
queryable = FilterProducts(queryable, filter);
queryable = ApplySort(queryable, sortingFilter);
return(queryable.ApplyPagination(pagination).ToListAsync());
}
public Task <List <Product> > GetAllAsync(
GetAllProductsFilter filter,
PaginationFilter pagination,
SortingFilter sortingFilter)
{
IQueryable <Product> queryable = Context.Products.Include(x => x.Ratings);
queryable = FilterProducts(queryable, filter);
queryable = ApplySort(queryable, sortingFilter);
return(queryable.ApplyPagination(pagination).ToListAsync());
}
public Uri GetAllProductsUri(
PaginationQuery pagination,
GetAllProductsFilter filter,
SortingFilter sorting)
{
var uri = new Uri(baseUri + ApiRoutes.Products.GetAll);
var modifiedUri = uri.AbsoluteUri.GeneratePaginationQuery(pagination)
.GenerateProductFilterQuery(filter)
.GenerateSortingQuery(sorting);
return(new Uri(modifiedUri));
}
public Uri GetProductRatingUri(
int productId,
PaginationQuery pagination,
GetAllRatingsFilter filter,
SortingFilter sorting)
{
var uri = new Uri(baseUri
+ ApiRoutes.ProductRatings.GetAll.Replace("{productId}", productId.ToString()));
var modifiedUri = uri.AbsoluteUri.GeneratePaginationQuery(pagination)
.GenerateRatingFilterQuery(filter)
.GenerateSortingQuery(sorting);
return(new Uri(modifiedUri));
}
public Task <List <Product> > GetAllAsync(
GetAllProductsFilter filter,
PaginationFilter pagination,
SortingFilter sortingFilter)
{
var key = GenerateKey(filter, pagination, sortingFilter);
return(cache.GetOrCreate(key,
entry =>
{
entry.SetOptions(cacheOptions);
return productRepository.GetAllAsync(filter, pagination, sortingFilter);
}));
}
public SortingFilterTests()
{
_sortingFilter = new SortingFilter();
_actionContext = new ActionContext
{
HttpContext = new DefaultHttpContext
{
Request =
{
QueryString = new QueryString("?sort=prop1_asc;prop2_dsc")
},
},
RouteData = new RouteData(),
ActionDescriptor = new ControllerActionDescriptor()
};
}
private static IQueryable <UserStory> Sort(SortingFilter sortingFilter, IQueryable <UserStory> query)
{
return(sortingFilter.SortingParams switch
{
UserStorySortingConstants.IdAsc => query.OrderBy(x => x.IdForProject),
UserStorySortingConstants.IdDesc => query.OrderByDescending(x => x.IdForProject),
UserStorySortingConstants.TitleAsc => query.OrderBy(x => x.Title),
UserStorySortingConstants.TitleDesc => query.OrderByDescending(x => x.Title),
UserStorySortingConstants.StoryPointsAsc => query.OrderBy(x => x.StoryPoints),
UserStorySortingConstants.StoryPointsDesc => query.OrderByDescending(x => x.StoryPoints),
UserStorySortingConstants.PriorityAsc => query.OrderBy(x => x.BacklogPriority.Weight),
UserStorySortingConstants.PriorityDesc => query.OrderByDescending(x => x.BacklogPriority.Weight),
UserStorySortingConstants.SprintAsc => query.OrderBy(x => x.Sprint.Name),
UserStorySortingConstants.SprintDesc => query.OrderByDescending(x => x.Sprint.Name),
_ => query,
});
private static List <Sorting> SortedBy(SortingFilter sortingFilter)
{
if (sortingFilter == null)
{
return(null);
}
var sorts = new List <Sorting>();
foreach (var sort in sortingFilter.Sortings)
{
sorts.Add(new Sorting
{
Field = sort.Name,
Order = SortingConstants.DirectionsDictionary[sort.Direction]
});
}
return(sorts);
}
private IQueryable <Rating> ApplySort(IQueryable <Rating> queryable, SortingFilter filter)
{
foreach (var sorting in filter.Sortings)
{
switch (sorting.Name)
{
case "comment":
queryable = queryable.OrderBy(x => x.Comment, sorting.Direction);
break;
case "value":
queryable = queryable.OrderBy(x => x.Value, sorting.Direction);
break;
}
}
return(queryable);
}
public void Check_That_SortFilter_Returns_Right_Sorting_Order_For_MostCommented()
{
// Arrange
var container = new GameFilterContainer
{
Model = new GamesFilterModel
{
SortCondition = SortCondition.MostCommented,
}
};
var filter = new SortingFilter();
IEnumerable <Game> list = GetGamesList();
// Act
filter.Execute(container);
IEnumerable <Game> result = list.OrderBy(x => (container.SortCondition(x)));
// Assert
Assert.IsTrue(result.First().GameLocalizations.First().Name == "game4");
Assert.IsTrue(result.Last().GameLocalizations.First().Name == "game1");
}
public async Task <IEnumerable <Order> > GetOrders(PaginationFilter paginationFilter, SortingFilter sortingFilter, GetAllOrdersFilter filter = null)
{
return(await orderRepository.GetAllFilteredAsync(paginationFilter, sortingFilter, filter));
}
private static IQueryable <Product> ApplySort(IQueryable <Product> queryable, SortingFilter filter)
{
foreach (var sorting in filter.Sortings)
{
switch (sorting.Name)
{
case "description":
queryable = queryable.OrderBy(x => x.Description, sorting.Direction);
break;
case "name":
queryable = queryable.OrderBy(x => x.Name, sorting.Direction);
break;
case "price":
queryable = queryable.OrderBy(x => x.Price, sorting.Direction);
break;
case "averageRating":
queryable = queryable.OrderBy(x => x.Ratings.Sum(r => r.Value), sorting.Direction);
break;
}
}
return(queryable);
}
public async Task <IEnumerable <UserStoryAllDto> > GetAllAsync(int projectId, SortingFilter sortingFilter)
{
var query = this.userStoryRepo.AllAsNoTracking()
.Where(x => x.ProjectId == projectId);
var srotedQuery = Sort(sortingFilter, query);
var sortedWorkItems = await srotedQuery.ProjectTo <UserStoryAllDto>(this.mapper.ConfigurationProvider)
.ToListAsync();
return(sortedWorkItems);
}
public async Task <IEnumerable <Order> > GetAllFilteredAsync(PaginationFilter paginationFilter, SortingFilter sortingFilter, GetAllOrdersFilter filter = null)
{
var query = dbContext.Set <Order>()
.Include(x => x.OrderDetails)
.ThenInclude(x => x.Product)
.AsQueryable();
AddFiltersOnQuery(ref query, filter);
SortingHelper.ApplySort(ref query, sortingFilter.OrderBy);
return(await PaginationHelper <Order> .PagedList(query, paginationFilter.Page));
}
public static string GenerateSortingQuery(this string uri, SortingFilter sorting)
{
return(uri.AddQuery("sort", SortingBuilder(sorting)));
}
