public CatalogProduct[] GetByIds(string[] itemIds, ItemResponseGroup respGroup, string catalogId = null)
{
var cacheKey = GetCacheKey("ItemService.GetByIds", string.Join(", ", itemIds), respGroup.ToString(), catalogId);
var retVal = _cacheManager.Get(cacheKey, RegionName, () => _itemService.GetByIds(itemIds, respGroup, catalogId));
return(retVal);
}
public virtual async Task <Product[]> GetProductsAsync(string[] ids, ItemResponseGroup responseGroup = ItemResponseGroup.None)
{
Product[] result;
if (ids.IsNullOrEmpty())
{
result = new Product[0];
}
else
{
var workContext = _workContextAccessor.WorkContext;
if (responseGroup == ItemResponseGroup.None)
{
responseGroup = workContext.CurrentProductResponseGroup;
}
result = await GetProductsAsync(ids, responseGroup, workContext);
var productsWithVariations = result.Concat(result.SelectMany(p => p.Variations)).ToList();
await LoadProductDependencies(productsWithVariations, responseGroup, workContext);
}
return(result);
}
protected virtual void LoadVariationsByParentIds(string[] parentIds, ItemResponseGroup respGroup)
{
// TODO: Call GetItemByIds for variations recursively (need to measure performance and data amount first)
var variationIds = Items.Where(x => parentIds.Contains(x.ParentId)).Select(x => x.Id).ToArray();
if (!variationIds.IsNullOrEmpty())
{
// Always load info, images and property values for variations
var variations = Items.Include(x => x.Images).Where(x => variationIds.Contains(x.Id)).ToArray();
if (variations.Any())
{
variationIds = variations.Select(x => x.Id).ToArray();
var variationPropertyValues = PropertyValues.Include(x => x.DictionaryItem.DictionaryItemValues).Where(x => variationIds.Contains(x.ItemId)).ToArray();
if (respGroup.HasFlag(ItemResponseGroup.ItemAssets))
{
var variationAssets = Assets.Where(x => variationIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(ItemResponseGroup.ItemEditorialReviews))
{
var variationEditorialReviews = EditorialReviews.Where(x => variationIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(ItemResponseGroup.Links))
{
var variationLinks = CategoryItemRelations.Where(x => variationIds.Contains(x.ItemId)).ToArray();
}
}
}
}
public async Task <Product> GetProductAsync(string id, ItemResponseGroup responseGroup = ItemResponseGroup.ItemInfo)
{
var item = (await _catalogModuleApi.CatalogModuleProductsGetProductByIdAsync(id)).ToWebModel(_workContext.CurrentLanguage, _workContext.CurrentCurrency);
var allProducts = new[] { item }.Concat(item.Variations).ToArray();
var taskList = new List <Task>();
if ((responseGroup | ItemResponseGroup.ItemWithPrices) == responseGroup)
{
var loadPricesTask = Task.Factory.StartNew(() =>
{
LoadProductsPrices(allProducts);
if ((responseGroup | ItemResponseGroup.ItemWithDiscounts) == responseGroup)
{
LoadProductsDiscountsAsync(allProducts).Wait();
}
});
taskList.Add(loadPricesTask);
}
if ((responseGroup | ItemResponseGroup.ItemWithInventories) == responseGroup)
{
taskList.Add(Task.Factory.StartNew(() => LoadProductsInventories(allProducts)));
}
Task.WaitAll(taskList.ToArray());
return(item);
}
public async Task <Product[]> GetProductsAsync(string[] ids, ItemResponseGroup responseGroup = ItemResponseGroup.ItemInfo)
{
var workContext = _workContextFactory();
var retVal = (await _catalogModuleApi.CatalogModuleProductsGetProductByIdsAsync(ids.ToList())).Select(x => x.ToWebModel(workContext.CurrentLanguage, workContext.CurrentCurrency)).ToArray();
var allProducts = retVal.Concat(retVal.SelectMany(x => x.Variations)).ToArray();
if (allProducts != null && allProducts.Any())
{
var taskList = new List <Task>();
if ((responseGroup | ItemResponseGroup.ItemWithInventories) == responseGroup)
{
taskList.Add(LoadProductsInventoriesAsync(allProducts));
}
if ((responseGroup | ItemResponseGroup.ItemWithPrices) == responseGroup)
{
await _pricingService.EvaluateProductPricesAsync(allProducts);
if ((responseGroup | ItemResponseGroup.ItemWithDiscounts) == responseGroup)
{
await LoadProductsDiscountsAsync(allProducts);
}
}
await Task.WhenAll(taskList.ToArray());
}
return(retVal);
}
public async Task<Product> GetProductAsync(string id, ItemResponseGroup responseGroup = ItemResponseGroup.ItemInfo)
{
var item = (await _catalogModuleApi.CatalogModuleProductsGetAsync(id)).ToWebModel(_workContext.CurrentLanguage, _workContext.CurrentCurrency);
var allProducts = new[] { item }.Concat(item.Variations).ToArray();
var taskList = new List<Task>();
if ((responseGroup | ItemResponseGroup.ItemWithPrices) == responseGroup)
{
var loadPricesTask = Task.Factory.StartNew(() =>
{
LoadProductsPrices(allProducts);
if ((responseGroup | ItemResponseGroup.ItemWithDiscounts) == responseGroup)
{
LoadProductsDiscountsAsync(allProducts).Wait();
}
});
taskList.Add(loadPricesTask);
}
if ((responseGroup | ItemResponseGroup.ItemWithInventories) == responseGroup)
{
taskList.Add(Task.Factory.StartNew(() => LoadProductsInventories(allProducts)));
}
Task.WaitAll(taskList.ToArray());
return item;
}
private IEnumerable <CatalogItem> InnerGetProductsByIds(String[] ids, ItemResponseGroup responseGroup)
{
var retVal = new List <CatalogItem>();
var products = _itemService.GetByIds(ids, responseGroup);
foreach (var product in products)
{
coreModel.Property[] properties = null;
if ((responseGroup & ItemResponseGroup.ItemProperties) == ItemResponseGroup.ItemProperties)
{
properties = GetAllProductProperies(product);
}
if (product != null)
{
var webModelProduct = product.ToWebModel(_blobUrlResolver, properties);
if (product.CategoryId != null)
{
var category = _categoryService.GetById(product.CategoryId);
webModelProduct.Outline = string.Join("/", category.Parents.Select(x => x.Id)) + "/" + category.Id;
}
retVal.Add(webModelProduct);
}
}
return(retVal);
}
public virtual async Task <Product[]> GetProductsAsync(string[] ids, ItemResponseGroup responseGroup = ItemResponseGroup.None)
{
Product[] result;
if (ids.IsNullOrEmpty())
{
result = new Product[0];
}
else
{
var workContext = _workContextFactory();
if (responseGroup == ItemResponseGroup.None)
{
responseGroup = workContext.CurrentProductResponseGroup;
}
result = await GetProductsAsync(ids, responseGroup, workContext);
var allProducts = result.Concat(result.SelectMany(p => p.Variations)).ToList();
if (!allProducts.IsNullOrEmpty())
{
var taskList = new List <Task>();
if (responseGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
taskList.Add(LoadProductAssociationsAsync(allProducts));
}
if (responseGroup.HasFlag(ItemResponseGroup.Inventory))
{
taskList.Add(LoadProductInventoriesAsync(allProducts));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithPrices))
{
taskList.Add(_pricingService.EvaluateProductPricesAsync(allProducts, workContext));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithVendor))
{
taskList.Add(LoadProductVendorsAsync(allProducts, workContext));
}
if (workContext.CurrentStore.SubscriptionEnabled && responseGroup.HasFlag(ItemResponseGroup.ItemWithPaymentPlan))
{
taskList.Add(LoadProductPaymentPlanAsync(allProducts, workContext));
}
await Task.WhenAll(taskList.ToArray());
}
}
return(result);
}
/// <summary>
/// Reduce product details according to response group
/// </summary>
/// <param name="product"></param>
/// <param name="respGroup"></param>
protected virtual void ReduceDetails(CatalogProduct product, ItemResponseGroup respGroup)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
product.ReduceDetails(respGroup.ToString());
}
public virtual CatalogProduct GetById(string itemId, ItemResponseGroup respGroup, string catalogId = null)
{
CatalogProduct result = null;
if (!string.IsNullOrEmpty(itemId))
{
var results = GetByIds(new[] { itemId }, respGroup, catalogId);
result = results.Any() ? results.First() : null;
}
return(result);
}
public async Task <ActionResult <ListEntrySearchResult> > ListItemsSearchAsync([FromBody] CatalogListEntrySearchCriteria criteria)
{
var result = new ListEntrySearchResult();
var useIndexedSearch = _settingsManager.GetValue(ModuleConstants.Settings.Search.UseCatalogIndexedSearchInManager.Name, true);
var authorizationResult = await _authorizationService.AuthorizeAsync(User, criteria, new CatalogAuthorizationRequirement(ModuleConstants.Security.Permissions.Read));
if (!authorizationResult.Succeeded)
{
return(Unauthorized());
}
if (useIndexedSearch && !string.IsNullOrEmpty(criteria.Keyword))
{
// TODO: create outline for category
// TODO: implement sorting
var categoryIndexedSearchCriteria = AbstractTypeFactory <CategoryIndexedSearchCriteria> .TryCreateInstance().FromListEntryCriteria(criteria) as CategoryIndexedSearchCriteria;
const CategoryResponseGroup catResponseGroup = CategoryResponseGroup.Info | CategoryResponseGroup.WithOutlines;
categoryIndexedSearchCriteria.ResponseGroup = catResponseGroup.ToString();
var catIndexedSearchResult = await _categoryIndexedSearchService.SearchAsync(categoryIndexedSearchCriteria);
var totalCount = catIndexedSearchResult.TotalCount;
var skip = Math.Min(totalCount, criteria.Skip);
var take = Math.Min(criteria.Take, Math.Max(0, totalCount - criteria.Skip));
result.Results = catIndexedSearchResult.Items.Select(x => AbstractTypeFactory <CategoryListEntry> .TryCreateInstance().FromModel(x)).ToList();
criteria.Skip -= (int)skip;
criteria.Take -= (int)take;
const ItemResponseGroup itemResponseGroup = ItemResponseGroup.ItemInfo | ItemResponseGroup.Outlines;
var productIndexedSearchCriteria = AbstractTypeFactory <ProductIndexedSearchCriteria> .TryCreateInstance().FromListEntryCriteria(criteria) as ProductIndexedSearchCriteria;
productIndexedSearchCriteria.ResponseGroup = itemResponseGroup.ToString();
var indexedSearchResult = await _productIndexedSearchService.SearchAsync(productIndexedSearchCriteria);
result.TotalCount += (int)indexedSearchResult.TotalCount;
result.Results.AddRange(indexedSearchResult.Items.Select(x => AbstractTypeFactory <ProductListEntry> .TryCreateInstance().FromModel(x)));
}
else
{
result = await _listEntrySearchService.SearchAsync(criteria);
}
return(Ok(result));
}
public virtual CatalogProduct[] GetByIds(string[] itemIds, ItemResponseGroup respGroup, string catalogId = null)
{
var result = Array.Empty <CatalogProduct>();
if (!itemIds.IsNullOrEmpty())
{
using (var repository = _repositoryFactory())
{
//Optimize performance and CPU usage
repository.DisableChangesTracking();
result = repository.GetItemByIds(itemIds, respGroup)
.Select(x => x.ToModel(AbstractTypeFactory <CatalogProduct> .TryCreateInstance()))
.ToArray();
}
if (result.Any())
{
LoadDependencies(result);
ApplyInheritanceRules(result);
var productsWithVariationsList = result.Concat(result.Where(p => p.Variations != null)
.SelectMany(p => p.Variations));
// Fill outlines for products and variations
if (respGroup.HasFlag(ItemResponseGroup.Outlines))
{
_outlineService.FillOutlinesForObjects(productsWithVariationsList, catalogId);
}
// Fill SEO info for products, variations and outline items
if ((respGroup & ItemResponseGroup.Seo) == ItemResponseGroup.Seo)
{
var objectsWithSeo = productsWithVariationsList.OfType <ISeoSupport>().ToList();
//Load SEO information for all Outline.Items
var outlineItems = productsWithVariationsList.Where(p => p.Outlines != null)
.SelectMany(p => p.Outlines.SelectMany(o => o.Items));
objectsWithSeo.AddRange(outlineItems);
_commerceService.LoadSeoForObjects(objectsWithSeo.ToArray());
}
//Reduce details according to response group
foreach (var product in productsWithVariationsList)
{
ReduceDetails(product, respGroup);
}
}
}
return(result);
}
/// <summary>
/// Reduce product details according to response group
/// </summary>
/// <param name="product"></param>
/// <param name="respGroup"></param>
protected virtual void ReduceDetails(CatalogProduct product, ItemResponseGroup respGroup)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemAssets))
{
product.Assets = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
product.Associations = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ReferencedAssociations))
{
product.ReferencedAssociations = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemEditorialReviews))
{
product.Reviews = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Inventory))
{
product.Inventories = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemProperties))
{
product.Properties = null;
product.PropertyValues = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Links))
{
product.Links = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Outlines))
{
product.Outlines = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Seo))
{
product.SeoInfos = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Variations))
{
product.Variations = null;
}
}
public CatalogProduct[] GetByIds(string[] itemIds, ItemResponseGroup respGroup, string catalogId = null)
{
var retVal = _productService.GetByIds(itemIds, respGroup, catalogId).ToList();
var foundIds = retVal.Select(x => x.Id).ToArray();
var taobaoProductIds = itemIds.Except(foundIds).Concat(retVal.Where(x => x.CatalogId.EqualsInvariant(_taobaoCatalog.Id)).Select(x => x.Id)).ToArray();
foreach (var taobaoProductId in taobaoProductIds)
{
var request = new ItemGetRequest()
{
NumIid = Convert.ToInt64(taobaoProductId),
Fields = @"num_iid,title,nick,type,cid,seller_cids,props,pic_url,num,modified,product_id,item_img,prop_img,sku,video,outer_id,skus, desc",
};
var itemGetResponse = _topClient.Execute <ItemGetResponse>(request);
if (itemGetResponse.Item != null)
{
var topItem = itemGetResponse.Item;
var product = new dataModel.Item()
{
CatalogId = _taobaoCatalog.Id
}.ToCoreModel(base.AllCachedCatalogs, base.AllCachedCategories);
product.Id = topItem.NumIid.ToString();
product.Catalog = _taobaoCatalog;
product.CatalogId = _taobaoCatalog.Id;
product.Code = topItem.Num.ToString();
product.Name = topItem.Title;
product.Images = new Image[] { new Image {
Url = topItem.PicUrl
} };
product.Reviews = new EditorialReview[] { new EditorialReview {
ReviewType = "Description", LanguageCode = "en-US", Content = topItem.Desc
} };
var existProduct = retVal.FirstOrDefault(x => x.Id == topItem.NumIid.ToString());
if (existProduct != null)
{
existProduct.Images = product.Images;
existProduct.Reviews = product.Reviews;
}
else
{
retVal.Add(product);
}
}
}
return(retVal.ToArray());
}
public async Task <Product[]> GetProductsAsync(string[] ids, ItemResponseGroup responseGroup = ItemResponseGroup.None)
{
var workContext = _workContextFactory();
if (responseGroup == ItemResponseGroup.None)
{
responseGroup = workContext.CurrentProductResponseGroup;
}
var retVal = (await _catalogModuleApi.CatalogModuleProductsGetProductByIdsAsync(ids.ToList(), ((int)responseGroup).ToString())).Select(x => x.ToWebModel(workContext.CurrentLanguage, workContext.CurrentCurrency, workContext.CurrentStore)).ToArray();
var allProducts = retVal.Concat(retVal.SelectMany(x => x.Variations)).ToList();
if (!allProducts.IsNullOrEmpty())
{
var taskList = new List <Task>();
if (responseGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
taskList.Add(LoadProductAssociationsAsync(allProducts));
}
if (responseGroup.HasFlag(ItemResponseGroup.Inventory))
{
taskList.Add(LoadProductInventoriesAsync(allProducts));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithPrices))
{
await _pricingService.EvaluateProductPricesAsync(allProducts);
if ((responseGroup | ItemResponseGroup.ItemWithDiscounts) == responseGroup)
{
await LoadProductDiscountsAsync(allProducts);
}
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithVendor))
{
await LoadProductVendorsAsync(allProducts);
}
await Task.WhenAll(taskList.ToArray());
}
return(retVal);
}
private static Item[] GetItemsByIds(string[] itemIds, ItemResponseGroup responseGroup)
{
var result = _items.Where(c => itemIds.Contains(c.Id)).ToArray();
var withLinks = (responseGroup & ItemResponseGroup.Links) == ItemResponseGroup.Links;
foreach (var item in result)
{
item.Catalog = _catalogs.FirstOrDefault(c => c.Id == item.CatalogId);
if (withLinks)
{
item.CategoryLinks = new ObservableCollection <CategoryItemRelation>(_categoryItemRelations.Where(r => r.ItemId == item.Id));
}
}
return(result);
}
protected virtual void ReduceSearchResult(ISearchCriteria criteria, ItemResponseGroup responseGroup, catalogModel.Product product)
{
if (!responseGroup.HasFlag(ItemResponseGroup.ItemAssets))
{
product.Assets = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
product.Associations = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.ItemEditorialReviews))
{
product.Reviews = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.ItemInfo))
{
product.Properties = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.Links))
{
product.Links = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.Outlines))
{
product.Outlines = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.Seo))
{
product.SeoInfos = null;
}
if (!responseGroup.HasFlag(ItemResponseGroup.Variations))
{
product.Variations = null;
}
}
public virtual SearchResult Search(SearchCriteria criteria)
{
SearchResult result;
var useIndexedSearch = _settingsManager.GetValue("Catalog.Search.UseCatalogIndexedSearchInManager", true);
var searchProducts = criteria.ResponseGroup.HasFlag(SearchResponseGroup.WithProducts);
if (useIndexedSearch && searchProducts && !string.IsNullOrEmpty(criteria.Keyword))
{
result = new SearchResult();
// TODO: create outline for category
// TODO: implement sorting
const ItemResponseGroup responseGroup = ItemResponseGroup.ItemInfo | ItemResponseGroup.Outlines;
var serviceCriteria = AbstractTypeFactory <ProductSearchCriteria> .TryCreateInstance();
serviceCriteria.ObjectType = KnownDocumentTypes.Product;
serviceCriteria.SearchPhrase = criteria.Keyword;
serviceCriteria.CatalogId = criteria.CatalogId;
serviceCriteria.Outline = criteria.CategoryId;
serviceCriteria.WithHidden = criteria.WithHidden;
serviceCriteria.Skip = criteria.Skip;
serviceCriteria.Take = criteria.Take;
serviceCriteria.ResponseGroup = responseGroup.ToString();
serviceCriteria.Sort = criteria.Sort;
SearchItems(result, serviceCriteria, responseGroup);
}
else
{
// use original implementation from catalog module
result = _catalogSearchService.Search(criteria);
}
return(result);
}
public async Task <ActionResult <ListEntrySearchResult> > ListItemsSearchAsync([FromBody] CatalogListEntrySearchCriteria criteria)
{
//TODO:
//ApplyRestrictionsForCurrentUser(coreModelCriteria);
var result = new ListEntrySearchResult();
var useIndexedSearch = _settingsManager.GetValue(ModuleConstants.Settings.Search.UseCatalogIndexedSearchInManager.Name, true);
if (useIndexedSearch && !string.IsNullOrEmpty(criteria.Keyword))
{
// TODO: create outline for category
// TODO: implement sorting
const ItemResponseGroup responseGroup = ItemResponseGroup.ItemInfo | ItemResponseGroup.Outlines;
var productIndexedSearchCriteria = AbstractTypeFactory <ProductIndexedSearchCriteria> .TryCreateInstance();
productIndexedSearchCriteria.ObjectType = KnownDocumentTypes.Product;
productIndexedSearchCriteria.Keyword = criteria.Keyword;
productIndexedSearchCriteria.CatalogId = criteria.CatalogId;
productIndexedSearchCriteria.Outline = criteria.CategoryId;
productIndexedSearchCriteria.WithHidden = !criteria.HideDirectLinkedCategories;
productIndexedSearchCriteria.Skip = criteria.Skip;
productIndexedSearchCriteria.Take = criteria.Take;
productIndexedSearchCriteria.ResponseGroup = responseGroup.ToString();
productIndexedSearchCriteria.Sort = criteria.Sort;
var indexedSearchResult = await _productIndexedSearchService.SearchAsync(productIndexedSearchCriteria);
result.TotalCount = (int)indexedSearchResult.TotalCount;
result.Results = indexedSearchResult.Items.Select(x => AbstractTypeFactory <ProductListEntry> .TryCreateInstance().FromModel(x)).ToList();
}
else
{
result = await _listEntrySearchService.SearchAsync(criteria);
}
return(Ok(result));
}
public async Task<Product[]> GetProductsAsync(string[] ids, ItemResponseGroup responseGroup = ItemResponseGroup.ItemInfo)
{
var workContext = _workContextFactory();
var retVal = (await _catalogModuleApi.CatalogModuleProductsGetProductByIdsAsync(ids.ToList(), ((int)responseGroup).ToString())).Select(x => x.ToWebModel(workContext.CurrentLanguage, workContext.CurrentCurrency, workContext.CurrentStore)).ToArray();
var allProducts = retVal.Concat(retVal.SelectMany(x => x.Variations)).ToArray();
if (!allProducts.IsNullOrEmpty())
{
var taskList = new List<Task>();
if (responseGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
taskList.Add(LoadProductsAssociationsAsync(allProducts));
}
if (responseGroup.HasFlag(ItemResponseGroup.Inventory))
{
taskList.Add(LoadProductsInventoriesAsync(allProducts));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithPrices))
{
await _pricingService.EvaluateProductPricesAsync(allProducts);
if ((responseGroup | ItemResponseGroup.ItemWithDiscounts) == responseGroup)
{
await LoadProductsDiscountsAsync(allProducts);
}
}
await Task.WhenAll(taskList.ToArray());
}
return retVal;
}
protected virtual void SearchItems(SearchResult result, ProductSearchCriteria criteria, ItemResponseGroup responseGroup)
{
Task.Run(() => SearchItemsAsync(result, criteria, responseGroup)).GetAwaiter().GetResult();
}
private IEnumerable<CatalogItem> InnerGetProductsByIds(storeModel.Store store, String[] ids, ItemResponseGroup responseGroup)
{
var retVal = new List<CatalogItem>();
var products = _itemService.GetByIds(ids, responseGroup);//.Where(p=>p.CatalogId == store.Catalog);
foreach (var product in products)
{
coreModel.Property[] properties = null;
if ((responseGroup & ItemResponseGroup.ItemProperties) == ItemResponseGroup.ItemProperties)
{
properties = GetAllProductProperies(product);
}
if (product != null)
{
var webModelProduct = product.ToWebModel(_blobUrlResolver, properties);
if (product.CategoryId != null)
{
var category = _categoryService.GetById(product.CategoryId);
webModelProduct.Outline = string.Join("/", category.Parents.Select(x => x.Id)) + "/" + category.Id;
}
retVal.Add(webModelProduct);
}
}
if ((responseGroup & ItemResponseGroup.Inventory) == ItemResponseGroup.Inventory)
{
this.PopulateInventory(store.FulfillmentCenter, retVal);
}
return retVal;
}
public virtual CatalogProduct GetById(string itemId, ItemResponseGroup respGroup, string catalogId = null)
{
var results = GetByIds(new[] { itemId }, respGroup, catalogId);
return(results.Any() ? results.First() : null);
}
private static Item[] GetItemsByIds(string[] itemIds, ItemResponseGroup responseGroup)
{
var result = _items.Where(c => itemIds.Contains(c.Id)).ToArray();
var withLinks = (responseGroup & ItemResponseGroup.Links) == ItemResponseGroup.Links;
foreach (var item in result)
{
item.Catalog = _catalogs.FirstOrDefault(c => c.Id == item.CatalogId);
if (withLinks)
{
item.CategoryLinks = new ObservableCollection<CategoryItemRelation>(_categoryItemRelations.Where(r => r.ItemId == item.Id));
}
}
return result;
}
protected virtual async Task <Product[]> GetProductsAsync(IList <string> ids, ItemResponseGroup responseGroup, WorkContext workContext)
{
var productDtos = await _catalogModuleApi.CatalogModuleProducts.GetProductByPlentyIdsAsync(ids, ((int)responseGroup).ToString());
var result = productDtos.Select(x => x.ToProduct(workContext.CurrentLanguage, workContext.CurrentCurrency, workContext.CurrentStore)).ToArray();
return(result);
}
public async Task<ActionResult> GetProductsByIds(string[] productIds, ItemResponseGroup respGroup = ItemResponseGroup.ItemLarge)
{
var retVal = await _catalogSearchService.GetProductsAsync(productIds, respGroup);
return Json(retVal);
}
protected virtual async Task <Product[]> GetProductsAsync(IList <string> ids, ItemResponseGroup responseGroup, WorkContext workContext)
{
var cacheKey = CacheKey.With(GetType(), "GetProductsAsync", string.Join("-", ids.OrderBy(x => x)), responseGroup.ToString());
var result = await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(CatalogCacheRegion.CreateChangeToken());
cacheEntry.AddExpirationToken(_apiChangesWatcher.CreateChangeToken());
return(await _productsApi.GetProductByPlentyIdsAsync(ids, ((int)responseGroup).ToString()));
});
return(result.Select(x => x.ToProduct(workContext.CurrentLanguage, workContext.CurrentCurrency, workContext.CurrentStore)).ToArray());
}
protected virtual async Task LoadProductDependencies(List <Product> products, ItemResponseGroup responseGroup, WorkContext workContext)
{
if (products.IsNullOrEmpty())
{
return;
}
var taskList = new List <Task>();
taskList
.AddIf(responseGroup.HasFlag(ItemResponseGroup.Inventory),
() => LoadProductInventoriesAsync(products, workContext))
.AddIf(responseGroup.HasFlag(ItemResponseGroup.ItemAssociations),
() => LoadProductsAssociationsAsync(products, workContext))
.AddIf(responseGroup.HasFlag(ItemResponseGroup.ItemWithPrices),
() => _pricingService.EvaluateProductPricesAsync(products, workContext))
.AddIf(responseGroup.HasFlag(ItemResponseGroup.ItemWithVendor),
() => LoadProductVendorsAsync(products, workContext))
.AddIf(workContext.CurrentStore.SubscriptionEnabled &&
responseGroup.HasFlag(ItemResponseGroup.ItemWithPaymentPlan),
() => LoadProductPaymentPlanAsync(products, workContext))
.AddIf(workContext.CurrentStore.CustomerReviewsEnabled,
() => LoadProductCustomerReviewsAsync(products));
await Task.WhenAll(taskList);
foreach (var product in products)
{
product.IsBuyable = new ProductIsBuyableSpecification().IsSatisfiedBy(product);
product.IsAvailable = new ProductIsAvailableSpecification(product).IsSatisfiedBy(1);
product.IsInStock = new ProductIsInStockSpecification().IsSatisfiedBy(product);
}
}
public async Task <ActionResult> GetProductsByIds(string[] productIds, ItemResponseGroup respGroup = ItemResponseGroup.ItemLarge)
{
var retVal = await _catalogService.GetProductsAsync(productIds, respGroup);
return(Json(retVal));
}
public virtual async Task <Product[]> GetProductsAsync(string[] ids, ItemResponseGroup responseGroup = ItemResponseGroup.None)
{
Product[] result;
if (ids.IsNullOrEmpty())
{
result = new Product[0];
}
else
{
var workContext = _workContextAccessor.WorkContext;
if (responseGroup == ItemResponseGroup.None)
{
responseGroup = workContext.CurrentProductResponseGroup;
}
result = await GetProductsAsync(ids, responseGroup, workContext);
var allProducts = result.Concat(result.SelectMany(p => p.Variations)).ToList();
if (!allProducts.IsNullOrEmpty())
{
var taskList = new List <Task>();
if (responseGroup.HasFlag(ItemResponseGroup.Inventory))
{
taskList.Add(LoadProductInventoriesAsync(allProducts, workContext));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
taskList.Add(LoadProductsAssociationsAsync(allProducts, workContext));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithPrices))
{
taskList.Add(_pricingService.EvaluateProductPricesAsync(allProducts, workContext));
}
if (responseGroup.HasFlag(ItemResponseGroup.ItemWithVendor))
{
taskList.Add(LoadProductVendorsAsync(allProducts, workContext));
}
if (workContext.CurrentStore.SubscriptionEnabled && responseGroup.HasFlag(ItemResponseGroup.ItemWithPaymentPlan))
{
taskList.Add(LoadProductPaymentPlanAsync(allProducts, workContext));
}
taskList.Add(LoadProductCustomerReviewsAsync(allProducts, workContext));
await Task.WhenAll(taskList.ToArray());
foreach (var product in allProducts)
{
product.IsBuyable = new ProductIsBuyableSpecification().IsSatisfiedBy(product);
product.IsAvailable = new ProductIsAvailableSpecification(product).IsSatisfiedBy(1);
product.IsInStock = new ProductIsInStockSpecification().IsSatisfiedBy(product);
}
}
}
return(result);
}
private ProductSearchResult SearchProducts(string scope, string storeId, ProductSearch criteria, ItemResponseGroup responseGroup)
{
var store = _storeService.GetById(storeId);
if (store == null)
{
return(null);
}
var context = new Dictionary <string, object>
{
{ "Store", store },
};
var filters = _browseFilterService.GetFilters(context);
var serviceCriteria = criteria.AsCriteria <CatalogItemSearchCriteria>(store.Catalog, filters);
var searchResults = _browseService.SearchItems(scope, serviceCriteria, responseGroup);
return(searchResults);
}
public virtual CatalogProduct[] GetByIds(string[] itemIds, ItemResponseGroup respGroup, string catalogId = null)
{
CatalogProduct[] result;
using (var repository = _repositoryFactory())
{
//Optimize performance and CPU usage
repository.DisableChangesTracking();
result = repository.GetItemByIds(itemIds, respGroup)
.Select(x => x.ToModel(AbstractTypeFactory <CatalogProduct> .TryCreateInstance()))
.ToArray();
}
LoadDependencies(result);
ApplyInheritanceRules(result);
// Fill outlines for products
if (respGroup.HasFlag(ItemResponseGroup.Outlines))
{
_outlineService.FillOutlinesForObjects(result, catalogId);
}
// Fill SEO info for products, variations and outline items
if ((respGroup & ItemResponseGroup.Seo) == ItemResponseGroup.Seo)
{
var objectsWithSeo = new List <ISeoSupport>(result);
var variations = result.Where(p => p.Variations != null)
.SelectMany(p => p.Variations);
objectsWithSeo.AddRange(variations);
var outlineItems = result.Where(p => p.Outlines != null)
.SelectMany(p => p.Outlines.SelectMany(o => o.Items));
objectsWithSeo.AddRange(outlineItems);
_commerceService.LoadSeoForObjects(objectsWithSeo.ToArray());
}
//Reduce details according to response group
foreach (var product in result)
{
if (!respGroup.HasFlag(ItemResponseGroup.ItemAssets))
{
product.Assets = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemAssociations))
{
product.Associations = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ReferencedAssociations))
{
product.ReferencedAssociations = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemEditorialReviews))
{
product.Reviews = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Inventory))
{
product.Inventories = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.ItemProperties))
{
product.Properties = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Links))
{
product.Links = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Outlines))
{
product.Outlines = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Seo))
{
product.SeoInfos = null;
}
if (!respGroup.HasFlag(ItemResponseGroup.Variations))
{
product.Variations = null;
}
}
return(result);
}
public virtual ProductSearchResult SearchItems(string scope, ISearchCriteria criteria, ItemResponseGroup responseGroup)
{
var result = new ProductSearchResult();
var searchResults = _searchProvider.Search <DocumentDictionary>(scope, criteria);
if (searchResults != null)
{
var returnProductsFromIndex = _settingsManager.GetValue("VirtoCommerce.SearchApi.UseFullObjectIndexStoring", true);
result.TotalCount = searchResults.TotalCount;
result.Aggregations = ConvertFacetsToAggregations(searchResults.Facets, criteria);
result.Products = ConvertDocumentsToProducts(searchResults.Documents?.ToList(), returnProductsFromIndex, criteria, responseGroup);
}
return(result);
}
protected virtual catalogModel.Product[] ConvertDocumentsToProducts(IList <DocumentDictionary> documents, bool returnProductsFromIndex, ISearchCriteria criteria, ItemResponseGroup responseGroup)
{
catalogModel.Product[] result = null;
if (documents != null && documents.Any())
{
var productsMap = documents.ToDictionary(doc => doc.Id.ToString(), doc => returnProductsFromIndex ? doc.GetObjectFieldValue <catalogModel.Product>() : null);
var missingProductIds = productsMap
.Where(kvp => kvp.Value == null)
.Select(kvp => kvp.Key)
.ToArray();
if (missingProductIds.Any())
{
// Load items from repository
var catalog = (criteria as CatalogItemSearchCriteria)?.Catalog;
var catalogProducts = _itemService.GetByIds(missingProductIds, responseGroup, catalog);
foreach (var product in catalogProducts)
{
productsMap[product.Id] = product.ToWebModel(_blobUrlResolver);
}
}
foreach (var product in productsMap.Values.Where(v => v != null))
{
ReduceSearchResult(criteria, responseGroup, product);
}
// Preserve original sorting order
result = documents.Select(doc => productsMap[doc.Id.ToString()]).ToArray();
}
return(result);
}
protected virtual async Task SearchItemsAsync(SearchResult result, ProductSearchCriteria criteria, ItemResponseGroup responseGroup)
{
// Search using criteria, it will only return IDs of the items
var searchResults = await _productSearchService.SearchAsync(criteria);
result.ProductsTotalCount = (int)searchResults.TotalCount;
if (!searchResults.Items.IsNullOrEmpty())
{
// Now load items from repository preserving original order
var itemIds = searchResults.Items.Select(x => x.Id.ToString()).ToList();
result.Products = _itemService.GetByIds(itemIds.ToArray(), responseGroup, criteria.CatalogId)
.OrderBy(i => itemIds.IndexOf(i.Id)).ToArray();
}
}
