public ExecuteResult <ProductCollectionResponse> Search(SearchProductRequest request)
{
return(new ExecuteResult <ProductCollectionResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "不支持该方法"
});
}
public ActionResult GetSearchProductsByAjax(SearchProductRequest request)
{
SearchProductRequest productSearchRequest = GenarateSeachRequest(request);
SearchProductResponse response = service.SearchByProductName(productSearchRequest, SearchType.SearchString);
return(Json(response));
}
public virtual async Task <IEnumerable <SitemapEntry> > GetEntriesAsync(SitemapParams sitemapParams, CultureInfo culture, int offset, int count)
{
Guard.NotNull(sitemapParams, nameof(sitemapParams));
Guard.NotNullOrWhiteSpace(sitemapParams.BaseUrl, $"{nameof(sitemapParams)}.{nameof(sitemapParams.BaseUrl)}");
Guard.NotNullOrWhiteSpace(sitemapParams.Scope, $"{nameof(sitemapParams)}.{nameof(sitemapParams.Scope)}");
Guard.NotNull(culture, nameof(culture));
var request = new SearchProductRequest
{
ScopeId = sitemapParams.Scope,
CultureName = culture.Name,
Keywords = "*",
StartingIndex = offset,
MaximumItems = count,
VariantGroupingStrategy = SearchVariantGroupingStrategy.PerProduct,
};
var response = await _overtureClient.SendAsync(request).ConfigureAwait(false);
if (!response.Documents.Any())
{
return(Enumerable.Empty <SitemapEntry>());
}
return(CreateStandardSitemapEntries(sitemapParams, response.Documents, culture));
}
public List <ActiveProductListResponse> SearchProduct(SearchProductRequest searchProductRequest)
{
using (DataAccess dataAccess = new DataAccess())
{
var list = from product in dataAccess.Products
join category in dataAccess.Categories on product.CategoryID equals category.CategoryID
join unit in dataAccess.Unit on product.UnitID equals unit.UnitID
join seller in dataAccess.Sellers on product.SellerID equals seller.SellerID
join city in dataAccess.Cities on seller.CityID equals city.CityID
join stockStatus in dataAccess.StockStatus on product.StockID equals stockStatus.StockID
where (product.StatusID == true && (product.ProductCode.StartsWith(searchProductRequest.query) || product.ProductName.StartsWith(searchProductRequest.query)))
orderby product.StockID descending
select(new ActiveProductListResponse
{
ProductID = product.ProductID,
CategoryName = category.CategoryName,
ProductCode = product.ProductCode,
ProductName = product.ProductName,
Volume = product.Volume,
UnitName = unit.UnitName,
SellerName = seller.Name,
SellerSurame = seller.Surname,
SellerEmail = seller.Email,
SellerCity = city.CityName,
StockNumber = product.StockNumber,
Price = product.Price,
Photo = product.Photo,
StockStatus = stockStatus.StockStatu
});
return(list.ToList());
}
}
public byte[] HandleSearchProduct(string json) //deal with doytsh
{
SearchProductRequest res = JsonConvert.DeserializeObject <SearchProductRequest>(json);
Dictionary <int, List <Product> > ans = storeService.SearchProducts(res.Filters);
string jsonAns = Seralize(new SearchProductResponse(converter.ToSearchProductResponse(ans)));
return(security.Encrypt(jsonAns));
}
public DataSet SearchProduct(SearchProductRequest model, ref int pTotal)
{
try
{
var spParameter = new SqlParameter[5];
#region Set param
var parameter = new SqlParameter("@P_ORDER_BY", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = model.OrderBy
};
spParameter[0] = parameter;
parameter = new SqlParameter("@P_ORDER_TYPE", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = model.OrderByType
};
spParameter[1] = parameter;
parameter = new SqlParameter("@P_START", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = model.Start
};
spParameter[2] = parameter;
parameter = new SqlParameter("@P_END", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = model.End
};
spParameter[3] = parameter;
parameter = new SqlParameter("@P_TOTAL", SqlDbType.Int)
{
Direction = ParameterDirection.Output,
Value = -1
};
spParameter[4] = parameter;
#endregion
var ds = SqlHelper.ExecuteDataset(ConfigInfo.ConnectString, CommandType.StoredProcedure,
"PROC_PRODUCT_SEARCH", spParameter);
pTotal = Convert.ToInt32(spParameter[4].Value);
return(ds);
}
catch (Exception ex)
{
Logger.Log.Error(ex.ToString());
return(new DataSet());
}
}
/// <summary>
/// Genarate initial Request of Search product request
/// </summary>
/// <param name="categoryId">id of selected category</param>
/// <returns></returns>
private SearchProductRequest CreateInitialSearchRequest(string searchString)
{
SearchProductRequest request = new SearchProductRequest()
{
Index = 1,
NumberOfResultsPerPage = productPerPage,
SortBy = ProductsSortBy.ProductNameAToZ,
SearchString = searchString
};
return(request);
}
public async Task <IActionResult> searchProducts([FromQuery] SearchProductRequest request)
{
List <ProductViewModel> products = await _productService.SearchProducts(request);
List <CategoryViewModel> catetegories = null;
if (products != null)
{
catetegories = await _productService.getListCategoryByGeneralityName(products[0].category.generalityName);
}
return(Ok(new { products = products, categories = catetegories == null ? null : catetegories }));
}
public ActionResult Search(SearchProductRequest request)
{
request.K = UrlDecode(request.K);
if (!ProcessSqlStr(request.K))
{
request.K = String.Empty;
}
return(new RestfulResult {
Data = this._productDataService.Search(request)
});
}
/// <summary>
/// Genarate request object to get list matched products from service
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private SearchProductRequest GenarateSeachRequest(SearchProductRequest request)
{
SearchProductRequest productSeachRequest = new SearchProductRequest()
{
CategoryIds = request.CategoryIds,
BrandIds = request.BrandIds,
SortBy = request.SortBy,
Index = request.Index,
NumberOfResultsPerPage = productPerPage,
SearchString = request.SearchString
};
return(productSeachRequest);
}
/// <summary>
/// Get list product match conditions(seach string, best sell products, new products, sort, filter, paging...)
/// </summary>
/// <param name="request">condition filters</param>
/// <param name="searchType">seach type(seach string or best products or new products)</param>
/// <returns>list product matched with conditions</returns>
private IEnumerable <ecom_Products> GetAllProductsMatchingSearchString(SearchProductRequest request, SearchType searchType = SearchType.SearchString)
{
var searchQuery = PredicateBuilder.True <ecom_Products>();
if (request.SearchString != null && request.SearchString != string.Empty && searchType != SearchType.AllProduct)
{
searchQuery = searchQuery.And(p => p.Name.Contains(request.SearchString));
}
if (searchType == SearchType.NewProducts)
{
searchQuery = searchQuery.And(p => p.IsNewProduct == true);
}
if (searchType == SearchType.BestSellProducts)
{
searchQuery = searchQuery.And(p => p.IsBestSellProduct == true);
}
searchQuery = searchQuery.And(p => p.Status == (int)OnlineStore.Infractructure.Utility.Define.Status.Active);
IEnumerable <ecom_Products> productsMatchingRefinement = db.Get(
filter: searchQuery, includeProperties: "ecom_Brands,ecom_Categories");
switch (request.SortBy)
{
case ProductsSortBy.PriceLowToHigh:
productsMatchingRefinement = productsMatchingRefinement
.OrderBy(p => p.Price);
break;
case ProductsSortBy.PriceHighToLow:
productsMatchingRefinement = productsMatchingRefinement
.OrderByDescending(p => p.Price);
break;
case ProductsSortBy.ProductNameAToZ:
productsMatchingRefinement = productsMatchingRefinement
.OrderBy(p => p.Name);
break;
case ProductsSortBy.ProductNameZToA:
productsMatchingRefinement = productsMatchingRefinement
.OrderByDescending(p => p.Name);
break;
}
return(productsMatchingRefinement.ToList());
}
/// <summary>
/// Get ProductView contain list product of selected category
/// </summary>
/// <param name="id">id of category</param>
/// <returns></returns>
public ActionResult SearchProduct(string searchString, int?searchType)
{
SearchType type;
if (searchType == null)
{
type = SearchType.SearchString;
}
else
{
type = (SearchType)searchType;
}
SearchProductRequest request = CreateInitialSearchRequest(searchString);
SearchProductResponse response = service.SearchByProductName(request, type);
PopulateStatusDropDownList();
PopulateCategoryList();
switch (type)
{
case SearchType.AllProduct:
{
@ViewBag.SearchTitle = "Tất cả các sản phẩm";
break;
}
case SearchType.SearchString:
{
@ViewBag.SearchTitle = "Từ khóa : " + request.SearchString;
break;
}
case SearchType.NewProducts:
{
@ViewBag.SearchTitle = "Sản phẩm mới";
break;
}
case SearchType.BestSellProducts:
{
@ViewBag.SearchTitle = "Sản phẩm HOT";
break;
}
}
return(View("SearchResult", response));
}
public ActionResult ListProduct()
{
if (DataMemory.CurrentUser == null)
{
return(RedirectToAction("Logout", "Admin"));
}
var request = new SearchProductRequest()
{
CurrentPage = 1,
Start = 1,
End = ConfigInfo.RecordOnPage,
OrderBy = "ShortName",
OrderByType = "Asc"
};
return(View(FindProduct(request)));
}
GetTiresByFilter(SearchProductRequest filter, string[] filterPropertys)
{
try
{
using (var searchClient = new ProductSearchClient())
{
var searchResult = await searchClient.QueryTireListFilterValuesAsync(filter, filterPropertys.ToList());
searchResult.ThrowIfException(true);
return(searchResult?.Result);
}
}
catch (Exception ex)
{
_logger.Error($"查询轮胎列表失败 {JsonConvert.SerializeObject(filter)}", ex);
return(null);
}
}
/// <summary>
/// 查询商品信息
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public async Task <PagedModel <string> > SearchProduct(SearchProductRequest query)
{
try
{
using (var searchClient = new ProductSearchClient())
{
var searchResult = await searchClient.SearchProductAsync(query);
searchResult.ThrowIfException(true);
return(searchResult?.Result);
}
}
catch (Exception ex)
{
_logger.Error($"查询商品信息失败 {JsonConvert.SerializeObject(query)}", ex);
return(null);
}
}
/// <summary>
/// Search product by name
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public SearchProductResponse SearchByProductName(SearchProductRequest request, SearchType searchType)
{
IEnumerable <ecom_Products> foundProducts = GetAllProductsMatchingSearchString(request, searchType);
SearchProductResponse response = new SearchProductResponse()
{
CategoryIds = request.CategoryIds,
NumberOfTitlesFound = foundProducts.Count(),
TotalNumberOfPages = (int)Math.Ceiling((double)foundProducts.Count() / request.NumberOfResultsPerPage),
CurrentPage = request.Index,
SearchString = request.SearchString,
SortBy = (int)request.SortBy,
BrandIds = request.BrandIds,
Products = CropProductListToSatisfyGivenIndex(foundProducts, request.Index, request.NumberOfResultsPerPage).ConvertToProductSummaryViews(),
Brands = foundProducts.Select(p => p.ecom_Brands).Where(b => b != null).Distinct().ToList().ConvertToBrandSummaryViews()// return list Brand exist in group product belong to selected category
};
return(response);
}
public Task <GetAllProductResponse> getAllProduct(SearchProductRequest request)
{
GetAllProductResponse response = new GetAllProductResponse();
try
{
//dieu kien search
ProductModel productModel = new ProductModel();
productModel.Name = request.Name;
productModel.Code = request.Code;
productModel.PreservationId = request.StoreCondition;
List <DataProductResponse> datas = new List <DataProductResponse>();
PagedModel pagedModel = _service.Search(productModel, request.Page, request.PageSize);
if (pagedModel.Data != null)
{
foreach (ProductModel p in pagedModel.Data)
{
p.Unit = _unitService.Get(p.UnitId); //lay don vi tinh thong thuong
p.OtherUnitOfProduct = _unitService.GetALlOtherUnitOfProduct(p.Id); //lay don vi tinh trong bao gia
p.Preservation = _preservationService.Get(p.PreservationId);
DataProductResponse d = new DataProductResponse();
d.ID = p.Id;
d.UpdatedAt = p.UpdatedAt;
d.CreatedAt = p.CreatedAt;
d.ProductInfo = p;
datas.Add(d);
}
}
response.Data = datas;
response.Metadata = new Metadata();
response.Metadata.Page = pagedModel.Page;
response.Metadata.PageSize = pagedModel.PageSize;
response.Metadata.Total = pagedModel.PageTotal;
response.Success = true;
}
catch (Exception e)
{
response.Message = e.ToString();
response.Success = false;
}
return(Task.FromResult(response));
}
private ListProducts FindProduct(SearchProductRequest request)
{
var total = 0;
var ds = _productDa.SearchProduct(request, ref total);
var lstGroupProduct = CBO.Fill2ListFromDataSet <Products>(ds, typeof(Products));
var totalPage = Math.Ceiling(((decimal)total / ConfigInfo.RecordOnPage));
var paging = HtmlControllHelpers.WritePaging(totalPage, request.CurrentPage, total, ConfigInfo.RecordOnPage,
"nhóm sản phẩm");
var listGroupProducts = new ListProducts()
{
Start = request.Start,
Collection = lstGroupProduct,
Paging = paging,
TotalRecord = total,
TotalPage = totalPage,
CurrentPage = request.CurrentPage
};
return(listGroupProducts);
}
public async Task <PagingResponseMessage <ProductListResponse> > ProductList([FromBody] SearchProductRequest search)
{
var response = new PagingResponseMessage <ProductListResponse>()
{
Extension = new List <ProductListResponse> {
}
};
try
{
response = await _prodoctManager.ProductListAsync(search, HttpContext.RequestAborted);
}
catch (Exception e)
{
response.Code = ResponseCodeDefines.ServiceError;
response.Message = "商品列表查询失败，请重试";
_logger.LogInformation($"商品列表查询失败异常:{JsonHelper.ToJson(e)}");
}
return(response);
}
public SearchProductResponse SearchProduct(SearchProductRequest request)
{
SearchProductResponse res = new SearchProductResponse();
string strSP = SqlCommandStore.uspSearchProduct;
try
{
using (SqlCommand cmd = new SqlCommand(strSP))
{
cmd.Parameters.Add("ProductCode", SqlDbType.VarChar, 20).Value = request.ProductCode;
cmd.Parameters.Add("ProductName", SqlDbType.NVarChar, 100).Value = request.ProductName;
cmd.Parameters.Add("FromPrice", SqlDbType.Decimal, 18).Value = request.FromPrice;
cmd.Parameters.Add("ToPrice", SqlDbType.Decimal, 18).Value = request.ToPrice;
cmd.Parameters.Add("Status", SqlDbType.Int).Value = request.Status;
cmd.Parameters.Add("CategoryID", SqlDbType.BigInt).Value = request.CategoryID;
cmd.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;
DataSet ds = DB.ExecuteSPDataSet(cmd);
res.Code = (ReturnCode)Convert.ToInt32(cmd.Parameters["@Return"].Value);
if (res.Code != ReturnCode.Success)
{
DB.RollBackTran();
return(res);
}
DataRow[] rows = new DataRow[ds.Tables[0].Rows.Count];
rows = new DataRow[ds.Tables[0].Rows.Count];
ds.Tables[0].Rows.CopyTo(rows, 0);
res.products = rows.Select(row => new ProductModel(row)).ToList();
return(res);
}
}
catch (Exception ex)
{
LogWriter.WriteLogException(ex);
res.Code = ReturnCode.Fail;
return(res);
}
}
private static async Task <object> ResolveConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var includeFields = context.SubFields.Values.GetAllNodesPaths().Select(x => x.TrimStart("items.")).ToArray();
var request = new SearchProductRequest
{
Skip = skip,
Take = first ?? context.PageSize ?? 10,
Query = context.GetArgument <string>("query"),
Filter = context.GetArgument <string>("filter"),
Facet = context.GetArgument <string>("facet"),
Fuzzy = context.GetArgument <bool>("fuzzy"),
Sort = context.GetArgument <string>("sort"),
IncludeFields = includeFields.ToArray(),
};
var response = await mediator.Send(request);
return(new ProductsConnection <ExpProduct>()
{
Edges = response.Results
.Select((x, index) =>
new Edge <ExpProduct>()
{
Cursor = (skip + index).ToString(),
Node = x,
})
.ToList(),
PageInfo = new PageInfo()
{
HasNextPage = response.TotalCount > (skip + first),
HasPreviousPage = skip > 0,
StartCursor = skip.ToString(),
EndCursor = Math.Min(response.TotalCount, (int)(skip + first)).ToString()
},
TotalCount = response.TotalCount,
Facets = response.Facets
});
}
public virtual async Task <IEnumerable <SitemapEntry> > GetEntriesAsync(SitemapParams param, CultureInfo culture, int offset, int count)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (string.IsNullOrWhiteSpace(param.BaseUrl))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.BaseUrl)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
if (culture == null)
{
throw new ArgumentNullException(nameof(culture));
}
var request = new SearchProductRequest
{
ScopeId = param.Scope,
CultureName = culture.Name,
Keywords = "*",
StartingIndex = offset,
MaximumItems = count,
VariantGroupingStrategy = SearchVariantGroupingStrategy.PerProduct,
};
var response = await _overtureClient.SendAsync(request).ConfigureAwait(false);
if (!response.Documents.Any())
{
return(Enumerable.Empty <SitemapEntry>());
}
return(CreateStandardSitemapEntries(param, response.Documents, culture));
}
public IEnumerable <SearchProductResponse> GetProducts(SearchProductRequest searchProductRequest)
{
var searchID = searchProductRequest.SearchID;
var searchName = searchProductRequest.SearchName;
List <Product> products;
if (searchID > 0)
{
products = _service.GetProducts(searchID).ToList();
if (products != null)
{
return(ProductsToResponses(products));
}
}
else
{
products = _service.GetProducts(searchName).ToList();
if (products.Count > 0)
{
return(ProductsToResponses(products));
}
}
return(null);
}
public ActionResult CalculatorPaint()
{
try
{
var request = new SearchProductRequest()
{
CurrentPage = 1,
Start = 1,
End = 1000,
OrderBy = "ShortName",
OrderByType = "Asc"
};
var total = 0;
var ds = _productDa.SearchProduct(request, ref total);
var lstGroupProduct = CBO <Products> .FillCollectionFromDataSet(ds);
ViewBag.LstProduct = lstGroupProduct;
}
catch (Exception e)
{
Logger.Log.Error(e.ToString());
}
return(View());
}
public ActionResult Index(SearchProductRequest request)
{
var products = _productAService.GetProducts(request);
return(View(products));
}
/// <summary>
/// 查询产品
/// </summary>
/// <param name="title"></param>
/// <param name="orderParamters"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public ResponseView <PagingResultView <SkuPageListView> > SearchProductPaging(SearchProductRequest request)
{
var pagingModel = _skuRepository.PagingResult(request.keyword,
request.GetOrderParamter(),
request.page_index,
request.page_size);
var data = SkuPageListView.ToPagingResultView(pagingModel);
var result = base.OutPutBrokenResponseView(data);
return(result);
}
public ResponseView <PagingResultView <SkuPageListView> > PostPaging(SearchProductRequest request)
{
var r = ProductCatalogService.SearchProductPaging(request);
return(r);
}
public async Task <IActionResult> Get([FromQuery] SearchProductRequest request)
{
var result = await _ProductAppService.getAllProduct(request);
return(Ok(result));
}
public List <Product> Search(SearchProductRequest reqModel)
{
return(_productRepository.Search(reqModel).ToList());
}
public List <ActiveProductListResponse> SearchProduct(SearchProductRequest searchProductRequest)
{
return(productService.SearchProduct(searchProductRequest));
}
