/// <summary> /// Get the collection of all channelOwners. /// </summary> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A set of channelOwners</returns> public ChannelOwnerSet GetChannelOwners(bool noCache, bool refreshCache) { // If no cache the load and return a entity set from the database if (noCache && !refreshCache) { return(LoadChannelOwnerSet()); } ChannelOwnerSet channelOwnerSet; string cacheKey = ChannelOwnerSet.StaticGetCacheKey(); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <ChannelOwnerSet>(cacheKey) || refreshCache) { // Load the entity set from the database channelOwnerSet = LoadChannelOwnerSet(); if (channelOwnerSet != null) { // Add the entity set to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, channelOwnerSet, ConfigurationManager.GetCacheExpirationByType( channelOwnerSet.GetType())); } } else { channelOwnerSet = CacheManagerProvider.GetCacheManagerInstance().Get <ChannelOwnerSet>(cacheKey); } return(channelOwnerSet); }
/// <summary> /// Get the collection of all StoreOptions. The cache is enabled by default. /// </summary> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A set of StoreOptions</returns> public StoreOptionTypeSet GetStoreOptions(bool noCache, bool refreshCache) { // If no cache the load and return a entity set from the database if (noCache && !refreshCache) { return(LoadStoreOptionTypeSet()); } StoreOptionTypeSet storeOptionSet; var cacheKey = StoreOptionTypeSet.StaticGetCacheKey(); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <StoreOptionTypeSet>(cacheKey) || refreshCache) { // Load the entity set from the database storeOptionSet = LoadStoreOptionTypeSet(); if (storeOptionSet != null) { // Add the entity set to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, storeOptionSet, ConfigurationManager.GetCacheExpirationByType( storeOptionSet.GetType())); } } else { storeOptionSet = CacheManagerProvider.GetCacheManagerInstance().Get <StoreOptionTypeSet>(cacheKey); } return(storeOptionSet); }
/// <summary> /// Get the collection of all channel stores. The cache is enabled by default. /// </summary> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <param name="channelId">Bypass the cache</param> /// param name="channelId">Bypass the cache</param> /// <returns></returns> public List <ChannelStore> GetChannelStoresByChannelId(int channelId, bool noCache, bool refreshCache) { // If no cache the load and return a entity set from the database if (noCache && !refreshCache) { return(GetChannelStoreById(channelId)); } List <ChannelStore> channelStoreList; var cacheKey = ChannelStoreSet.StaticGetCacheKey(); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <ChannelStoreSet>(cacheKey) || refreshCache) { // Load the entity set from the database channelStoreList = GetChannelStoreById(channelId); if (channelStoreList != null) { // Add the entity set to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, channelStoreList, ConfigurationManager.GetCacheExpirationByType( channelStoreList.GetType())); } } else { channelStoreList = CacheManagerProvider.GetCacheManagerInstance().Get <List <ChannelStore> >(cacheKey); } return(channelStoreList); }
/// <summary> /// Get the current channelOwner of a channelOwner. The cache is not bypassed by default. /// </summary> /// <param name="channelOwnerId">The channelOwner identifier</param> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A channelOwner</returns> public ChannelOwner GetChannelOwner(int channelOwnerId, bool noCache, bool refreshCache) { // If no cache the load and return a entity from the database if (noCache && !refreshCache) { return(LoadChannelOwner(channelOwnerId)); } ChannelOwner channelOwner; string cacheKey = ChannelOwner.GetCacheKeyById(channelOwnerId); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <ChannelOwner>(cacheKey) || refreshCache) { // Load the entity from the database channelOwner = LoadChannelOwner(channelOwnerId); if (channelOwner != null) { // Add the entity to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, channelOwner, ConfigurationManager.GetCacheExpirationByType( channelOwner.GetType())); } } else { channelOwner = CacheManagerProvider.GetCacheManagerInstance().Get <ChannelOwner>(cacheKey); } return(channelOwner); }
/// <summary> /// Get the collection of all product items. /// </summary> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A set of product items</returns> public ProductItemSet GetProductItems(bool noCache, bool refreshCache) { // If no cache the load and return a entity set from the database if (noCache && !refreshCache) { return(LoadProductItemSet()); } ProductItemSet productItemSet; string cacheKey = ProductItemSet.StaticGetCacheKey(); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <ProductItemSet>(cacheKey) || refreshCache) { // Load the entity set from the database productItemSet = LoadProductItemSet(); if (productItemSet != null) { // Add the entity set to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, productItemSet, ConfigurationManager.GetCacheExpirationByType( productItemSet.GetType())); } } else { productItemSet = CacheManagerProvider.GetCacheManagerInstance().Get <ProductItemSet>(cacheKey); } return(productItemSet); }
/// <summary> /// Get the campaign item. The cache is not bypassed by default. /// </summary> /// <param name="campaignItemId">The campaign item identifier</param> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A campaign item</returns> public CampaignItem GetCampaignItem(int campaignItemId, bool noCache, bool refreshCache) { // If no cache the load and return a entity from the database if (noCache && !refreshCache) { return(LoadCampaign(campaignItemId)); } CampaignItem campaignItem; string cacheKey = CampaignItem.GetCacheKeyById(campaignItemId); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <CampaignItem>(cacheKey) || refreshCache) { // Load the entity from the database campaignItem = LoadCampaign(campaignItemId); if (campaignItem != null) { // Add the entity to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, campaignItem, ConfigurationManager.GetCacheExpirationByType( campaignItem.GetType())); } } else { campaignItem = CacheManagerProvider.GetCacheManagerInstance().Get <CampaignItem>(cacheKey); } return(campaignItem); }
/// <summary> /// Get the product item. The cache is not bypassed by default. /// </summary> /// <param name="productId">The product identifier</param> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A product</returns> public ProductItem GetProductItem(string itemCode, bool noCache, bool refreshCache) { // If no cache the load and return a entity from the database if (noCache && !refreshCache) { return(GetProductByItemCode(itemCode)); } ProductItem product; string cacheKey = ProductItem.GetCustomCacheKey(itemCode); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <ProductItem>(cacheKey) || refreshCache) { // Load the entity from the database product = GetProductByItemCode(itemCode); if (product != null) { // Add the entity to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, product, ConfigurationManager.GetCacheExpirationByType( product.GetType())); } } else { product = CacheManagerProvider.GetCacheManagerInstance().Get <ProductItem>(cacheKey); } return(product); }
/// <summary> /// Get the collection of all redemptionCodes. /// </summary> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A set of redemptionCodes</returns> public RedemptionCodeSet GetRedemptionCodes(bool noCache, bool refreshCache) { // If no cache the load and return a entity set from the database if (noCache && !refreshCache) { return(LoadRedemptionCodeSet()); } RedemptionCodeSet redemptionCodeSet; string cacheKey = RedemptionCodeSet.StaticGetCacheKey(); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <RedemptionCodeSet>(cacheKey) || refreshCache) { // Load the entity set from the database redemptionCodeSet = LoadRedemptionCodeSet(); if (redemptionCodeSet != null) { // Add the entity set to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, redemptionCodeSet, ConfigurationManager.GetCacheExpirationByType( redemptionCodeSet.GetType())); } } else { redemptionCodeSet = CacheManagerProvider.GetCacheManagerInstance().Get <RedemptionCodeSet>(cacheKey); } return(redemptionCodeSet); }
/// <summary> /// Get the current redemptionCode of a redemptionCode. The cache is not bypassed by default. /// </summary> /// <param name="redemptionCodeId">The redemptionCode identifier</param> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A redemptionCode</returns> public RedemptionCode GetRedemptionCode(int redemptionCodeId, bool noCache, bool refreshCache) { // If no cache the load and return a entity from the database if (noCache && !refreshCache) { return(LoadRedemptionCode(redemptionCodeId)); } RedemptionCode redemptionCode; string cacheKey = RedemptionCode.GetCacheKeyById(redemptionCodeId); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <RedemptionCode>(cacheKey) || refreshCache) { // Load the entity from the database redemptionCode = LoadRedemptionCode(redemptionCodeId); if (redemptionCode != null) { // Add the entity to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, redemptionCode, ConfigurationManager.GetCacheExpirationByType( redemptionCode.GetType())); } } else { redemptionCode = CacheManagerProvider.GetCacheManagerInstance().Get <RedemptionCode>(cacheKey); } return(redemptionCode); }
/// <summary> /// Get the channel item from product ID. The cache is not bypassed by default. /// </summary> /// <param name="productId">The product identifier</param> /// <param name="noCache">Bypass the cache</param> /// <param name="refreshCache">Force refresh the cache</param> /// <returns>A Channel</returns> public ChannelItem GetChannelProcduct(int productId, int channelId, bool noCache, bool refreshCache) { // If no cache the load and return a entity from the database if (noCache && !refreshCache) { return(GetChannelProductByProductId(productId, channelId)); } ChannelItem channel; string cacheKey = ChannelItem.GetCustomCacheKey(productId.ToString()); if (!CacheManagerProvider.GetCacheManagerInstance().Contains <ChannelItem>(cacheKey) || refreshCache) { // Load the entity from the database channel = GetChannelProductByProductId(productId, channelId); if (channel != null) { // Add the entity to the cache by reading caching parameters from the configuration CacheManagerProvider.GetCacheManagerInstance().Insert(cacheKey, channel, ConfigurationManager.GetCacheExpirationByType( channel.GetType())); } } else { channel = CacheManagerProvider.GetCacheManagerInstance().Get <ChannelItem>(cacheKey); } return(channel); }
/// <summary> /// Remove entity from the cache. /// </summary> public void Refresh() { // Remove entity of the cache string cacheKey = GetCacheKey(); if (CacheManagerProvider.GetCacheManagerInstance().Contains <T>(cacheKey)) { CacheManagerProvider.GetCacheManagerInstance().Remove(cacheKey, this); } }