/// <summary>
/// Gets a product category mapping collection
/// </summary>
/// <param name="productId">Product identifier</param>
/// <param name="storeId">Store identifier (used in multi-store environment). "showHidden" parameter should also be "true"</param>
/// <param name="showHidden"> A value indicating whether to show hidden records</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the product category mapping collection
/// </returns>
protected virtual async Task <IList <ProductCategory> > GetProductCategoriesByProductIdAsync(int productId, int storeId,
bool showHidden = false)
{
if (productId == 0)
{
return(new List <ProductCategory>());
}
var customer = await _workContext.GetCurrentCustomerAsync();
return(await _productCategoryRepository.GetAllAsync(async query =>
{
if (!showHidden)
{
var categoriesQuery = _categoryRepository.Table.Where(c => c.Published);
//apply store mapping constraints
categoriesQuery = await _storeMappingService.ApplyStoreMapping(categoriesQuery, storeId);
//apply ACL constraints
categoriesQuery = await _aclService.ApplyAcl(categoriesQuery, customer);
query = query.Where(pc => categoriesQuery.Any(c => !c.Deleted && c.Id == pc.CategoryId));
}
return query
.Where(pc => pc.ProductId == productId)
.OrderBy(pc => pc.DisplayOrder)
.ThenBy(pc => pc.Id);
}, cache => _staticCacheManager.PrepareKeyForDefaultCache(NopCatalogDefaults.ProductCategoriesByProductCacheKey,
productId, showHidden, customer, storeId)));
}
/// <summary>
/// Gets all manufacturers
/// </summary>
/// <param name="manufacturerName">Manufacturer name</param>
/// <param name="storeId">Store identifier; 0 if you want to get all records</param>
/// <param name="pageIndex">Page index</param>
/// <param name="pageSize">Page size</param>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <param name="overridePublished">
/// null - process "Published" property according to "showHidden" parameter
/// true - load only "Published" products
/// false - load only "Unpublished" products
/// </param>
/// <returns>Manufacturers</returns>
public virtual async Task <IPagedList <Manufacturer> > GetAllManufacturersAsync(string manufacturerName = "",
int storeId = 0,
int pageIndex = 0,
int pageSize = int.MaxValue,
bool showHidden = false,
bool?overridePublished = null)
{
return(await _manufacturerRepository.GetAllPagedAsync(async query =>
{
if (!showHidden)
{
query = query.Where(m => m.Published);
}
else if (overridePublished.HasValue)
{
query = query.Where(m => m.Published == overridePublished.Value);
}
//apply store mapping constraints
query = await _storeMappingService.ApplyStoreMapping(query, storeId);
//apply ACL constraints
if (!showHidden)
{
var customer = await _workContext.GetCurrentCustomerAsync();
query = await _aclService.ApplyAcl(query, customer);
}
query = query.Where(m => !m.Deleted);
if (!string.IsNullOrWhiteSpace(manufacturerName))
{
query = query.Where(m => m.Name.Contains(manufacturerName));
}
return query.OrderBy(m => m.DisplayOrder).ThenBy(m => m.Id);
}, pageIndex, pageSize));
}
/// <summary>
/// Gets a topic
/// </summary>
/// <param name="systemName">The topic system name</param>
/// <param name="storeId">Store identifier; pass 0 to ignore filtering by store and load the first one</param>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <returns>Topic</returns>
public virtual async Task <Topic> GetTopicBySystemNameAsync(string systemName, int storeId = 0, bool showHidden = false)
{
if (string.IsNullOrEmpty(systemName))
{
return(null);
}
var customer = await _workContext.GetCurrentCustomerAsync();
var customerRoleIds = await _customerService.GetCustomerRoleIdsAsync(customer);
var cacheKey = _staticCacheManager.PrepareKeyForDefaultCache(NopTopicDefaults.TopicBySystemNameCacheKey, systemName, storeId, customerRoleIds);
var topic = await _staticCacheManager.GetAsync(cacheKey, async() =>
{
var query = _topicRepository.Table;
if (!showHidden)
{
query = query.Where(t => t.Published);
}
//apply store mapping constraints
query = await _storeMappingService.ApplyStoreMapping(query, storeId);
//apply ACL constraints
if (!showHidden)
{
query = await _aclService.ApplyAcl(query, customerRoleIds);
}
return(query.Where(t => t.SystemName == systemName)
.OrderBy(t => t.Id)
.FirstOrDefault());
});
return(topic);
}
/// <summary>
/// Filter hidden entries according to constraints if any
/// </summary>
/// <param name="query">Query to filter</param>
/// <param name="storeId">A store identifier</param>
/// <param name="customerRoleIds">Identifiers of customer's roles</param>
/// <returns>Filtered query</returns>
protected virtual IQueryable <TEntity> FilterHiddenEntries <TEntity>(IQueryable <TEntity> query, int storeId, int[] customerRoleIds)
where TEntity : Category
{
//filter unpublished entries
query = query.Where(entry => entry.Published);
//apply store mapping constraints
if (!_catalogSettings.IgnoreStoreLimitations && _storeMappingService.IsEntityMappingExists <TEntity>(storeId))
{
query = query.Where(_storeMappingService.ApplyStoreMapping <TEntity>(storeId));
}
//apply ACL constraints
if (!_catalogSettings.IgnoreAcl && _aclService.IsEntityAclMappingExist <TEntity>(customerRoleIds))
{
query = query.Where(_aclService.ApplyAcl <TEntity>(customerRoleIds));
}
return(query);
}
/// <summary>
/// Filter hidden entries according to constraints if any
/// </summary>
/// <param name="query">Query to filter</param>
/// <param name="storeId">A store identifier</param>
/// <param name="customerRolesIds">Identifiers of customer's roles</param>
/// <returns>Filtered query</returns>
protected virtual async Task <IQueryable <TEntity> > FilterHiddenEntriesAsync <TEntity>(IQueryable <TEntity> query,
int storeId, int[] customerRolesIds)
where TEntity : Manufacturer
{
//filter unpublished entries
query = query.Where(entry => entry.Published);
//apply store mapping constraints
if (!_catalogSettings.IgnoreStoreLimitations && await _storeMappingService.IsEntityMappingExistsAsync <TEntity>(storeId))
{
query = query.Where(_storeMappingService.ApplyStoreMapping <TEntity>(storeId));
}
//apply ACL constraints
if (!_catalogSettings.IgnoreAcl && await _aclService.IsEntityAclMappingExistAsync <TEntity>(customerRolesIds))
{
query = query.Where(_aclService.ApplyAcl <TEntity>(customerRolesIds));
}
return(query);
}
protected virtual async Task <IQueryable <Product> > GetAvailableProductsQueryAsync()
{
var productsQuery =
from p in _productRepository.Table
where !p.Deleted && p.Published &&
(p.ParentGroupedProductId == 0 || p.VisibleIndividually) &&
(!p.AvailableStartDateTimeUtc.HasValue || p.AvailableStartDateTimeUtc <= DateTime.UtcNow) &&
(!p.AvailableEndDateTimeUtc.HasValue || p.AvailableEndDateTimeUtc >= DateTime.UtcNow)
select p;
var store = await _storeContext.GetCurrentStoreAsync();
var currentCustomer = await _workContext.GetCurrentCustomerAsync();
//apply store mapping constraints
productsQuery = await _storeMappingService.ApplyStoreMapping(productsQuery, store.Id);
//apply ACL constraints
productsQuery = await _aclService.ApplyAcl(productsQuery, currentCustomer);
return(productsQuery);
}
/// <summary>
/// Get product count for every linked tag
/// </summary>
/// <param name="storeId">Store identifier</param>
/// <param name="showHidden">A value indicating whether to show hidden records</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the dictionary of "product tag ID : product count"
/// </returns>
public virtual async Task <Dictionary <int, int> > GetProductCountAsync(int storeId, bool showHidden = false)
{
var customer = await _workContext.GetCurrentCustomerAsync();
var customerRoleIds = await _customerService.GetCustomerRoleIdsAsync(customer);
var key = _staticCacheManager.PrepareKeyForDefaultCache(NopCatalogDefaults.ProductTagCountCacheKey, storeId, customerRoleIds, showHidden);
return(await _staticCacheManager.GetAsync(key, async() =>
{
var query = _productProductTagMappingRepository.Table;
if (!showHidden)
{
var productsQuery = _productRepository.Table.Where(p => p.Published);
//apply store mapping constraints
productsQuery = await _storeMappingService.ApplyStoreMapping(productsQuery, storeId);
//apply ACL constraints
productsQuery = await _aclService.ApplyAcl(productsQuery, customerRoleIds);
query = query.Where(pc => productsQuery.Any(p => !p.Deleted && pc.ProductId == p.Id));
}
var pTagCount = from pt in _productTagRepository.Table
join ptm in query on pt.Id equals ptm.ProductTagId
group ptm by ptm.ProductTagId into ptmGrouped
select new
{
ProductTagId = ptmGrouped.Key,
ProductCount = ptmGrouped.Count()
};
return pTagCount.ToDictionary(item => item.ProductTagId, item => item.ProductCount);
}));
}
