public async Task <IEnumerable <Product> > GetProductsAsync(ProductResourceParameters productResourcParameters)
{
if (productResourcParameters == null)
{
return(await GetProductsAsync());
}
if (string.IsNullOrWhiteSpace(productResourcParameters.ProductName) &&
string.IsNullOrWhiteSpace(productResourcParameters.SearchQuery))
{
return(await GetProductsAsync());
}
var collection = _dbContext.Products as IQueryable <Product>;
if (!string.IsNullOrWhiteSpace(productResourcParameters.ProductName))
{
var productName = productResourcParameters.ProductName.Trim();
collection = collection.Where(p => p.Deleted == null && p.ProductName.Contains(productName));
}
if (!string.IsNullOrWhiteSpace(productResourcParameters.SearchQuery))
{
var searchQuery = productResourcParameters.SearchQuery.Trim();
collection = collection.Where(p => p.ProductName.Contains(searchQuery) ||
p.ProductDescription.Contains(searchQuery));
}
return(await collection.ToListAsync());
}
private IEnumerable <LinkDTO> CreateLinksForProducts(ProductResourceParameters productResourceParameters,
bool hasNext, bool hasPrevious)
{
var links = new List <LinkDTO>();
// self
links.Add(
new LinkDTO(CreateProductResourceUri(productResourceParameters,
ResourceUriType.Current)
, "self", "GET"));
if (hasNext)
{
links.Add(
new LinkDTO(CreateProductResourceUri(productResourceParameters,
ResourceUriType.NextPage),
"nextPage", "GET"));
}
if (hasPrevious)
{
links.Add(
new LinkDTO(CreateProductResourceUri(productResourceParameters,
ResourceUriType.PreviousPage),
"previousPage", "GET"));
}
return(links);
}
public async Task <ICollection <Product> > GetProducts(ProductResourceParameters productResourceParameters)
{
if (productResourceParameters == null)
{
throw new ArgumentNullException(nameof(productResourceParameters));
}
var collection = _productContext.Products as IQueryable <Product>; /* http://www.macoratti.net/14/11/net_ieiq1.htm =>
* basicamente executa o select com todos os filtros*/
if (!string.IsNullOrEmpty(productResourceParameters.SearchQuery))
{
var searchQuery = productResourceParameters.SearchQuery.Trim().ToLower();
collection = collection.Where(p => EF.Functions.Like(p.Name.ToLower(), $"%{searchQuery}%"));
}
if (!string.IsNullOrEmpty(productResourceParameters.Quantity))
{
int quantity;
try
{
quantity = int.Parse(productResourceParameters.Quantity.Trim());
collection = collection.Where(p => p.Quantity < quantity);
}
catch (FormatException formatException)
{
throw formatException;
}
}
return(await collection.ToListAsync());
}
private IEnumerable <LinkResource> CreateLinksForProducts(ProductResourceParameters productResourceParameters,
bool hasPrevious, bool hasNext)
{
var links = new List <LinkResource>
{
new LinkResource(
CreateProductUri(productResourceParameters, PaginationResourceUriType.CurrentPage),
"self", "GET")
};
if (hasPrevious)
{
links.Add(
new LinkResource(
CreateProductUri(productResourceParameters, PaginationResourceUriType.PreviousPage),
"previous_page", "GET"));
}
if (hasNext)
{
links.Add(
new LinkResource(
CreateProductUri(productResourceParameters, PaginationResourceUriType.NextPage),
"next_page", "GET"));
}
return(links);
}
public async Task <ActionResult <IEnumerable <ProductDto> > > GetProducts(
[FromServices] IProductRepository productRepository,
[FromServices] IMapper mapper,
[FromQuery] ProductResourceParameters productResourceParameters)
{
var productEntities = await productRepository.GetProducts(productResourceParameters);
var products = mapper.Map <ICollection <ProductDto> >(productEntities);
return(Ok(products));
}
public async Task <IActionResult> GetProducts([FromQuery] ProductResourceParameters parameters)
{
var productsFromRepo = await _productRepository.GetProductsAsync(parameters.Keyword);
if (productsFromRepo == null || productsFromRepo.Count() <= 0)
{
return(NotFound("No Products"));
}
var productsDto = _mapper.Map <IEnumerable <ProductDto> >(productsFromRepo);
return(Ok(productsDto));
}
public async Task <ActionResult <IEnumerable <ProductDto> > > GetProducts([FromQuery] ProductResourceParameters productResourcParameters)
{
var products = await _productService.GetProductsAsync(productResourcParameters);
if (products.Count() == 0)
{
return(NotFound());
}
var productDtos = _mapper.Map <IEnumerable <ProductDto> >(products);
return(Ok(productDtos));
}
public async Task <PaginatedList <Product> > GetProductsAsync(ProductResourceParameters parameters)
{
var query = _myContext.Products.AsQueryable();
if (!string.IsNullOrEmpty(parameters.Name))
{
var name = parameters.Name.Trim().ToLowerInvariant();
query = query.Where(x => x.Name.ToLowerInvariant() == name);
}
query = query.ApplySort(parameters.OrderBy, _propertyMappingContainer.Resolve <ProductResource, Product>());
var count = await query.CountAsync();
var items = await query
.Skip(parameters.PageSize *parameters.PageIndex)
.Take(parameters.PageSize).ToListAsync();
return(new PaginatedList <Product>(parameters.PageIndex, parameters.PageSize, count, items));
}
public PagedList <Product> GetAllProducts(ProductResourceParameters productResourceParameters)
{
var collectionBeforePaging =
_context.Products.ApplySort(productResourceParameters.OrderBy,
_productPropertyMappingService.GetPropertyMapping <ProductDTO, Product>());
if (!string.IsNullOrEmpty(productResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = productResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(s => s.Name.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(PagedList <Product> .Create(collectionBeforePaging,
productResourceParameters.PageNumber,
productResourceParameters.PageSize));
}
private string CreateProductResourceUri(
ProductResourceParameters productResourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link("GetProducts",
new
{
fields = productResourceParameters.Fields,
orderBy = productResourceParameters.OrderBy,
searchQuery = productResourceParameters.SearchQuery,
pageNumber = productResourceParameters.PageNumber - 1,
pageSize = productResourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(_urlHelper.Link("GetProducts",
new
{
fields = productResourceParameters.Fields,
orderBy = productResourceParameters.OrderBy,
searchQuery = productResourceParameters.SearchQuery,
pageNumber = productResourceParameters.PageNumber + 1,
pageSize = productResourceParameters.PageSize
}));
default:
return(_urlHelper.Link("GetProducts",
new
{
fields = productResourceParameters.Fields,
orderBy = productResourceParameters.OrderBy,
searchQuery = productResourceParameters.SearchQuery,
pageNumber = productResourceParameters.PageNumber,
pageSize = productResourceParameters.PageSize
}));
}
}
public async Task <ActionResult <LinkedCollectionResourceWrapperDto <ProductDetailDto> > > GetProductsByDetail(
[FromQuery] ProductResourceParameters productResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <ProductDetailDto>
(productResourceParameters.OrderBy))
{
return(BadRequest());
}
var query = new ProductsDetailQuery(
productResourceParameters.OrderBy,
productResourceParameters.SearchTerm,
productResourceParameters.Active,
productResourceParameters.PageNumber,
productResourceParameters.PageSize);
_logger.LogInformation(
"----- Sending query: ProductsDetailQuery");
var queryResult = await _mediator.Send(query);
if (queryResult == null)
{
return(BadRequest("Query not created"));
}
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = queryResult.RecordCount,
pageSize = productResourceParameters.PageSize,
currentPage = productResourceParameters.PageNumber,
totalPages = queryResult.PageCount
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
return(Ok(queryResult));
}
// GET: /<controller>/
public async Task <IActionResult> List(ProductResourceParameters RP)
{
IEnumerable <Product> products;
string title;
if (!string.IsNullOrEmpty(RP.Category))
{
products = await _productRepository.Search(RP.Category, RP.Brand, RP.SearchQuery);
var category = await _categoryRepository.GetCategoryByName(RP.Category);
title = category.Name;
}
//else if (!string.IsNullOrEmpty(RP.Brand))
//{
// products =await _productRepository.Search(RP.Category, RP.Brand, RP.SearchQuery);
// var brand=await _brandRepository.GetBrandByName(RP.Brand);
// title = brand.BrandName;
//}
else if (!string.IsNullOrEmpty(RP.SearchQuery))
{
products = await _productRepository.Search(RP.Category, RP.Brand, RP.SearchQuery);
title = RP.SearchQuery;
}
else
{
products = _productRepository.AllProduct.OrderBy(p => p.Id);
title = "All Products";
}
var productsListViewModel = new ProductsListViewModel
{
Products = products,
CurrentCategory = title
};
return(View(productsListViewModel));
}
public IEnumerable <Product> GetProduct(ProductResourceParameters productResourceParameters)
{
if (productResourceParameters == null)
{
throw new ArgumentNullException(nameof(productResourceParameters));
}
if (string.IsNullOrWhiteSpace(productResourceParameters.SearchQuery))
{
return(GetProducts());
}
var collection = unitOfWork.ProductRepository.Get(includeProperties: "ImageLines,DescriptionLines").AsQueryable();
if (!string.IsNullOrWhiteSpace(productResourceParameters.SearchQuery))
{
var searchQuery = productResourceParameters.SearchQuery.Trim();
collection = collection.Where(p => p.Name.Contains(searchQuery, StringComparison.OrdinalIgnoreCase));
}
return(collection.Include("ImageLines,DescriptionLines").ToList());
}
private string CreateProductUri(ProductResourceParameters parameters, PaginationResourceUriType uriType)
{
switch (uriType)
{
case PaginationResourceUriType.PreviousPage:
var previousParameters = new
{
pageIndex = parameters.PageIndex - 1,
pageSize = parameters.PageSize,
orderBy = parameters.OrderBy,
fields = parameters.Fields,
name = parameters.Name
};
return(_urlHelper.Link("GetProducts", previousParameters));
case PaginationResourceUriType.NextPage:
var nextParameters = new
{
pageIndex = parameters.PageIndex + 1,
pageSize = parameters.PageSize,
orderBy = parameters.OrderBy,
fields = parameters.Fields,
name = parameters.Name
};
return(_urlHelper.Link("GetProducts", nextParameters));
default:
var currentParameters = new
{
pageIndex = parameters.PageIndex,
pageSize = parameters.PageSize,
orderBy = parameters.OrderBy,
fields = parameters.Fields,
name = parameters.Name
};
return(_urlHelper.Link("GetProducts", currentParameters));
}
}
// GET: /<controller>/
public IActionResult List(ProductResourceParameters RP)
{
IEnumerable <Products> products;
string title;
if (!string.IsNullOrEmpty(RP.Category))
{
products = _productRepository.GetProducts(RP.Category, RP.Brand, RP.SearchQuery);
title = _categoryRepository.AllCategories
.FirstOrDefault(c => c.Cat_Name == RP.Category)?.Cat_Name;
}
else if (!string.IsNullOrEmpty(RP.Brand))
{
products = _productRepository.GetProducts(RP.Category, RP.Brand, RP.SearchQuery);
title = _brandRepository.AllBrands
.FirstOrDefault(c => c.Brand_Name == RP.Brand)?.Brand_Name;
}
else if (!string.IsNullOrEmpty(RP.SearchQuery))
{
products = _productRepository.GetProducts(RP.Category, RP.Brand, RP.SearchQuery);
title = RP.SearchQuery;
}
else
{
products = _productRepository.AllProducts.OrderBy(p => p.Product_Id);
title = "All Products";
}
var productsListViewModel = new ProductsListViewModel
{
Products = products,
CurrentCategory = title
};
return(View(productsListViewModel));
}
public PagedList <Product> GetAllProductsFromSupermarket(int supermarketId, ProductResourceParameters productResourceParameters)
{
var allStockWithSupermarketId = _context.SupermarketStocks
.Where(s => s.SupermarketId == supermarketId)
.ToList();
// make a list of ints containing all productIds
var intList = new List <int>();
foreach (SupermarketStock ss in allStockWithSupermarketId)
{
intList.Add(ss.ProductId);
}
var productsFromRepo = _context.Products
.Where(p => intList.Contains(p.ProductId));
var collectionBeforePaging =
productsFromRepo.ApplySort(productResourceParameters.OrderBy,
_productPropertyMappingService.GetPropertyMapping <ProductDTO, Product>());
if (!string.IsNullOrEmpty(productResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = productResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(s => s.Name.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(PagedList <Product> .Create(collectionBeforePaging,
productResourceParameters.PageNumber,
productResourceParameters.PageSize));
}
public ActionResult <IEnumerable <ProductDto> > GetProduct([FromQuery] ProductResourceParameters productResourceParameters)
{
var product = productService.GetProduct(productResourceParameters);
return(Ok(mapper.Map <IEnumerable <ProductDto> >(product)));
}
public async Task <IActionResult> GetProducts(ProductResourceParameters productResourceParameters,
[FromHeader(Name = "Accept")] string mediaType)
{
if (!_propertyMappingContainer.ValidateMappingExistsFor <ProductResource, Product>(productResourceParameters.OrderBy))
{
return(BadRequest("Can't find the fields for sorting."));
}
if (!_typeHelperService.TypeHasProperties <ProductResource>(productResourceParameters.Fields))
{
return(BadRequest("Can't find the fields on Resource."));
}
var pagedList = await _productRepository.GetProductsAsync(productResourceParameters);
var productResources = _mapper.Map <List <ProductResource> >(pagedList);
if (mediaType == "application/vnd.solenovex.hateoas+json")
{
var meta = new
{
pagedList.TotalItemsCount,
pagedList.PaginationBase.PageSize,
pagedList.PaginationBase.PageIndex,
pagedList.PageCount
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
var links = CreateLinksForProducts(productResourceParameters, pagedList.HasPrevious, pagedList.HasNext);
var shapedResources = productResources.ToDynamicIEnumerable(productResourceParameters.Fields);
var shapedResourcesWithLinks = shapedResources.Select(product =>
{
var productDict = product as IDictionary <string, object>;
var productLinks = CreateLinksForProduct((int)productDict["Id"], productResourceParameters.Fields);
productDict.Add("links", productLinks);
return(productDict);
});
var linkedProducts = new
{
value = shapedResourcesWithLinks,
links
};
return(Ok(linkedProducts));
}
else
{
var previousPageLink = pagedList.HasPrevious ?
CreateProductUri(productResourceParameters,
PaginationResourceUriType.PreviousPage) : null;
var nextPageLink = pagedList.HasNext ?
CreateProductUri(productResourceParameters,
PaginationResourceUriType.NextPage) : null;
var meta = new
{
pagedList.TotalItemsCount,
pagedList.PaginationBase.PageSize,
pagedList.PaginationBase.PageIndex,
pagedList.PageCount,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
return(Ok(productResources.ToDynamicIEnumerable(productResourceParameters.Fields)));
}
}
public IActionResult GetProducts(ProductResourceParameters productResourceParameters,
[FromHeader(Name = "Accept")] string mediaType)
{
// check mappings are valid
if (!_propertyMappingService.ValidMappingExistsFor <ProductDTO, Product>
(productResourceParameters.OrderBy))
{
return(BadRequest());
}
// check all fields are valid
if (!_typeHelperService.TypeHasProperties <ProductDTO>
(productResourceParameters.Fields))
{
return(BadRequest());
}
var productsFromRepo = _supermarketRepository.GetAllProducts(productResourceParameters);
var products = Mapper.Map <IEnumerable <ProductDTO> >(productsFromRepo);
if (mediaType == "application/vnd.idp.hateoas+json")
{
var paginationMetadata = new
{
totalCount = productsFromRepo.TotalCount,
pageSize = productsFromRepo.PageSize,
currentPage = productsFromRepo.CurrentPage,
totalPages = productsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
var links = CreateLinksForProducts(productResourceParameters,
productsFromRepo.HasNext, productsFromRepo.HasPrevious);
var shapedProducts = products.ShapeData(productResourceParameters.Fields);
var shapedProductsWithLinks = shapedProducts.Select(product =>
{
var productAsDictionary = product as IDictionary <string, object>;
var productLinks = CreateLinksForProduct(
(int)productAsDictionary["ProductId"], productResourceParameters.Fields);
productAsDictionary.Add("links", productLinks);
return(productAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedProductsWithLinks,
links = links
};
return(Ok(linkedCollectionResource));
}
else
{
var previousPageLink = productsFromRepo.HasPrevious ?
CreateProductResourceUri(productResourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = productsFromRepo.HasNext ?
CreateProductResourceUri(productResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
previousPageLink,
nextPageLink,
totalCount = productsFromRepo.TotalCount,
pageSize = productsFromRepo.PageSize,
currentPage = productsFromRepo.CurrentPage,
totalPages = productsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
return(Ok(products.ShapeData(productResourceParameters.Fields)));
}
}
