public async Task CanPrepareProductOverviewModels()
{
var product = await _productService.GetProductByIdAsync(1);
var model = (await _productModelFactory.PrepareProductOverviewModelsAsync(new[] { product })).FirstOrDefault();
PropertiesShouldEqual(product, model);
}
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task <IActionResult> RecentlyViewedProducts()
{
if (!_catalogSettings.RecentlyViewedProductsEnabled)
{
return(Content(""));
}
var products = await _recentlyViewedProductsService.GetRecentlyViewedProductsAsync(_catalogSettings.RecentlyViewedProductsNumber);
var model = new List <ProductOverviewModel>();
model.AddRange(await _productModelFactory.PrepareProductOverviewModelsAsync(products));
return(View(model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public async Task <IViewComponentResult> InvokeAsync(int?productThumbPictureSize)
{
if (!_catalogSettings.ShowBestsellersOnHomepage || _catalogSettings.NumberOfBestsellersOnHomepage == 0)
{
return(Content(""));
}
//load and cache report
var report = (await _staticCacheManager.GetAsync(_staticCacheManager.PrepareKeyForDefaultCache(NopModelCacheDefaults.HomepageBestsellersIdsKey, await _storeContext.GetCurrentStoreAsync()),
async() => await _orderReportService.BestSellersReportAsync(
storeId: (await _storeContext.GetCurrentStoreAsync()).Id,
pageSize: _catalogSettings.NumberOfBestsellersOnHomepage)))
.ToList();
//load products
var products = await(await _productService.GetProductsByIdsAsync(report.Select(x => x.ProductId).ToArray()))
//ACL and store mapping
.WhereAwait(async p => await _aclService.AuthorizeAsync(p) && await _storeMappingService.AuthorizeAsync(p))
//availability dates
.Where(p => _productService.ProductIsAvailable(p)).ToListAsync();
if (!products.Any())
{
return(Content(""));
}
//prepare model
var model = (await _productModelFactory.PrepareProductOverviewModelsAsync(products, true, true, productThumbPictureSize)).ToList();
return(View(model));
}
public virtual async Task <IActionResult> SearchTermAutoComplete(string term)
{
term = term.Trim();
if (string.IsNullOrWhiteSpace(term) || term.Length < _catalogSettings.ProductSearchTermMinimumLength)
{
return(Content(""));
}
//products
var productNumber = _catalogSettings.ProductSearchAutoCompleteNumberOfProducts > 0 ?
_catalogSettings.ProductSearchAutoCompleteNumberOfProducts : 10;
var products = await _productService.SearchProductsAsync(0,
storeId : (await _storeContext.GetCurrentStoreAsync()).Id,
keywords : term,
languageId : (await _workContext.GetWorkingLanguageAsync()).Id,
visibleIndividuallyOnly : true,
pageSize : productNumber);
var showLinkToResultSearch = _catalogSettings.ShowLinkToAllResultInSearchAutoComplete && (products.TotalCount > productNumber);
var models = (await _productModelFactory.PrepareProductOverviewModelsAsync(products, false, _catalogSettings.ShowProductImagesInSearchAutoComplete, _mediaSettings.AutoCompleteSearchThumbPictureSize)).ToList();
var result = (from p in models
select new
{
label = p.Name,
producturl = Url.RouteUrl("Product", new { SeName = p.SeName }),
productpictureurl = p.DefaultPictureModel.ImageUrl,
showlinktoresultsearch = showLinkToResultSearch
})
.ToList();
return(Json(result));
}
public async Task <IViewComponentResult> InvokeAsync(int?productThumbPictureSize, bool?preparePriceModel)
{
if (!_catalogSettings.RecentlyViewedProductsEnabled)
{
return(Content(""));
}
var preparePictureModel = productThumbPictureSize.HasValue;
var products = await(await _recentlyViewedProductsService.GetRecentlyViewedProductsAsync(_catalogSettings.RecentlyViewedProductsNumber))
//ACL and store mapping
.WhereAwait(async p => await _aclService.AuthorizeAsync(p) && await _storeMappingService.AuthorizeAsync(p))
//availability dates
.Where(p => _productService.ProductIsAvailable(p)).ToListAsync();
if (!products.Any())
{
return(Content(""));
}
//prepare model
var model = new List <ProductOverviewModel>();
model.AddRange(await _productModelFactory.PrepareProductOverviewModelsAsync(products,
preparePriceModel.GetValueOrDefault(),
preparePictureModel,
productThumbPictureSize));
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync(int?productThumbPictureSize)
{
var cart = await _shoppingCartService.GetShoppingCartAsync(await _workContext.GetCurrentCustomerAsync(), ShoppingCartType.ShoppingCart, (await _storeContext.GetCurrentStoreAsync()).Id);
var products = await(await _productService.GetCrossSellProductsByShoppingCartAsync(cart, _shoppingCartSettings.CrossSellsNumber))
//ACL and store mapping
.WhereAwait(async p => await _aclService.AuthorizeAsync(p) && await _storeMappingService.AuthorizeAsync(p))
//availability dates
.Where(p => _productService.ProductIsAvailable(p))
//visible individually
.Where(p => p.VisibleIndividually).ToListAsync();
if (!products.Any())
{
return(Content(""));
}
//Cross-sell products are displayed on the shopping cart page.
//We know that the entire shopping cart page is not refresh
//even if "ShoppingCartSettings.DisplayCartAfterAddingProduct" setting is enabled.
//That's why we force page refresh (redirect) in this case
var model = (await _productModelFactory.PrepareProductOverviewModelsAsync(products,
productThumbPictureSize: productThumbPictureSize, forceRedirectionAfterAddingToCart: true))
.ToList();
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync(int productId, int?productThumbPictureSize)
{
if (!_catalogSettings.ProductsAlsoPurchasedEnabled)
{
return(Content(""));
}
//load and cache report
var store = await _storeContext.GetCurrentStoreAsync();
var productIds = await _staticCacheManager.GetAsync(_staticCacheManager.PrepareKeyForDefaultCache(NopModelCacheDefaults.ProductsAlsoPurchasedIdsKey, productId, store),
async() => await _orderReportService.GetAlsoPurchasedProductsIdsAsync(store.Id, productId, _catalogSettings.ProductsAlsoPurchasedNumber)
);
//load products
var products = await(await _productService.GetProductsByIdsAsync(productIds))
//ACL and store mapping
.WhereAwait(async p => await _aclService.AuthorizeAsync(p) && await _storeMappingService.AuthorizeAsync(p))
//availability dates
.Where(p => _productService.ProductIsAvailable(p)).ToListAsync();
if (!products.Any())
{
return(Content(""));
}
var model = (await _productModelFactory.PrepareProductOverviewModelsAsync(products, true, true, productThumbPictureSize)).ToList();
return(View(model));
}
/// <returns>A task that represents the asynchronous operation</returns>
public async Task <IViewComponentResult> InvokeAsync(int?productThumbPictureSize)
{
var products = await(await _productService.GetAllProductsDisplayedOnHomepageAsync())
//ACL and store mapping
.WhereAwait(async p => await _aclService.AuthorizeAsync(p) && await _storeMappingService.AuthorizeAsync(p))
//availability dates
.Where(p => _productService.ProductIsAvailable(p))
//visible individually
.Where(p => p.VisibleIndividually).ToListAsync();
if (!products.Any())
{
return(Content(""));
}
var model = (await _productModelFactory.PrepareProductOverviewModelsAsync(products, true, true, productThumbPictureSize)).ToList();
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync(int productId, int?productThumbPictureSize)
{
//load and cache report
var productIds = (await _productService.GetRelatedProductsByProductId1Async(productId)).Select(x => x.ProductId2).ToArray();
//load products
var products = await(await _productService.GetProductsByIdsAsync(productIds))
//ACL and store mapping
.WhereAwait(async p => await _aclService.AuthorizeAsync(p) && await _storeMappingService.AuthorizeAsync(p))
//availability dates
.Where(p => _productService.ProductIsAvailable(p))
//visible individually
.Where(p => p.VisibleIndividually).ToListAsync();
if (!products.Any())
{
return(Content(string.Empty));
}
var model = (await _productModelFactory.PrepareProductOverviewModelsAsync(products, true, true, productThumbPictureSize)).ToList();
return(View(model));
}
public async Task <IActionResult> Promo(string promoSlug, CatalogProductsCommand command)
{
var urlRecord = await _urlRecordService.GetBySlugAsync(promoSlug);
if (urlRecord == null)
{
return(InvokeHttp404());
}
var promo = await _abcPromoService.GetPromoByIdAsync(urlRecord.EntityId);
if (promo == null)
{
return(InvokeHttp404());
}
var shouldDisplay = _settings.IncludeExpiredPromosOnRebatesPromosPage ?
promo.IsExpired() || promo.IsActive() :
promo.IsActive();
if (!shouldDisplay)
{
return(InvokeHttp404());
}
var promoProducts = await _abcPromoService.GetPublishedProductsByPromoIdAsync(promo.Id);
// if a category is provided, filter by it
var filterCategory = await GetFilterCategoryAsync();
if (filterCategory != null)
{
var filterCategoryIds = (await _categoryService.GetChildCategoryIdsAsync(filterCategory.Id)).ToList();
filterCategoryIds.Add(filterCategory.Id);
var categoryFilteredProducts = new List <Product>();
foreach (var product in promoProducts)
{
var pcs = await _categoryService.GetProductCategoriesByProductIdAsync(product.Id);
var pcsCategoryIds = pcs.Select(pc => pc.CategoryId);
var pcCategoryIdsWithParents = new List <int>();
if (pcsCategoryIds.Intersect(filterCategoryIds).Any())
{
categoryFilteredProducts.Add(product);
}
}
promoProducts = categoryFilteredProducts;
}
promoProducts = SortPromoProducts(promoProducts, command);
var filteredPromoProducts = promoProducts.Skip(command.PageIndex * 20).Take(20).ToList();
var model = new PromoListingModel
{
Name = promo.ManufacturerId != null ?
$"{(await _manufacturerService.GetManufacturerByIdAsync(promo.ManufacturerId.Value)).Name} - {promo.Description}" :
promo.Description,
Products = (await _productModelFactory.PrepareProductOverviewModelsAsync(filteredPromoProducts)).ToList(),
BannerImageUrl = await promo.GetPromoBannerUrlAsync(),
PromoFormPopup = promo.GetPopupCommand()
};
var pagedList = new PagedList <Product>(
filteredPromoProducts,
command.PageIndex,
20,
promoProducts.Count
);
model.LoadPagedList(pagedList);
// using duplicate sorting - it would be good to link this to NOP code but it's pretty complex
await PrepareSortingOptionsAsync(model, command);
return(View("~/Plugins/Widgets.AbcPromos/Views/PromoListing.cshtml", model));
}
