public async Task<IActionResult> SearchProducts(ProductSearchRequest request)
{
var products = await _productService.SearchProductsWithWeightAsync(
request.Keyword,
request.Terms,
request.SortField,
request.SortDescending,
request.From,
request.Size);
var suggest = await _productService.GetSearchSuggestionAsync(request.Keyword);
return Json(new { Products = products, Suggest = suggest });
}
private ProductViewModel GetData(ProductSearchRequest request)
{
ProductResponse products = productService.LoadAllProducts(request);
IEnumerable <Models.Product> enumerableProduct = products.Products.Select(product => product.CreateFrom()).ToList();
var productViewModel = new ProductViewModel
{
ProductList = new StaticPagedList <Models.Product>(enumerableProduct, request.PageNo, request.PageSize, products.TotalCount),
Categories = categoryService.LoadAllCategories().AsEnumerable(),
TotalPrice = enumerableProduct.Select(x => x.Price).Sum(),
TotalNoOfRec = products.TotalCount,
ProductSearchRequest = request,
Products = new SelectList(Enumerable.Empty <Models.Product>(), "Id", "Name")//you can assume its a list of sub-categories
};
return(productViewModel);
}
/// <summary>
/// 产品搜索
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task <List <TbkProductInfo> > Search(ProductSearchRequest request)
{
return(Task.Factory.StartNew(() =>
{
List <TbkProductInfo> result = new List <TbkProductInfo>();
TbkDgItemCouponGetRequest req = new TbkDgItemCouponGetRequest();
req.AdzoneId = ConstantsUtils.ADZONE_ID;
req.Platform = ConstantsUtils.PLATFORM;
req.PageSize = request.PageSize;
req.PageNo = request.PageNo;
if (!string.IsNullOrWhiteSpace(request.KeyWord))
{
req.Q = request.KeyWord;
}
if (request.CategoryIds != null && request.CategoryIds.Count >= 1)
{
req.Cat = string.Join(",", request.CategoryIds);
}
var response = client.Execute(req);
if (null != response && response.Results != null)
{
response.Results.ForEach(item =>
{
Tuple <decimal, string> coupon = CouponInfoFomarter.GetCouponPrice(item.CouponInfo);
if (coupon.Item1 <= 0 || item.ZkFinalPrice.ToDecimal() - coupon.Item1 < 0)
{
return;
}
result.Add(new TbkProductInfo()
{
CP = coupon.Item2,
FP = (item.ZkFinalPrice.ToDouble() - coupon.Item2.ToDouble()).ToString(),
PTLX = item.UserType.ToString(),
SPID = item.NumIid,
SPMC = item.Title,
SPYHQTGLJ = item.CouponClickUrl,
SPYXL = item.Volume,
SPZT = ToolUtils.GetThumbnail(item.PictUrl),
SPJG = item.ZkFinalPrice,
Rate = item.CommissionRate.ToDouble(),
Desc = item.ItemDescription,
});
});
}
return result;
}));
}
public async Task <IActionResult> GetProductionsGrpcAsync()
{
var request = new ProductSearchRequest
{
StatusCode = 1000
};
request.Ids.AddRange(new long[] { 285806185760389, 285806311700101 });
var grpcResult = await _whseGrpcClient.GetProductsAsync(request, GrpcClientConsts.BasicHeader);
if (grpcResult.IsSuccessStatusCode && grpcResult.Content.Is(ProductListReply.Descriptor))
{
var unpackResult = grpcResult.Content.Unpack <ProductListReply>();
return(Ok(unpackResult));
}
return(NoContent());
}
public async Task <ProductSearchResponse> ProductSearch(ProductSearchRequest productSearchModel, ViatorSetting setting = null)
{
var uri = $"service/search/products";
var response = await _httpClient.PostAsync <ProductSearchRequest>(GenerateBaseURL(uri, setting), productSearchModel);
if (response.IsSuccessStatusCode)
{
var content = response.Content.ReadAsStringAsync().Result;
var result = ProductSearchResponse.FromJson(content);
return(result);
}
else
{
throw new Exception("Viator API - ProductSearch: Api error response");
}
}
public override async Task <GrpcResponse> GetProducts(ProductSearchRequest request, ServerCallContext context)
{
var grpcResponse = new GrpcResponse();
var searchDto = _mapper.Map <ProductSearchListDto>(request);
var products = await _productAppService.GetListAsync(searchDto);
var replyProducts = products.IsNullOrEmpty()
? new List <ProductReply>()
: _mapper.Map <List <ProductReply> >(products);
var replyList = new ProductListReply();
replyList.List.AddRange(replyProducts);
grpcResponse.Content = Any.Pack(replyList);
grpcResponse.IsSuccessStatusCode = true;
return(grpcResponse);
}
public ProductResponse GetAllProducts(ProductSearchRequest productSearchRequest)
{
int fromRow = (productSearchRequest.PageNo - 1) * productSearchRequest.PageSize;
int toRow = productSearchRequest.PageSize;
Expression <Func <Product, bool> > query =
s => (!productSearchRequest.CategoryId.HasValue || s.CategoryId == productSearchRequest.CategoryId) &&
(string.IsNullOrEmpty(productSearchRequest.SearchString) || s.Name.Contains(productSearchRequest.SearchString));
IEnumerable <Product> products = productSearchRequest.IsAsc ? DbSet.Where(query).Include("Category")
.OrderBy(productClause[productSearchRequest.ProductOrderBy]).Skip(fromRow).Take(toRow).ToList()
: DbSet.Where(query).Include("Category")
.OrderByDescending(productClause[productSearchRequest.ProductOrderBy]).Skip(fromRow).Take(toRow).ToList();
return(new ProductResponse {
Products = products, TotalCount = DbSet.Count(query)
});
}
public IActionResult Search([FromQuery] ProductSearchRequest filter)
{
ResultCode resultCode; QueryModel queryResult;
(resultCode, queryResult) = _service.Search(filter);
Result error; int statusCode;
(statusCode, error) = ResultHandler.GetStatusCodeAndResult(resultCode);
GeneralResponse response = new GeneralResponse
{
Result = queryResult,
Error = error,
};
return(StatusCode(statusCode, response));
}
public async Task <IActionResult> Index(ProductSearchRequest productSearch)
{
try
{
var model = await _productService.GetAllProductAsync();
if (productSearch != null)
{
model = await _productService.GetCustomerBySearchTermsAsync(productSearch);
}
return(View(model));
}
catch (ArgumentNullException)
{
var emptyList = new List <ProductResponse>();
return(View(emptyList));
}
}
public Task <List <TbkProductInfo> > Search(ProductSearchRequest request)
{
return(Task.Factory.StartNew(() =>
{
var tkjdResponse = new HttpUtils().DoGet <TaokeJidiDataResponse>(ConstantsUtils.TAOKEJIDI_SEARCH,
new Dictionary <string, string>()
{
{ "appkey", ConstantsUtils.TAOKEJIDI_KEY },
{ "page", request.PageNo.ToString() },
{ "keyword", request.KeyWord }
});
if (null != tkjdResponse && tkjdResponse.Data != null)
{
return GetProductList(tkjdResponse.Data);
}
return new List <TbkProductInfo>();
}));
}
public ActionResult Search([FromBody] ProductSearchRequest searchRequest)
{
if (searchRequest == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Search request cannot be empty"));
}
try
{
var validator = new ProductSearchRequestValidator();
var validationResult = validator.Validate(searchRequest);
if (!validationResult.IsValid)
{
string errorMessage = "";
foreach (var error in validationResult.Errors)
{
errorMessage += error.ErrorMessage + " ";
}
return(Conflict(errorMessage));
}
}
catch (Exception e)
{
_logger.LogError($"Search products failed. Input data failed validation. Full validator exception message: {e.Message}");
return(StatusCode(StatusCodes.Status500InternalServerError, "Internal server error"));
}
var blResult = _productService.Search(searchRequest);
if (blResult.actionResult.ResultConnection != ServiceResult.ResultConnectionEnum.Correct)
{
_logger.LogError($"Product service error: {blResult.actionResult.Message}");
return(StatusCode(StatusCodes.Status500InternalServerError, blResult.actionResult.Message));
}
return(Ok(blResult.products));
}
//
// GET: /Product/Delete/5
public ActionResult Delete(ProductSearchRequest request)
{
var product = productService.FindProduct(request.Id);
try
{
productService.DeleteProduct(product);
ProductViewModel productViewModel = GetData(request);
if (Request.IsAjaxRequest())
{
return(PartialView("_Product", productViewModel));
}
}
catch
{
return(View());
}
return(null);
}
public IEnumerable <ShopifyProduct> Search(ProductSearchRequest request)
{
var store = _storeService.GetById(request.StoreId);
if (store == null || store.Options.HasFlag(StoreOptions.Disabled))
{
throw new Exception("Store not found or disabled");
}
var productService = new ShopifyProductService(new ShopifySettings(store.Host, store.AccessToken));
var products = productService.Filter(new ShopifyProductFilterRequest
{
Title = request.Title,
PublishedStatus = ShopifyPublishedStatus.Published,
Page = request.Page,
Limit = request.Limit
});
return(products);
}
public IEnumerable <Product> GetByCriteria(ProductSearchRequest request)
{
var products = _repository.GetAll();
if (!string.IsNullOrWhiteSpace(request.Name))
{
products = products.Where(x => x.Name.ToLower().Contains(request.Name.ToLower()));
}
if (!string.IsNullOrWhiteSpace(request.Code))
{
products = products.Where(x => x.Code.ToLower().Contains(request.Code.ToLower()));
}
if (request.Category.HasValue)
{
products = products.Where(x => x.Category == request.Category);
}
return(products);
}
public async Task <List <ProductViewModel> > searchProduct(ProductSearchRequest request)
{
var data = _context.Products.AsQueryable();
if (request.categoryId.Value != 0)
{
data = data.Where(ele => ele.categoryId == request.categoryId);
}
if (request.providerId.Value != 0)
{
data = data.Where(ele => ele.providerId == request.providerId);
}
if (!string.IsNullOrEmpty(request.searchKey.Trim()))
{
data = data.Where(ele => ele.name.ToLower()
.Contains(request.searchKey.ToLower())
);
}
return(await data.Where(i => i.status == ActionStatus.Display).Select(rs => new ProductViewModel
{
id = rs.id,
name = rs.name,
price = rs.price,
importPrice = rs.importPrice,
sale = rs.sale,
categoryId = rs.categoryId,
category = rs.category,
color = rs.color,
size = rs.size,
description = rs.description,
Images = rs.Images.Where(p => p.status == ActionStatus.Display).ToList(),
rating = Convert.ToInt32(rs.Evaluations.Average(ave => ave.rating)),
provider = rs.provider,
providerId = rs.providerId,
status = rs.status
}).ToListAsync());
}
public async Task <ProductListResponse> List(ProductSearchRequest request)
{
var qing = qingtaokeApiDataRepository.Search(request);
var zhushou = taokeZhushouApiDataRepository.Search(request);
var jidi = taokeJidiApiDataRepository.Search(request);
var datas = await Task.WhenAll(qing, zhushou, jidi).ContinueWith(task =>
{
List <TbkProductInfo> lstResult = new List <TbkProductInfo>();
task.Result.ToList().ForEach(item =>
{
if (item == null)
{
return;
}
lstResult.AddRange(item);
});
return(lstResult.Distinct(new ProductIdComparer()).Sort(request.Sort, false).ToList());
});
if (datas == null || datas.Count <= 0)
{
List <TbkProductInfo> lstTao = await sdkDataRepository.Search(request);
if (null != lstTao)
{
datas = lstTao;
}
else
{
datas = new List <TbkProductInfo>();
}
}
return(new ProductListResponse()
{
Datas = datas,
Total = datas.Count
});
}
private GetProductsByCategoryRequest GenerateProductSearchRequestFrom(ProductSearchRequest jsonProductSearchRequest)
{
GetProductsByCategoryRequest productSearchRequest = new GetProductsByCategoryRequest();
productSearchRequest.NumberOfResultsPerPage = int.Parse(_configuration["NumberOfResultsPerPage"]);
if (jsonProductSearchRequest != null)
{
productSearchRequest.Index = jsonProductSearchRequest.Index;
productSearchRequest.CategoryId = jsonProductSearchRequest.CategoryId;
productSearchRequest.SortBy = jsonProductSearchRequest.SortBy;
foreach (var jsonRefinementGroup in jsonProductSearchRequest.RefinementGroups)
{
switch ((RefinementGroupings)jsonRefinementGroup.GroupId)
{
case RefinementGroupings.Brand:
productSearchRequest.BrandIds = jsonRefinementGroup.SelectedRefinements;
break;
case RefinementGroupings.Color:
productSearchRequest.ColorIds = jsonRefinementGroup.SelectedRefinements;
break;
case RefinementGroupings.Size:
productSearchRequest.SizeIds = jsonRefinementGroup.SelectedRefinements;
break;
default:
break;
}
}
}
return(productSearchRequest);
}
public async Task <List <Model.Models.Product> > Get(ProductSearchRequest request)
{
var products = _context.Product.AsQueryable().Where(x => x.Active == true);
if (request.Page != -1)
{
products = products
.Skip((request.Page - 1) * request.ItemsPerPage)
.Take(request.ItemsPerPage);
}
var result = _mapper.Map <List <Model.Models.Product> >(products);
foreach (var product in result)
{
var directory = Path.Combine(Directory.GetCurrentDirectory(), "Data", "Images", "Products", $"{product.ImageLocation}");
product.Image = await FindImage(directory);
product.Price = Math.Round(product.Price, 2);
}
return(result);
}
//page_size
/// <summary>
/// 产品搜索
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task <List <TbkProductInfo> > Search(ProductSearchRequest request)
{
return(Task.Factory.StartNew(() =>
{
var reqParams = new Dictionary <string, string>()
{
{ "app_key", ConstantsUtils.QINGTAOKE_APP_KEY },
{ "page", request.PageNo.ToString() },
{ "key_word", request.KeyWord }
};
switch (request.Sort)
{
case 0:
reqParams.Add("sort", "1");
break;
case 1:
reqParams.Add("sort", "3");
break;
case 2:
reqParams.Add("sort", "4");
break;
case 3:
reqParams.Add("sort", "5");
break;
}
var qtkResponse = new HttpUtils().DoGet <QingtaokeSearchResponse>(ConstantsUtils.QINGTAOKE_SEARCH, reqParams);
if (qtkResponse != null && qtkResponse.Data != null && qtkResponse.Data.List?.Length >= 1)
{
return GetProductList(qtkResponse.Data.List);
}
return new List <TbkProductInfo>();
}));
}
public async Task <IActionResult> search([FromBody] ProductSearchRequest request)
{
var data = await _manageProductService.searchProduct(request);
return(Ok(data));
}
public async Task <IEnumerable <ProductResponse> > GetCustomerBySearchTermsAsync(ProductSearchRequest searchRequest)
{
var searchFilter = Mapper.Map <Product>(searchRequest);
var product = await _unitOfWork.Products.GetProductBySearchTermsAsync(searchFilter);
_nullCheckMethod.CheckIfResponseListIsEmpty(product);
var response = Mapper.Map <IEnumerable <ProductResponse> >(product);
return(response);
}
public IHttpActionResult Search([FromUri] ProductSearchRequest request)
{
return(Ok(_productService.Search(request)));
}
public async Task <List <Model.Models.Product> > Get([FromQuery] ProductSearchRequest request)
{
return(await _service.Get(request));
}
public Task <List <TbkProductInfo> > Search(ProductSearchRequest request)
{
return(Task.Factory.StartNew(() =>
{
var dicParams = new Dictionary <string, string>()
{
{ "app_key", ConstantsUtils.TAOKEZHUSHOU_KEY },
{ "page", request.PageNo.ToString() }
};
if (!string.IsNullOrWhiteSpace(request.KeyWord))
{
dicParams.Add("q", request.KeyWord);
}
if (request.TodayNew >= 1)
{
dicParams.Add("today", "1");
}
if (request.Juhuasuan == 1)
{
dicParams.Add("juhuasuan", "1");
}
if (request.Taoqianggou == 1)
{
dicParams.Add("taoqianggou", "1");
}
if (request.Haitao == 1)
{
dicParams.Add("haitao", "1");
}
if (request.MinPrice > 0)
{
dicParams.Add("price_start", request.MinPrice.ToString());
}
if (request.MaxPrice > 0)
{
dicParams.Add("price_end", request.MaxPrice.ToString());
}
if (request.Cat >= 0)
{
dicParams.Add("cate_id", request.Cat.ToString());
}
if (request.Tmall == 1)
{
dicParams.Add("is_tmall", request.Tmall.ToString());
}
switch (request.Sort)
{
case 0:
dicParams.Add("sort", "one_day_sale_num");
break;
case 1:
dicParams.Add("sort", "sale_num");
break;
case 2:
dicParams.Add("sort", "price_asc");
break;
case 3:
dicParams.Add("sort", "commission_rate_desc");
break;
}
var dtkResponse = new HttpUtils().DoGet <TaokeZhushouDataResponse>(ConstantsUtils.TAOKEZHUSHOU_SEARCH, dicParams);
if (null != dtkResponse && dtkResponse.Data != null)
{
return GetProductList(dtkResponse.Data);
}
return new List <TbkProductInfo>();
}));
}
public object GetBySearchStringAndProperties([FromQuery] string query, [FromQuery] int from,
[FromQuery] int size, [FromQuery] string lang, [FromBody] ProductSearchRequest requestBody)
{
if (requestBody == null)
{
requestBody = new ProductSearchRequest();
}
return(_productQueryService.FindByStringAndProperty(query, string.IsNullOrEmpty(lang) ? "default" :
lang, from, size == 0 ? 10 : size, requestBody.StringProperties, requestBody.NumericProperties, requestBody.Category, requestBody.StringAggregations, requestBody.NumericAggregations));
}
public IHttpActionResult Search([FromUri] ProductSearchRequest request)
{
request = request ?? new ProductSearchRequest();
request.Normalize();
var context = new Dictionary <string, object>
{
{ "StoreId", request.Store },
};
var fullLoadedStore = GetStoreById(request.Store);
if (fullLoadedStore == null)
{
throw new NullReferenceException(request.Store + " not found");
}
var catalog = fullLoadedStore.Catalog;
string categoryId = null;
var criteria = new CatalogIndexedSearchCriteria {
Locale = request.Language, Catalog = catalog.ToLowerInvariant(), IsFuzzySearch = true
};
if (!string.IsNullOrWhiteSpace(request.Outline))
{
criteria.Outlines.Add(string.Format("{0}/{1}*", catalog, request.Outline));
categoryId = request.Outline.Split(new[] { '/' }).Last();
context.Add("CategoryId", categoryId);
}
#region Filters
// Now fill in filters
var filters = _browseFilterService.GetFilters(context);
// Add all filters
foreach (var filter in filters)
{
criteria.Add(filter);
}
// apply terms
var terms = ParseKeyValues(request.Terms);
if (terms.Any())
{
var filtersWithValues = filters
.Where(x => (!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(request.Currency, StringComparison.OrdinalIgnoreCase)))
.Select(x => new { Filter = x, Values = x.GetValues() })
.ToList();
foreach (var term in terms)
{
var filter = filters.SingleOrDefault(x => x.Key.Equals(term.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(request.Currency, StringComparison.OrdinalIgnoreCase)));
// handle special filter term with a key = "tags", it contains just values and we need to determine which filter to use
if (filter == null && term.Key == "tags")
{
foreach (var termValue in term.Values)
{
// try to find filter by value
var foundFilter = filtersWithValues.FirstOrDefault(x => x.Values.Any(y => y.Id.Equals(termValue)));
if (foundFilter != null)
{
filter = foundFilter.Filter;
var appliedFilter = _browseFilterService.Convert(filter, term.Values);
criteria.Apply(appliedFilter);
}
}
}
else
{
var appliedFilter = _browseFilterService.Convert(filter, term.Values);
criteria.Apply(appliedFilter);
}
}
}
#endregion
#region Facets
// apply facet filters
var facets = ParseKeyValues(request.Facets);
foreach (var facet in facets)
{
var filter = filters.SingleOrDefault(
x => x.Key.Equals(facet.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) ||
((PriceRangeFilter)x).Currency.Equals(request.Currency, StringComparison.OrdinalIgnoreCase)));
var appliedFilter = _browseFilterService.Convert(filter, facet.Values);
criteria.Apply(appliedFilter);
}
#endregion
//criteria.ClassTypes.Add("Product");
criteria.RecordsToRetrieve = request.Take <= 0 ? 10 : request.Take;
criteria.StartingRecord = request.Skip;
criteria.Pricelists = request.Pricelists;
criteria.Currency = request.Currency;
criteria.StartDateFrom = request.StartDateFrom;
criteria.SearchPhrase = request.SearchPhrase;
#region sorting
if (!string.IsNullOrEmpty(request.Sort))
{
var isDescending = "desc".Equals(request.SortOrder, StringComparison.OrdinalIgnoreCase);
SearchSort sortObject = null;
switch (request.Sort.ToLowerInvariant())
{
case "price":
if (criteria.Pricelists != null)
{
sortObject = new SearchSort(
criteria.Pricelists.Select(
priceList =>
new SearchSortField(String.Format("price_{0}_{1}", criteria.Currency.ToLower(), priceList.ToLower()))
{
IgnoredUnmapped = true,
IsDescending = isDescending,
DataType = SearchSortField.DOUBLE
})
.ToArray());
}
break;
case "position":
sortObject =
new SearchSort(
new SearchSortField(string.Format("sort{0}{1}", catalog, categoryId).ToLower())
{
IgnoredUnmapped = true,
IsDescending = isDescending
});
break;
case "name":
sortObject = new SearchSort("name", isDescending);
break;
case "rating":
sortObject = new SearchSort(criteria.ReviewsAverageField, isDescending);
break;
case "reviews":
sortObject = new SearchSort(criteria.ReviewsTotalField, isDescending);
break;
default:
sortObject = CatalogIndexedSearchCriteria.DefaultSortOrder;
break;
}
criteria.Sort = sortObject;
}
#endregion
//Load ALL products
var searchResults = _browseService.SearchItems(criteria, request.ResponseGroup);
// populate inventory
if ((request.ResponseGroup & ItemResponseGroup.ItemProperties) == ItemResponseGroup.ItemProperties)
{
PopulateInventory(fullLoadedStore.FulfillmentCenter, searchResults.Items);
}
return(Ok(searchResults));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var productSearch = new ProductSearchRequest();
return(View("ProductSearch", productSearch));
}
public async Task <ResponseDTO <PagedList <ProductResponse> > > Search(ProductSearchRequest search)
{
var resp = await _productsApplicationService.SearchProductsByNameAsync(search);
return(resp);
}
public ProductResponse LoadAllProducts(ProductSearchRequest productSearchRequest)
{
return(productRepository.GetAllProducts(productSearchRequest));
}
public (ServiceResult actionResult, IEnumerable <Product> products) Search(ProductSearchRequest searchRequest)
{
var allList = _dbContext.Products.SelectAll();
if (allList == null)
{
return(new ServiceResult(ServiceResult.ResultConnectionEnum.SystemError, ""), null);
}
bool searchStatus;
bool searchCost;
bool searchParameter;
bool searchCategory;
List <ProductStatus> productStatuses = new List <ProductStatus>();
#region Search parameters init
try
{
foreach (string productStatus in searchRequest.ProductStatuses)
{
var status = new ProductStatus(productStatus);
productStatuses.Add(status);
}
searchStatus = true;
}
catch
{
productStatuses = null;
searchStatus = false;
}
if (searchRequest.MinCost != 0 || searchRequest.MaxCost != 0)
{
searchCost = true;
}
else
{
searchCost = false;
}
if (!string.IsNullOrEmpty(searchRequest.ProductSearch))
{
searchParameter = true;
}
else
{
searchParameter = false;
}
if (searchRequest.IdProductCategories != null && searchRequest.IdProductCategories.Count() != 0)
{
searchCategory = true;
}
else
{
searchCategory = false;
}
#endregion
#region Search in the list
var listResult = new List <Product>();
foreach (Product product in allList)
{
#region Status check
if (searchStatus)
{
bool statusCheck = false;
foreach (ProductStatus productStatus in productStatuses)
{
if (product.ProductStatus.Status == productStatus.Status)
{
statusCheck = true;
}
}
if (!statusCheck)
{
continue;
}
}
#endregion
#region Price check
if (searchCost)
{
if (product.Price > searchRequest.MaxCost || product.Price < searchRequest.MinCost)
{
continue;
}
}
#endregion
#region Search string check
if (searchParameter)
{
if (!product.ProductInformation.ProductName.ToLower().Contains(searchRequest.ProductSearch.ToLower()) &&
!product.ProductInformation.Description.ToLower().Contains(searchRequest.ProductSearch.ToLower()))
{
continue;
}
}
#endregion
#region Product category check
if (searchCategory)
{
bool containCategories = true;
foreach (int idSearchCategory in searchRequest.IdProductCategories)
{
bool containCategory = false;
foreach (ProductCategory productCategory in product.ProductInformation.ProductCategories)
{
// ReSharper disable once PossibleInvalidOperationException
if (productCategory.IdEntity.Value == idSearchCategory)
{
containCategory = true;
}
}
if (!containCategory)
{
containCategories = false;
break;
}
}
if (!containCategories)
{
continue;
}
}
#endregion
listResult.Add(product);
}
#endregion
ServiceResult resultCorrect = new ServiceResult(ServiceResult.ResultConnectionEnum.Correct, "");
return(resultCorrect, listResult);
}
public async Task <ResponseDTO <PagedList <ProductDTO> > > SearchProductsByNameAsync(ProductSearchRequest search)
{
List <OrderExpression <ProductDTO> > orderExpressionList = new List <OrderExpression <ProductDTO> >();
orderExpressionList.Add(new OrderExpression <ProductDTO>(OrderType.Asc, p => p.Name));
Expression <Func <ProductDTO, bool> > queryFilter = c => c.RowStatus == true;
if (!string.IsNullOrEmpty(search.Code))
{
queryFilter = queryFilter.And(p => p.Code.Contains(search.Code));
}
if (!string.IsNullOrEmpty(search.Name))
{
queryFilter = queryFilter.And(p => p.Name.Contains(search.Name));
}
if (!string.IsNullOrEmpty(search.ShortName))
{
queryFilter = queryFilter.And(p => p.ShortName.Contains(search.ShortName));
}
if (!string.IsNullOrEmpty(search.IsHazardous))
{
queryFilter = queryFilter.And(p => p.IsHazardous.Contains(search.IsHazardous));
}
var product = await _productDataAcces.ListPagedAsync(queryFilter, search.Page, search.PageSize, orderExpressionList.ToArray());
var pagedResult = new PagedList <ProductDTO>()
{
Items = product.Items,
PageSize = product.PageSize,
Page = product.Page,
Total = product.Total
};
return(ResponseBuilder.Correct(pagedResult));
}
