public async Task <IActionResult> GetProducts([FromQuery] ProductFilterParameters query)
{
IQueryable <Product> products = this.context.Products;
if (query.MaxPrice != null && query.MinPrice != null)
{
products = products.Where(p => p.Price >= query.MinPrice && p.Price <= query.MaxPrice);
}
if (!string.IsNullOrEmpty(query.Sku))
{
products = products.Where(p => p.Sku.Equals(query.Sku));
}
if (!string.IsNullOrEmpty(query.Name))
{
products = products.Where(p => p.Name.ToLower().Contains(query.Name.ToLower()));
}
if (!string.IsNullOrEmpty(query.SortBy))
{
if (typeof(Product).GetProperty(query.SortBy) != null)
{
products = products.OrderByCustom(query.SortBy, query.SortOrder);
}
}
products = products.Skip(query.Size * (query.Page - 1))
.Take(query.Size);
return(Ok(await products.ToArrayAsync()));
}
public async Task <HttpResponseMessage> GetProducts([FromUri] ResourceParameters resourceParameters,
[FromUri] ProductFilterParameters filterParameters)
{
filterParameters = filterParameters ?? new ProductFilterParameters();
resourceParameters = resourceParameters ?? new ResourceParameters();
if (
!_propertyMappingService.ValidMappingExistsFor <ProductEntity, Data.Sqlite.Models.ProductModel>(
resourceParameters.OrderBy))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ExceptionMessageModelFactory.BadRequstOrderByParameters()));
}
if (!_typeHelper.TypeHasProperties <ProductForGetModel>(resourceParameters.Fields))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ExceptionMessageModelFactory.BadRequstFieldsParameters()));
}
var products = await _productRepository.GetProducts(resourceParameters, filterParameters);
// UrlHelper requires the Request to get
var pagedListHelper = new PagedListHelper(new UrlHelper(Request));
var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products);
var response = Request.CreateResponse(HttpStatusCode.OK, modelResults.ShapeData(resourceParameters.Fields));
response.Headers.Add("X-Pagination",
pagedListHelper.AddPaginationMetadataToResponseHeader(products, resourceParameters, filterParameters,
"GetProducts"));
return(response);
}
public async Task <IActionResult> GetProducts(ResourceParameters resourceParameters,
ProductFilterParameters filterParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <ProductEntity, Data.Sqlite.Models.ProductModel>(resourceParameters.OrderBy))
{
return(BadRequest(ExceptionMessageModelFactory.BadRequstOrderByParameters()));
}
if (!_typeHelper.TypeHasProperties <ProductForGetModel>(resourceParameters.Fields))
{
return(BadRequest(ExceptionMessageModelFactory.BadRequstFieldsParameters()));
}
var products = await _productRepository.GetProducts(resourceParameters, filterParameters);
AddHeaders();
var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products);
return(Ok(modelResults.ShapeData(resourceParameters.Fields)));
// Local method to get create headers. Is this overkill? Probably.
void AddHeaders() => Response.Headers.Add("X-Pagination",
_pagedListHelper.AddPaginationMetadataToResponseHeader(products, resourceParameters, filterParameters,
"GetProducts"));
}
/// <summary>
/// Uses EF instead of Dapper so we can use IQueryable and only query the database once.
/// </summary>
/// <param name="resourceParameters"></param>
/// <param name="filterParameters"></param>
/// <returns></returns>
public Task <PagedList <ProductEntity> > GetProducts(ResourceParameters resourceParameters, ProductFilterParameters filterParameters)
{
using (var context = new WebApiPatternContext(_setting.ConnectionString))
{
// Sort
var queryable =
context.Products.ApplySort(resourceParameters.OrderBy,
_propertyMappingService.GetPropertyMapping <ProductEntity, ProductModel>());
// Filter
if (!string.IsNullOrEmpty(filterParameters.ProductType))
{
var query = filterParameters.ProductType.Trim().ToLowerInvariant();
queryable = queryable.Where(p => p.ProductType != null && p.ProductType.ToLowerInvariant() == query);
}
// Search
if (!string.IsNullOrEmpty(resourceParameters.SearchQuery))
{
var query = resourceParameters.SearchQuery.Trim().ToLowerInvariant();
queryable = queryable.Where(p =>
p.Name.ToLowerInvariant().Contains(query) ||
p.Vendor.ToLowerInvariant().Contains(query) ||
(p.Description != null && p.Description.ToLowerInvariant().Contains(query))
);
}
// Page
var count = queryable.Count();
var models =
queryable.Skip((resourceParameters.PageNumber - 1) * resourceParameters.PageSize)
.Take(resourceParameters.PageSize)
.ToList();
var entities = _mapper.Map <IEnumerable <ProductEntity> >(models).ToList();
return(Task.FromResult(new PagedList <ProductEntity>(entities, count, resourceParameters.PageNumber,
resourceParameters.PageSize)));
}
}
