public async Task <IActionResult> GetAll([FromQuery] PageArguments pageArgs,
[FromQuery] SortingArguments sortingArgs, [FromQuery] FilterArguments filterArgs)
{
var languages = await _mediator.Send(new GetLanguagesQuery(pageArgs, sortingArgs, filterArgs));
return(Ok(languages));
}
public IEnumerable <LinkModel> DecorateResponse(PageData pageData, SortingArguments sortArgs, FilterArguments filterArgs, PathString path)
{
Response.Headers.Add(Constants.XPagination, JsonSerializer.Serialize(pageData,
new JsonSerializerOptions {
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var links = LinksCreator.CreateLinksForCountries(pageData, sortArgs, filterArgs, path, _processor);
return(links);
}
public async Task <IActionResult> GetAll([FromQuery] AnnoucementFilterArguments filterArgs,
[FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs)
{
PageDataContainer <AnnoucementDto> pagedAnnoucementDtos = await _annoucementService.GetAnnoucements(filterArgs, pageArgs, sortingArgs);
if (pagedAnnoucementDtos == null)
{
return(NoContent());
}
PageDataContainer <AnnoucementWebModel> pagedWebAnnoucements = _mapper.Map <PageDataContainer <AnnoucementWebModel> >(pagedAnnoucementDtos);
return(Ok(pagedWebAnnoucements));
}
public async Task <IActionResult> Get([FromQuery] BrandFilterArguments filterArgs,
[FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs)
{
PageDataContainer <BrandDto> pagedBrandDtos = await _brandService.GetAllBrands(filterArgs, pageArgs, sortingArgs);
if (pagedBrandDtos == null)
{
return(NoContent());
}
PageDataContainer <BrandWebModel> pagedBrandModels = _mapper.Map <PageDataContainer <BrandWebModel> >(pagedBrandDtos);
return(Ok(pagedBrandModels));
}
public async Task <ActionResult <IEnumerable <CountryModel> > > GetCountries([FromQuery] PageArguments pageArgs,
[FromQuery] SortingArguments sortingArgs, [FromQuery] FilterArguments filterArgs,
[FromHeader(Name = ApiConstants.AcceptHeader)] string mediaType)
{
if (!MediaTypeHeaderValue.TryParse(mediaType, out var parsedMediaType))
{
return(BadRequest());
}
var pagedCountries = await _mediator.Send(new GetCountriesQuery(pageArgs, sortingArgs, new List <FilterArguments> {
filterArgs
}));
var links = DecorateResponse(pagedCountries.PageData, sortingArgs, filterArgs, Request.Path);
return(parsedMediaType.MediaType.Contains(ApiConstants.HateoasKeyword) ?
Ok(new { pagedCountries.Items, links }) : Ok(pagedCountries.Items));
}
public async Task <ActionResult <IEnumerable <CountryModel> > > GetCountriesByCurrency(string currency,
[FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs,
[FromHeader(Name = ApiConstants.AcceptHeader)] string mediaType)
{
var pagedCountries = await _mediator.Send(new GetCountriesQuery(pageArgs, sortingArgs, new List <FilterArguments>
{
new FilterArguments {
FilterProperty = "Currency.Code", FilterValues = new string[] { currency }
}
}));
return(Ok(pagedCountries.Items));
}
public static IEnumerable <LinkModel> CreateLinksForCountries(PageData pageData, SortingArguments sortArgs,
FilterArguments filter, string path, ILinkProcessor processor)
{
var links = new List <LinkModel>();
if (pageData.HasPrevPage)
{
links.Add(new LinkModel
{
Href = processor.ProcessLinksForCollection(new ResourceParameters
{
PageArgs = new PageArguments
{
PageIndex = pageData.PageIndex,
PageSize = pageData.PageSize
},
SortArgs = sortArgs,
FilterArgs = filter,
Path = path,
LinkType = LinkType.Previous
}),
Method = "GET",
Rel = "prev_page"
});
}
if (pageData.HasNextPage)
{
links.Add(new LinkModel
{
Href = processor.ProcessLinksForCollection(new ResourceParameters
{
PageArgs = new PageArguments
{
PageIndex = pageData.PageIndex,
PageSize = pageData.PageSize
},
SortArgs = sortArgs,
FilterArgs = filter,
Path = path,
LinkType = LinkType.Next
}),
Method = "GET",
Rel = "prev_page"
});
}
links.Add(new LinkModel
{
Href = processor.ProcessLinksForCollection(new ResourceParameters
{
PageArgs = new PageArguments
{
PageIndex = pageData.PageIndex,
PageSize = pageData.PageSize
},
SortArgs = sortArgs,
FilterArgs = filter,
Path = path,
LinkType = LinkType.Current
}),
Method = "GET",
Rel = "self"
});
return(links);
}
public static async Task <PagedResponse <TEntity> > CreatePaginatedResponse <TEntity>(this IQueryable <TEntity> source, PageArguments pageArgs,
SortingArguments sortArgs, List <FilterArguments> filterArgs, LogicalOperator logicalOperator) where TEntity : class
{
source = source.ApplyFilters(filterArgs, logicalOperator);
var total = await source.CountAsync();
source = source.ApplyPagination(pageArgs.PageIndex, pageArgs.PageSize);
source = source.ApplySort(sortArgs.OrderBy, sortArgs.Direction);
var listResult = await source.ToListAsync();
return(new PagedResponse <TEntity>
{
PageData = new PageData
{
PageIndex = pageArgs.PageIndex,
PageSize = pageArgs.PageSize,
TotalItems = total
},
Items = listResult
});
}
public async Task <PageDataContainer <BrandDto> > GetPagedBrands(BrandFilterArguments filterOptions, SortingArguments sortingArguments, PageArguments pageArguments)
{
var filters = new List <Expression <Func <Brand, bool> > >()
{
brand => brand.Title.Contains(filterOptions.Title ?? ""),
};
var includes = new string[] { "BrandCategories.Category" };
var orderParameters = new List <OrderParams <Brand> >()
{
new OrderParams <Brand> {
OrderBy = (x) => x.Title,
Descending = (sortingArguments.Direction == "desc")
}
};
IOrderedQueryable <Brand> query = GetAllForPaging(includes, filters, orderParameters);
PageDataContainer <Brand> pagedBrands = await query.GetPageAsync(pageArguments);
return(_mapper.Map <PageDataContainer <BrandDto> >(pagedBrands));
}
public GetCountriesQuery(PageArguments pageArgs, SortingArguments sortingArgs, List <FilterArguments> filterArgs)
{
PageArgs = pageArgs;
SortingArgs = sortingArgs;
FilterArgs = filterArgs;
}
public async Task <PageDataContainer <AnnoucementDto> > GetPagedAnnoucements(AnnoucementFilterArguments filterOptions,
PageArguments paginateParams, SortingArguments orderParams)
{
_dataSet = _context.Annoucements;
IQueryable <Annoucement> annoucements = IncludeProperties(_dataSet);
IQueryable <Annoucement> filteredAnnoucements = ApplySeachQuery(annoucements, filterOptions);
IOrderedQueryable <Annoucement> orderedAnnoucements = OrderAnnoucements(filteredAnnoucements, orderParams);
var pagedAnnoucements = await orderedAnnoucements.GetPageAsync(paginateParams);
return(_mapper.Map <PageDataContainer <AnnoucementDto> >(pagedAnnoucements));
}
private static IOrderedQueryable <Annoucement> OrderAnnoucements(IQueryable <Annoucement> annoucements, SortingArguments orderParams)
{
IOrderedQueryable <Annoucement> orderedAnnoucements;
if (orderParams.Direction == "desc")
{
switch (orderParams.OrderBy?.ToLower())
{
case "title": orderedAnnoucements = annoucements.OrderByDescending(x => x.Title); break;
case "price": orderedAnnoucements = annoucements.OrderByDescending(x => x.Price); break;
case "date": orderedAnnoucements = annoucements.OrderByDescending(x => x.CreateDate); break;
default: orderedAnnoucements = annoucements.OrderByDescending(x => x.CreateDate); break;
}
}
else
{
switch (orderParams.OrderBy?.ToLower())
{
case "title": orderedAnnoucements = annoucements.OrderBy(x => x.Title); break;
case "price": orderedAnnoucements = annoucements.OrderBy(x => x.Price); break;
case "date": orderedAnnoucements = annoucements.OrderBy(x => x.CreateDate); break;
default: orderedAnnoucements = annoucements.OrderBy(x => x.CreateDate); break;
}
}
return(orderedAnnoucements);
}
public async Task <PageDataContainer <BrandDto> > GetAllBrands(BrandFilterArguments filterArguments,
PageArguments pageArguments, SortingArguments sortingArguments)
{
PageDataContainer <BrandDto> pagedBrands = await _brandRepo.GetPagedBrands(filterArguments, sortingArguments, pageArguments);
if (pagedBrands.PageData.Count > 0)
{
return(pagedBrands);
}
return(null);
}
public async Task <PagedResponse <TEntity> > GetAllAsync <TEntity>(PageArguments pageArgs, SortingArguments sortingArgs,
List <FilterArguments> filterArgs, LogicalOperator logicalOperator) where TEntity : BaseEntity
{
try
{
return(await _ctx.Set <TEntity>().CreatePaginatedResponse(pageArgs, sortingArgs, filterArgs, logicalOperator));
}
catch (Exception e)
{
throw new BadRequestException("Some of the query params are invalid.", e);
}
}
public async Task <ActionResult <IEnumerable <CountryModel> > > GetCountriesByAlphaCodes([FromQuery] string codes,
[FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs)
{
var filterArgs = new List <FilterArguments>
{
new FilterArguments {
FilterProperty = nameof(Country.Alpha2Code), FilterValues = codes.Split(';')
},
new FilterArguments {
FilterProperty = nameof(Country.Alpha3Code), FilterValues = codes.Split(';')
}
};
var pagedCountries = await _mediator.Send(new GetCountriesQuery(pageArgs, sortingArgs, filterArgs));
return(Ok(pagedCountries.Items));
}
public async Task <ActionResult <CountryModel> > GetCountryByAlphaCode(string code,
[FromQuery] PageArguments pageArgs, [FromQuery] SortingArguments sortingArgs)
{
Expression <Func <Country, bool> > expression = c => c.Alpha2Code == code || c.Alpha3Code == code;
var predicates = new List <Expression <Func <Country, bool> > >();
predicates.Add(expression);
var country = await _mediator.Send(new GetCountriesWithPredicateQuery(predicates));
return(Ok(country));
}
public async Task <PageDataContainer <AnnoucementDto> > GetAnnoucements(AnnoucementFilterArguments filterOptions,
PageArguments paginateParams, SortingArguments orderParams)
{
PageDataContainer <AnnoucementDto> pagedAnnoucements = await _annoucementRepo.GetPagedAnnoucements(filterOptions, paginateParams, orderParams);
if (pagedAnnoucements.PageData.Count == 0)
{
return(null);
}
return(pagedAnnoucements);
}
