public ActionResult <IEnumerable <ProductDTO> > Get([FromQuery] ProductsFilter filter)
{
try
{
IEnumerable <Product> products;
if (filter != null)
{
products = _productService.ReadFiltered(filter);
}
else
{
products = _productService.ReadProducts();
}
if (products == null || products.Count() < 1)
{
return(NotFound("There are no products in database"));
}
else
{
List <ProductDTO> productDTOs = new List <ProductDTO>();
foreach (var item in products)
{
productDTOs.Add(toDto(item));
}
return(Ok(productDTOs));
}
}
catch (Exception ex)
{
Log.Error($"Exception occured on ProductsController GetAll\n Stack Trace: {ex.StackTrace}");
return(StatusCode(500, ex.Message));
}
}
public void SearchReturnsCorrectProduct()
{
var products = new List <Product>();
for (int i = 0; i < 1000; i++)
{
products.Add(new Product()
{
ID = i,
Name = "Prod" + i
});
}
var filter = new ProductsFilter()
{
CurrentPage = 1,
PageSize = 10,
SearchTextName = "Prod1"
};
var expectedFilteredList = products.Where(c => c.Name.Contains(filter.SearchTextName))
.Take(10);
var productRepo = new Mock <IProductRepository>();
productRepo.Setup(cr => cr.ReadProducts())
.Returns(products);
var service = GetService(productRepo);
var foundProducts = service.ReadFiltered(filter);
Assert.Equal(expectedFilteredList, foundProducts);
}
private List <BrandViewModel> GetBrands()
{
var brands = _productService
.GetBrands()
.ToList();
var brandViewModels = new List <BrandViewModel>();
foreach (var brand in brands)
{
var productFilter = new ProductsFilter
{
BrandId = brand.Id
};
var products = _productService
.GetProducts(productFilter)
.ToList();
var brandViewModel = new BrandViewModel
{
Id = brand.Id,
Name = brand.Name,
Order = brand.Order,
ProductsCount = products.Count
};
brandViewModels.Add(brandViewModel);
}
return(brandViewModels
.OrderBy(b => b.Order)
.ToList());
}
public void SearchProducts(ProductsFilter filter)
{
string sql = $@"
SELECT
p.Title,
p.Description,
p.Price
FROM Products AS p
WHERE 1 = 1
{@if(filter.Title != null, @"
AND p.Title = @Title"
)}
{@if(filter.MinPrice != null, @"
AND p.Price >= @MinPrice"
)}
{@if(filter.MaxPrice != null, @"
AND p.Price <= @MaxPrice"
)}
{@if(filter.Tags != null, $@"
AND (
SELECT COUNT(1)
FROM ProductTags AS t
WHERE t.ProductId = p.Id
AND t.Tag IN (@Tags)
) = @TagsLength"
)}
ORDER BY
{@switch(filter.SortBy,
@case(ProductsSortBy.Title, " Title ASC"),
@case(ProductsSortBy.Price, " Price ASC")
)}";
}
public IQueryable <Product> Get(ProductsFilter filter)
{
IQueryable <Product> query = GetAll();
if (filter != null)
{
if (filter.ParentId != null)
{
query = query.Where(product => product.Categories.Any(category => category.Id == filter.ParentId.Value));
}
if (!string.IsNullOrEmpty(filter.Text))
{
query = query.Where(product => product.Name.Contains(filter.Text));
}
if (filter.Publish.HasValue)
{
query = query.Where(product => product.Publish == filter.Publish.Value);
}
if (filter.IsDeleted.HasValue)
{
query = query.Where(product => product.IsDeleted == filter.IsDeleted.Value);
}
}
return(query);
}
public IEnumerable <ProductDto> GetProducts(ProductsFilter filter)
{
var response = Post($"{ServiceAddress}", filter);
var products = response.Content.ReadAsAsync <List <ProductDto> >().Result;
return(products);
}
public ActionResult Index(ProductsFilter request)
{
request.SetDefaultPaging();
ViewBag.ParentCategories = GetParentCategoriesForFilter();
var model = GetCommand <GetProductsCommand>().ExecuteCommand(request);
return(View(model));
}
private IEnumerable <ProductDo> GetProductsByFilter(ProductsFilter filter)
{
if (filter.IsActive == true)
{
return(_productRepository.GetActiveProducts());
}
return(_productRepository.GetAllProducts());
}
public async Task <IActionResult> FilterProducts([FromBody] ProductsFilter productsFilter)
{
var response = await _productsService.FilterProducts(productsFilter);
if (response.IsSuccess)
{
return(Ok(response));
}
return(NotFound());
}
public IEnumerable <Product> ReadFiltered(ProductsFilter filter)
{
if (filter == null || (filter.PageSize == 0 && filter.CurrentPage == 0))
{
return(ReadProducts());
}
var allItems = _productRepo.ReadProducts()
.Where(item => filter.Accepts(item));
IEnumerable <Product> page;
if (filter.CategoryId > 0)
{
var category = _categoryRepo.FindCategoryWithID(filter.CategoryId);
var acceptedCategoryIds = GetCategoriesSubIds(category);
allItems = allItems
.Select(e => e)
.Where(item => acceptedCategoryIds.Contains(item.Category.ID));
}
switch (filter.Ordering)
{
case ProductsFilter.OrderingType.TopRated:
allItems = allItems.OrderByDescending(item => item.Rating);
break;
case ProductsFilter.OrderingType.MostExpensive:
allItems = allItems.OrderByDescending(item => item.Price);
break;
case ProductsFilter.OrderingType.LeastExpensive:
allItems = allItems.OrderBy(item => item.Price);
break;
case ProductsFilter.OrderingType.MostSold:
break;
default:
break;
}
page = allItems
.Skip((filter.CurrentPage - 1) * filter.PageSize)
.Take(filter.PageSize);
if (page != null)
{
return(page);
}
return(new List <Product>());
}
public async void TestGetProductsWithNameFilter()
{
var productsFilter = new ProductsFilter
{
Name = "Sweepstakes Giveaway"
};
var products = await Client.Products.GetPageAsync(1, 100, productsFilter) as List <Product>;
Assert.True(products.Count > 0);
}
public PagedProductListResult Get(ProductsFilter filter)
{
IQueryable <Product> query = _productsRepository.Get(filter).OrderBy(entity => entity.Name);
PagedProductListResult result = new PagedProductListResult();
result.TotalRecords = query.Count();
result.Entities.AddRange(query.Skip((filter.PaginationFilter.PageNumber - 1) * filter.PaginationFilter.PageSize).Take(filter.PaginationFilter.PageSize));
return(result);
}
public async void TestGetProductsWithDateFilter()
{
var productsFilter = new ProductsFilter
{
StartDate = DateTime.Now.Subtract(TimeSpan.FromDays(30))
};
var products = await Client.Products.GetPageAsync(1, 100, productsFilter) as List <Product>;
Assert.True(products.Count > 0);
}
public async void TestGetProductsWithShowInactiveFilter()
{
var productsFilter = new ProductsFilter
{
ShowInactive = true
};
var products = await Client.Products.GetPageAsync(1, 100, productsFilter) as List <Product>;
Assert.True(products.Count > 0);
}
private HomePageViewModel BuildHomePageViewModel(string searchTerm, int?parentCategoryId, int?pageNumber)
{
HomePageViewModel viewModel = new HomePageViewModel();
viewModel.RootCategories = _productCategoriesBL.GetCategories(null).Select(productCategory => new HorizontalCategoryItemViewModel
{
ProductCategory = productCategory,
IsSelected = false
}).ToList();
viewModel.SelectedCategory = null;
ProductsFilter productsFilter = new ProductsFilter
{
Text = searchTerm,
Publish = true,
ParentId = parentCategoryId
};
productsFilter.PaginationFilter.PageNumber = pageNumber == null ? 1 : pageNumber.Value;
productsFilter.PaginationFilter.PageSize = ApplicationSettings.Instance.AppSettings.DefaultPageSize;
PagedProductListResult pagedProductListResult = _productsBL.Get(productsFilter);
viewModel.Products = pagedProductListResult.Entities;
viewModel.PaginationFilterViewModel = new HomePagePaginationFilterViewModel
{
PageNumber = productsFilter.PaginationFilter.PageNumber,
TotalRecords = pagedProductListResult.TotalRecords,
PageSize = productsFilter.PaginationFilter.PageSize,
SearchTerm = searchTerm,
ParentCategoryId = parentCategoryId
};
if (parentCategoryId.HasValue)
{
viewModel.ParentCategories = _productCategoriesBL.GetParentCategories(parentCategoryId.Value);
viewModel.SelectedCategory = _productCategoriesBL.GetById(parentCategoryId.Value);
viewModel.ParentCategories.Add(viewModel.SelectedCategory);
viewModel.ChildCategories = _productCategoriesBL.SearchByFilter(new ProductCategoriesFilter
{
ParentId = parentCategoryId,
IncludeDeleted = false,
Publish = true
}).Entities;
}
else
{
viewModel.ParentCategories = new List <ProductCategory>();
viewModel.ChildCategories = new List <ProductCategory>();
}
return(viewModel);
}
public async Task <PageResult <ConcurrencyToken <Product> > > Get(ProductsFilter request)
{
if (request == default)
{
throw new ArgumentOutOfRangeException(nameof(request));
}
var products = await _repository.Get(request);
var total = await _repository.Count(request);
return(new PageResult <ConcurrencyToken <Product> >(request.PageFilter, products, (uint)total));
}
public async Task <List <ConcurrencyToken <Product> > > Get(ProductsFilter productsFilter)
{
var query = Filter(productsFilter);
query = Order(productsFilter, query);
var products = await query
.Skip((int)productsFilter.PageFilter.Skip)
.Take((int)productsFilter.PageFilter.Take)
.ToListAsync();
return(products.Select(p => p.ToProduct()).ToList());
}
public string SearchProducts(ProductsFilter filter)
{
var query = new QueryBuilder();
var q = query.Append;
q("SELECT");
{
q("p.Title,");
q("p.Description,");
q("p.Price");
}
q("FROM Products AS p");
q("WHERE 1 = 1");
if (filter.Title != null)
{
q("AND p.Title = @Title");
}
if (filter.MinPrice != null)
{
q("AND p.Price = @MinPrice");
}
if (filter.MaxPrice != null)
{
q("AND p.Price = @MaxPrice");
}
if (filter.Tags != null)
{
q("AND (");
{
q("SELECT COUNT(1)");
q("FROM ProductTags AS t");
q("WHERE t.ProductId = p.Id");
q("AND t.Tag IN (@Tags)");
}
q(") = @TagsLength");
}
q("ORDER BY");
switch (filter.SortBy)
{
case ProductsSortBy.Title:
q("Title ASC");
break;
case ProductsSortBy.Price:
q("Price ASC");
break;
}
return(query.ToString());
}
public ProductsModel GetProducts(ProductsFilter filter)
{
string searchTextQuery = "";
string subquery = "";
string filterQuery = "";
string CountTextQuery = "";
if (!string.IsNullOrWhiteSpace(filter.SearchText))
{
searchTextQuery = " c.ProductName like '%" + filter.SearchText + "%' or c.Category like '%" + filter.SearchText + "%' or c.SubCategory like '%" + filter.SearchText + "%' or c.Quantity like '%" + filter.SearchText + "%' and ";
CountTextQuery = " where c.ProductName like '%" + filter.SearchText + "%' or c.Category like '%" + filter.SearchText + "%' or c.SubCategory like '%" + filter.SearchText + "%' or c.Quantity like '%" + filter.SearchText + "%' ";
}
string rawQuery = @"
declare @pagesize int
declare @pageno int
set @pagesize = " + filter.UnitPerPage + @"
set @pageno = " + filter.PageNumber + @"
declare @pagestart int
set @pagestart=(@pageno-1)* @pagesize
select TOP (@pagesize) c.* FROM Products c
where {1}{2} c.Id NOT IN(Select TOP (@pagestart) Id from Products {0})
{0}
";
string CountQuery = string.Format("Select * from Products c {0}", CountTextQuery);
rawQuery = string.Format(rawQuery, subquery, searchTextQuery, filterQuery);
int TotalCount = 0;
List <Product> dsResult = new List <Product>();
try
{
var ctx = DataContext.getInstance();
dsResult = ctx.Product.SqlQuery(rawQuery).ToList();
TotalCount = ctx.Product.SqlQuery(CountQuery).ToList().Count;
}
catch (Exception ex)
{
}
ProductsModel productsModel = new ProductsModel();
productsModel.ProductsList = dsResult;
//context.Dispose();
productsModel.TotalCount = TotalCount;
return(productsModel);
}
public async Task<BaseFilterResponse<Products>> GetProductsFiltered(ProductsFilter productsFilter)
{
var totalRecords = await _unitOfWork.ProductsRepository.GetAll();
BaseFilterResponse<Products> objResponse = new BaseFilterResponse<Products>
{
PageNumber = productsFilter.currentpage,
PageSize = productsFilter.recordsperpage,
TotalRecords = totalRecords.Count(),
data = _unitOfWork.ProductsRepository.GetProductsFiltered(productsFilter)
};
return objResponse;
}
public SearchableGridViewModel <ProductViewModel> Execute(ProductsFilter request)
{
request.SetDefaultSortingOptions("Code");
var query = Repository
.AsQueryable <Models.Product>()
.Select(t => new ProductViewModel
{
Id = t.Id,
Version = t.Version,
CategoryId = t.CategoryId,
Code = t.Code,
Size = t.Size,
Color = t.Color,
Description = t.Description,
Description_en = t.Description_en,
IsFeature = t.IsFeature,
SortOrder = t.SortOrder,
Image = t.Image != null && !t.Image.IsDeleted ?
new ImageSelectorViewModel
{
ImageId = t.Image.Id,
ImageUrl = fileUrlResolver.EnsureFullPathUrl(t.Image.PublicUrl),
ThumbnailUrl = fileUrlResolver.EnsureFullPathUrl(t.Image.PublicThumbnailUrl),
ImageTooltip = t.Image.Caption,
FolderId = t.Image.Folder != null ? t.Image.Folder.Id : (Guid?)null
} : null
});
//search
if (!string.IsNullOrWhiteSpace(request.SearchQuery))
{
query = query.Where(t => t.Code.Contains(request.SearchQuery));
}
//filter
if (request.CategoryId != null && request.CategoryId != Guid.Parse("99999999-9999-9999-9999-999999999999"))
{
query = query.Where(t => t.CategoryId == request.CategoryId);
}
if (request.IsFeature != null)
{
query = query.Where(t => t.IsFeature == request.IsFeature);
}
//total count
var count = query.ToRowCountFutureValue();
//sorting, paging
query = query.AddSortingAndPaging(request);
return(new SearchableGridViewModel <ProductViewModel>(query.ToList(), request, count.Value));
}
public void GeProducts_ByName()
{
//Arrange
ProductsRepository productsRepository = DI.Resolve <ProductsRepository>();
ProductsFilter filter = new ProductsFilter
{
Text = "фре"
};
//Act
List <Product> products = productsRepository.Get(filter).ToList();
//Assert
Assert.That(products.Count, Is.EqualTo(23));
}
public void GeProducts_ByParentId()
{
//Arrange
ProductsRepository productsRepository = DI.Resolve <ProductsRepository>();
ProductsFilter filter = new ProductsFilter
{
ParentId = 54
};
//Act
List <Product> products = productsRepository.Get(filter).ToList();
//Assert
Assert.That(products.Count, Is.EqualTo(14));
}
public void GetProducts_OnlyPublish()
{
//Arrange
ProductsRepository productsRepository = DI.Resolve <ProductsRepository>();
ProductsFilter filter = new ProductsFilter
{
Publish = true
};
//Act
List <Product> products = productsRepository.Get(filter).ToList();
//Assert
Assert.That(products.Count, Is.EqualTo(36));
}
private void FindProducts(object value)
{
string findByValue = (value as string) ?? FindByValue;
if (FindBy == null || findByValue == null)
{
return;
}
var filter = new ProductsFilter {
FindBy = FindBy, FindByValue = findByValue
};
IProductsList products = new ProductsGetter().Get(filter);
_onProductsFound(products);
}
/// <summary>
/// Obtains a list of products that match the specified criteria. All of the available filters are optional. They do not need to
/// be included in the URL.
/// </summary>
/// <param name="filter">A Products filter.</param>
/// <returns>A list of products that match the specified criteria.</returns>
public async Task <IList <Product> > GetAllPagesAsync(ProductsFilter filter)
{
var items = new List <Product>();
filter = filter ?? new ProductsFilter();
var pageOne = await GetDataAsync <PaginatedResponse <Product> >(filter).ConfigureAwait(false);
items.AddRange(pageOne.Items);
if (pageOne.Pages > 1)
{
items.AddRange(await GetPageRangeAsync(2, pageOne.Pages, filter.PageSize, filter).ConfigureAwait(false));
}
return(items);
}
public async Task <BaseResponse <IEnumerable <Product> > > Filter(ProductsFilter productsFilter)
{
BaseResponse <IEnumerable <Product> > response = new BaseResponse <IEnumerable <Product> >();
_ = await response.SafeCall(async() =>
{
var allByFilter = _context.Product.Include(p => p.Variants)
.Where(p => p.CategoryId == productsFilter.CategoryId);
response.Results = allByFilter.Skip(productsFilter.Page *productsFilter.PerPage).Take(productsFilter.PerPage);
response.Page = productsFilter.Page;
response.TotalPages = allByFilter.Count() / productsFilter.PerPage;
});
return(response);
}
public void GetProducts_ByParentIdAndByName()
{
//Arrange
ProductsRepository productsRepository = DI.Resolve <ProductsRepository>();
ProductsFilter filter = new ProductsFilter
{
ParentId = 54,
Text = "Полотно СМТ JT12"
};
//Act
List <Product> products = productsRepository.Get(filter).ToList();
//Assert
Assert.That(products.Count, Is.EqualTo(2));
}
public ActionResult LoadProductList(ProductsFilter filter)
{
if (filter.CategoryName == "-1" || filter.CategoryName == null)
{
filter.CategoryName = string.Empty;
}
if (filter.PageNumber == 0)
{
filter.PageNumber = 1;
}
filter.UnitPerPage = 12;
if (filter.PageNumber == null || filter.PageNumber == 0)
{
filter.PageNumber = 1;
}
ProductsModel productsList = productsFacade.GetProducts(filter);
ViewBag.OutOfNumber = productsList.TotalCount;
if ((int)ViewBag.OutOfNumber == 0)
{
ViewBag.Message = "No Content Available !";
}
if (@ViewBag.OutOfNumber == 0)
{
filter.PageNumber = 1;
}
ViewBag.PageNumber = filter.PageNumber;
if ((int)ViewBag.PageNumber * filter.UnitPerPage > (int)ViewBag.OutOfNumber)
{
ViewBag.CurrentNumber = (int)ViewBag.OutOfNumber;
}
else
{
ViewBag.CurrentNumber = (int)ViewBag.PageNumber * filter.UnitPerPage;
}
ViewBag.PageCount = Math.Ceiling((double)ViewBag.OutOfNumber / filter.UnitPerPage.Value);
productsList.ProductsList = productsList.ProductsList.Where(x => x.Category.Contains(filter.CategoryName)).ToList();
return(View(productsList.ProductsList));
}
public IEnumerable <Product> GetProducts(ProductsFilter filter)
{
var products = _products;
if (filter.CategoryId.HasValue)
{
products = products
.Where(p => p.CategoryId == filter.CategoryId.Value)
.ToList();
}
if (filter.BrandId.HasValue)
{
products = products
.Where(p => p.BrandId.HasValue && p.BrandId == filter.BrandId.Value)
.ToList();
}
return(products);
}
