// GET: Products
public async Task <ActionResult> Index(string searchString, bool?inStock, string sortOrder)
{
if (User.IsInRole("Unvalidated User"))
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - Verify with a vendor first!" }));
}
ViewBag.Message = "?";
if (sortOrder != null)
{
ViewBag.Message += "sortOrder=" + sortOrder;
}
if (inStock == true)
{
ViewBag.Message += "&inStock=" + true;
}
if (!String.IsNullOrEmpty(searchString))
{
ViewBag.Message += "&searchString=" + searchString;
}
ProductFilters pf = new ProductFilters();
pf.InStock = inStock;
pf.SearchString = searchString;
pf.SortOrder = sortOrder;
return(View(pf));
}
public IActionResult Get([FromQuery] ProductFilters filters)
{
var products = _service.GetByFilter(filters);
var productList = _mapper.Map <IList <ProductModel> >(products.Item1);
return(Ok(new { Data = productList, Count = products.Item2 }));
}
public async Task <ResponseModel <ProductViewModel> > GetList(ProductFilters filters, SortCol sortCol
, AccountViewModel account, string type = "管理")
{
var query = _context.Product.Where(o => o.IsDelete == 0 && o.CompanyId == account.CompanyId);
query = Search(query, filters);
query = Sort(query, sortCol);
var vms = await query.Skip((filters.Page - 1) *filters.Limit).Take(filters.Limit)
.ProjectTo <ProductViewModel>().ToListAsync();
if (type == "报表")
{
foreach (var vm in vms)
{
var productNum = vm.Id.ToString();
vm.LocalProductNum = _context.LocalProduct.Where(o => o.ProductNum == productNum &&
o.CompanyId == account.CompanyId).Select(o => o.Num).Sum();
vm.InStorageNum = _context.InStorDetail.Where(o => o.ProductNum == productNum)
.Select(o => (int)o.PutRealNum).Sum();
vm.OutStorageNum = _context.OutStoDetail.Where(o => o.ProductNum == productNum)
.Select(o => (int)o.PutRealNum).Sum();
vm.BadReportNum = _context.BadReportDetail.Where(o => o.ProductNum == productNum).Select(o => o.Num).Sum();
}
}
ResponseModel <ProductViewModel> result = new ResponseModel <ProductViewModel>();
result.status = 0;
result.message = "";
result.total = query.Count();
result.data = vms;
return(result);
}
private List <ProductViewModel> LookFor(ProductFilters filter)
{
//obtengo la sucursal en sesión
var branchId = User.Identity.GetBranchId();
//configuro variables auxiliares
string[] arr = new List <string>().ToArray();
//si el filtro de texto tiene datos
if (filter.Text != null && filter.Text != string.Empty)
{
//divido el texto por palabras y lo convierto en un array
arr = filter.Text.Trim().Split(' ');
}
var model = db.Products.Include(p => p.SubCategory.Category).Include(p => p.ProductImages).
Where(p => (filter.CategoryId == null || p.SubCategory.CategoryId == filter.CategoryId) &&
(filter.CategoryId == null || p.SubCategoryId == filter.SubCategoryId) &&
(filter.Text == null || filter.Text == string.Empty || arr.All(s => (p.Code + " " + p.Description + " " + p.TradeMark).Contains(s))) &&
(filter.ProductId == null || p.ProductId == filter.ProductId)).Select(p => new ProductViewModel {
Product = p
}).ToList();
return(model);
}
public IActionResult GetProducts([FromQuery] ProductFilters productFilters)
{
//var fetchProducts = from p in _techDbContext.Vw_Product
// select p;
//if (productFilters.CategoryUrl != null)
//{
// fetchProducts = from p in fetchProducts
// join cp in _techDbContext.CategoryProduct on p.Id equals cp.ProductId
// join c in _techDbContext.Category on cp.CategoryId equals c.Id
// where c.Url == productFilters.CategoryUrl
// select p;
//}
//if (productFilters.CategoryName != null)
//{
// fetchProducts = from p in fetchProducts
// join cp in _techDbContext.CategoryProduct on p.Id equals cp.ProductId
// join c in _techDbContext.Category on cp.CategoryId equals c.Id
// where c.Name == productFilters.CategoryName
// select p;
//}
//if (productFilters.MaxPrice > 0)
//{
// fetchProducts = from p in fetchProducts
// where p.Price <= productFilters.MaxPrice
// select p;
//}
//if (productFilters.MinPrice > 0)
//{
// fetchProducts = from p in fetchProducts
// where p.Price >= productFilters.MinPrice
// select p;
//}
//PagedList<Vw_Product> products = PagedList<Vw_Product>.ToPagedList(
// fetchProducts,
// productFilters.PageNumber,
// productFilters.PageSize);
//var metadata = new
//{
// products.TotalCount,
// products.PageSize,
// products.CurrentPage,
// products.TotalPages,
// products.HasNext,
// products.HasPrevious
//};
//Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
//return Ok(products);
return(Ok());
}
public Object Post([FromBody] ProductFilters filters)
{
if (_productRepository.GetProducts().Count() == 0)
{
PopulateProducts();
}
List <Product> ps = _productRepository.GetProducts().ToList();
if (filters.Title.Length > 0)
{
ps = ps.Where(p => p.Title.ToLower().Contains(filters.Title.ToLower())).ToList();
}
if (filters.CategoryId > 0)
{
ps = ps.Where(p => p.CategoryId == filters.CategoryId).ToList();
}
if (filters.PriceFrom > 0)
{
ps = ps.Where(p => p.Price >= filters.PriceFrom).ToList();
}
if (filters.PriceTo > 0)
{
ps = ps.Where(p => p.Price <= filters.PriceTo).ToList();
}
if (filters.ASC)
{
ps = ps.OrderBy(p => p.Price).ToList();
}
else
{
ps = ps.OrderByDescending(p => p.Price).ToList();
}
int pageCount = (int)Math.Ceiling((double)(ps.Count() / ItemsPerPage)) + 1;
int skip = ItemsPerPage * (filters.Page - 1);
bool canPage = skip < ps.Count();
if (!canPage)
{
filters.Page = 1;
}
ps = ps.Skip(skip).Take(ItemsPerPage).ToList();
return(Ok(new { Page = filters.Page, PageCount = pageCount, Products = ps }));
}
public IQueryable <Product> Search(IQueryable <Product> query, ProductFilters filters)
{
if (!string.IsNullOrWhiteSpace(filters.Name))
{
query = query.Where(o => o.ProductName.Contains(filters.Name));
}
if (!string.IsNullOrWhiteSpace(filters.Code))
{
query = query.Where(o => o.BarCode.Contains(filters.Code));
}
return(query);
}
public ProductFilters GetFilters()
{
var filters = new ProductFilters()
{
Page = Convert.ToInt32(HttpContext.Request.Query["page"]),
Limit = Convert.ToInt32(HttpContext.Request.Query["limit"]),
Name = HttpContext.Request.Query["name"],
Code = HttpContext.Request.Query["code"],
};
return(filters);
}
public List <Product> GetProducts(User user, ProductFilters filters)
{
return(context.Products
.AsNoTracking()
.Where(p => p.Status == ProductStatus.Listed)
.Where(p => filters.Search == null || p.Name.ToLower().Contains(filters.Search.ToLower()) || p.Description.ToLower().Contains(filters.Search.ToLower()))
.Where(p => filters.ProductType == null || p.Type == filters.ProductType)
.Include(p => p.Owner)
.ThenInclude(o => o.Activity)
.Where(p => filters.IsOwner == null || p.Owner.Id == user.Id)
.Include(p => p.Images)
.ToList());
}
public Task <IReadOnlyList <Product> > GetAll(ProductFilters filters)
{
Ensure.ArgumentNotNull(filters, nameof(filters));
var options = new ApiOptions
{
StartPage = filters.StartPage,
PageCount = filters.PageCount,
PageSize = filters.PageSize
};
return(ApiConnection.GetAll <Product>(ApiUrls.Products(), filters.Parameters, options));
}
public IActionResult GetProducts([FromQuery] ProductFilters filters)
{
try
{
var user = uEngine.GetUser(this.User.FindFirst(ClaimTypes.Email).Value);
var products = engine.GetProducts(user, filters);
return(Ok(products));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task InSkillProductQueryOptionDoesntAllow101MaxResults()
{
var filters = new ProductFilters
{
MaxResults = 101
};
var request = DummyLaunchRequest();
var client = new InSkillProductsClient(request, new HttpClient(new ActionHandler(message =>
{
}, Utility.ExampleFileContent <InSkillProductsResponse>("InSkillProductsResponse.json"))));
await Assert.ThrowsAsync <InvalidOperationException>(() => client.GetProducts(filters));
}
public async Task ReturnsCorrectCountWithoutStart()
{
var pipedrive = Helper.GetAuthenticatedClient();
var options = new ProductFilters
{
PageSize = 3,
PageCount = 1
};
var products = await pipedrive.Product.GetAll(options);
Assert.Equal(3, products.Count);
}
public ActionResult Index(string searchString)
{
string category = null;
Guid? categoryId = null;
if (Request.Form["categories.categories"] != null)
{
category = Request.Form["categories.categories"].ToString();
if (!String.IsNullOrEmpty(category))
{
categoryId = new Guid(category);
}
}
ProductsDTO products;
if (String.IsNullOrEmpty(searchString))
{
if (!categoryId.HasValue)
{
products = ProductLogic.AllProducts();
}
else
{
products = ProductLogic.AllProductsInCategory(new Guid(categoryId.ToString()));
}
}
else
{
if (!categoryId.HasValue)
{
products = ProductLogic.AllProductsInSearch(searchString);
}
else
{
products = ProductLogic.AllProductsInSearchAndCategory(searchString, new Guid(categoryId.ToString()));
}
}
ProductFilters productFilters = new ProductFilters
{
productsDTOs = products,
categories = CategoryLogic.AllCategories()
};
return(View(productFilters));
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProductsAsync([FromQuery] ProductParams productParams)
{
var spec = new ProductSpecifcation(productParams);
var specCount = new ProductFilters(productParams);
var totalItems = await productRepo.CountAsync(specCount);
var products = await productRepo.ListAsync(spec);
var data = mapper.Map <List <Product>, List <ProductToReturnDto> >((List <Product>)products);
if (products == null)
{
return(NotFound(new ApiResponce(404)));
}
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize, totalItems, data)));
}
public async Task InSkillProductQueryOptionsGeneratesSingleFilterCorrectly()
{
var filters = new ProductFilters
{
MaxResults = 99
};
var request = DummyLaunchRequest();
var client = new InSkillProductsClient(request, new HttpClient(new ActionHandler(message =>
{
Assert.Equal("/v1/users/~current/skills/~current/inSkillProducts?maxResults=99", message.RequestUri.PathAndQuery);
}, Utility.ExampleFileContent <InSkillProductsResponse>("InSkillProductsResponse.json"))));
var results = await client.GetProducts(filters);
Assert.Single(results.Products);
}
public async Task <InSkillProductsResponse> GetProducts(ProductFilters filters)
{
var query = string.Empty;
if (filters?.AnySet ?? false)
{
if (filters.MaxResults.HasValue && (filters.MaxResults < 0 || filters.MaxResults > 100))
{
throw new InvalidOperationException("When set MaxResults must be between 1 and 100");
}
var content = new Dictionary <string, string>();
if (!string.IsNullOrWhiteSpace(filters.Purchasable))
{
content.Add("purchasable", filters.Purchasable);
}
if (!string.IsNullOrWhiteSpace(filters.Entitled))
{
content.Add("entitled", filters.Entitled);
}
if (!string.IsNullOrWhiteSpace(filters.ProductType))
{
content.Add("productType", filters.ProductType);
}
if (filters.MaxResults.HasValue)
{
content.Add("maxResults", filters.MaxResults.ToString());
}
query = "?" + string.Join("&", content.Select(kvp => $"{kvp.Key}={kvp.Value}"));
}
var response = await Client.GetStreamAsync(InSkillProductBasePath + query).ConfigureAwait(false);
using (var reader = new JsonTextReader(new StreamReader(response)))
{
return(Serializer.Deserialize <InSkillProductsResponse>(reader));
}
}
public Tuple <IEnumerable <Product>, int> GetByFilter(ProductFilters filters)
{
Func <Product, bool> query = x => (filters.productTypes == null || filters.productTypes.Length < 1 || filters.productTypes.Contains(x.ProductTypeId));
int count = _context.Products.Count(query);
if (count < 1)
{
throw new RepositoryException("No records found.");
}
var products = _context.Products
.Include(x => x.ContactPerson)
.Include(x => x.ProductType)
.Where(query)
.Skip((filters.pageIndex * filters.recordsCount))
.Take(filters.recordsCount);
return(new Tuple <IEnumerable <Product>, int>(products, count));
}
public async Task <ActionResult> Index(string searchString, bool?inStock)
{
if (User.IsInRole("Unvalidated User"))
{
return(RedirectToAction("Warning", "Home", new { message = "ACCESS DENIED - Verify with a vendor first!" }));
}
ProductFilters pf = new ProductFilters();
// need viewbag message for the filter to show up atm
ViewBag.Message += "?searchString=" + searchString;
ViewBag.Message += "&inStock=True";
pf.SearchString = searchString;
pf.InStock = inStock;
pf.SortOrder = "";
return(View(pf));
}
public async Task InSkillProductQueryOptionsGeneratedCorrectly()
{
var filters = new ProductFilters
{
Purchasable = PurchaseState.NotPurchasable,
Entitled = Entitlement.NotEntitled,
ProductType = ProductType.Entitlement,
MaxResults = 99
};
var request = DummyLaunchRequest();
var client = new InSkillProductsClient(request, new HttpClient(new ActionHandler(message =>
{
Assert.Equal(
"/v1/users/~current/skills/~current/inSkillProducts?purchasable=NOT_PURCHASABLE&entitled=NOT_ENTITLED&productType=ENTITLEMENT&maxResults=99",
message.RequestUri.PathAndQuery);
}, Utility.ExampleFileContent <InSkillProductsResponse>("InSkillProductsResponse.json"))));
var results = await client.GetProducts(filters);
Assert.Single(results.Products);
}
public async Task ReturnsDistinctInfosBasedOnStartPage()
{
var pipedrive = Helper.GetAuthenticatedClient();
var startOptions = new ProductFilters
{
PageSize = 1,
PageCount = 1
};
var firstPage = await pipedrive.Product.GetAll(startOptions);
var skipStartOptions = new ProductFilters
{
PageSize = 1,
PageCount = 1,
StartPage = 1
};
var secondPage = await pipedrive.Product.GetAll(skipStartOptions);
Assert.NotEqual(firstPage[0].Id, secondPage[0].Id);
}
public async Task RequestsCorrectUrl()
{
var connection = Substitute.For <IApiConnection>();
var client = new ProductsClient(connection);
var filters = new ProductFilters
{
PageSize = 1,
PageCount = 1,
StartPage = 0
};
await client.GetAll(filters);
Received.InOrder(async() =>
{
await connection.GetAll <Product>(
Arg.Is <Uri>(u => u.ToString() == "products"),
Arg.Is <Dictionary <string, string> >(d => d.Count == 0),
Arg.Is <ApiOptions>(o => o.PageSize == 1 &&
o.PageCount == 1 &&
o.StartPage == 0));
});
}
public ActionResult SearchProducts(ProductFilters filter)
{
var model = LookFor(filter);
return(PartialView("_ProductList", model));
}
