/// <summary> /// The execute. /// </summary> /// <param name="arg"> /// The pipeline argument. /// </param> /// <param name="context"> /// The context. /// </param> /// <returns> /// The <see cref="PipelineArgument"/>. /// </returns> public async override Task <IEnumerable <LocalizedTerm> > Run(LocalizedProductFeaturesArgument arg, CommercePipelineExecutionContext context) { var cachePolicy = context.GetPolicy <ProductFeaturesCachePolicy>(); if (!cachePolicy.AllowCaching) { context.CommerceContext.AddUniqueObjectByType((object)new KeyValuePair <string, bool>("IsFromCache", false)); return(null); } var policy = context.GetPolicy <ProductFeaturesControlPanelPolicy>(); string cacheKey = policy.AvailableProductFeaturesPath + "|" + context.CommerceContext.CurrentLanguage(); var cachePipeline = this.Commander.Pipeline <IGetEnvironmentCachePipeline>(); EnvironmentCacheArgument environmentCacheArgument = new EnvironmentCacheArgument(); environmentCacheArgument.CacheName = cachePolicy.CacheName; var result = (await cachePipeline.Run(environmentCacheArgument, context))?.Get(cacheKey)?.Result as IEnumerable <LocalizedTerm>; if (result == null) { context.CommerceContext.AddUniqueObjectByType((object)new KeyValuePair <string, bool>("IsFromCache", false)); return(null); } context.CommerceContext.AddUniqueObjectByType((object)new KeyValuePair <string, bool>("IsFromCache", true)); context.Logger.LogDebug("Mgmt.GetLocMsg." + cacheKey); return(result); }
/// <summary> /// The execute. /// </summary> /// <param name="arg"> /// The pipeline argument. /// </param> /// <param name="context"> /// The context. /// </param> /// <returns> /// The <see cref="PipelineArgument"/>. /// </returns> public async override Task <LocalizedTerm> Run(LocalizedTerm arg, CommercePipelineExecutionContext context) { if (arg == null) { return(null); } var argument = context.CommerceContext.GetObject <LocalizedProductFeaturesConfigurationArgument>(); if (string.IsNullOrEmpty(argument?.LocalizationKey)) { return(arg); } KeyValuePair <string, bool> keyValuePair = context.CommerceContext.GetObject <KeyValuePair <string, bool> >((Func <KeyValuePair <string, bool>, bool>)(k => k.Key.Equals("IsFromCache", StringComparison.OrdinalIgnoreCase))); string currentLanguage = context.CommerceContext.CurrentLanguage(); var cachePolicy = context.GetPolicy <ProductFeaturesCachePolicy>(); if (cachePolicy.AllowCaching && !keyValuePair.Value) { string cacheKey = argument.LocalizationKey + "|" + currentLanguage; IGetEnvironmentCachePipeline cachePipeline = this.Commander.Pipeline <IGetEnvironmentCachePipeline>(); EnvironmentCacheArgument environmentCacheArgument = new EnvironmentCacheArgument(); environmentCacheArgument.CacheName = cachePolicy.CacheName; await(await cachePipeline.Run(environmentCacheArgument, context)).Set(cacheKey, (ICachable) new Cachable <LocalizedTerm>(arg, 1L), cachePolicy.GetCacheEntryOptions()); cacheKey = (string)null; } return(arg); }
/// <summary> /// The execute. /// </summary> /// <param name="arg"> /// The pipeline argument. /// </param> /// <param name="context"> /// The context. /// </param> /// <returns> /// The <see cref="PipelineArgument"/>. /// </returns> public async override Task <LocalizedTerm> Run(LocalizedProductFeaturesConfigurationArgument arg, CommercePipelineExecutionContext context) { Condition.Requires <LocalizedProductFeaturesConfigurationArgument>(arg).IsNotNull <LocalizedProductFeaturesConfigurationArgument>(this.Name + ": pipeline block argument can not be null"); Condition.Requires <string>(arg.LocalizationKey).IsNotNullOrEmpty(Name + ": pipeline block argument LocalizationKey cannot be null or empty"); context.CommerceContext.AddUniqueObjectByType((object)arg); var cachePolicy = context.GetPolicy <ProductFeaturesCachePolicy>(); if (!cachePolicy.AllowCaching) { context.CommerceContext.AddUniqueObjectByType((object)new KeyValuePair <string, bool>("IsFromCache", false)); return((LocalizedTerm)null); } string cacheKey = arg.LocalizationKey + "|" + context.CommerceContext.CurrentLanguage(); var cachePipeline = this.Commander.Pipeline <IGetEnvironmentCachePipeline>(); EnvironmentCacheArgument environmentCacheArgument = new EnvironmentCacheArgument(); environmentCacheArgument.CacheName = cachePolicy.CacheName; LocalizedTerm result = (await cachePipeline.Run(environmentCacheArgument, context))?.Get(cacheKey)?.Result as LocalizedTerm; if (result == null) { context.CommerceContext.AddUniqueObjectByType((object)new KeyValuePair <string, bool>("IsFromCache", false)); return((LocalizedTerm)null); } context.CommerceContext.AddUniqueObjectByType((object)new KeyValuePair <string, bool>("IsFromCache", true)); context.Logger.LogDebug("Mgmt.GetLocMsg." + cacheKey); return(result); }
/// <summary> /// Processes the specified commerce context. /// </summary> /// <param name="commerceContext">The commerce context.</param> /// <param name="name">The name.</param> /// <returns></returns> public virtual async Task <FulfillmentFeeBook> Process(CommerceContext commerceContext, string name = "") { using (var activity = CommandActivity.Start(commerceContext, this)) { var FulfillmentFeeBookName = commerceContext.GetPolicy <GlobalPolicy>().GetFulfillmentFeeBookName(name, commerceContext); var cachePolicy = commerceContext.GetPolicy <FulfillmentFeeCachePolicy>(); var cacheKey = string.Format("{0}{1}", commerceContext.CurrentLanguage(), FulfillmentFeeBookName); ICache cache = null; FulfillmentFeeBook FulfillmentFeeBook = null; if (cachePolicy.AllowCaching) { var environmentCacheArgument = new EnvironmentCacheArgument { CacheName = cachePolicy.CacheName }; cache = await _cachePipeline.Run(environmentCacheArgument, commerceContext.GetPipelineContextOptions()); FulfillmentFeeBook = await cache.Get(cacheKey) as FulfillmentFeeBook; } if (FulfillmentFeeBook == null) { FulfillmentFeeBook = await this.GetFulfillmentFeeBook(commerceContext, FulfillmentFeeBookName); if (cachePolicy.AllowCaching && cache != null) { await cache.Set(cacheKey, new Cachable <FulfillmentFeeBook>(FulfillmentFeeBook, 1L), cachePolicy.GetCacheEntryOptions()); } } return(FulfillmentFeeBook); } }
public override async Task <PersistEntityArgument> Run(PersistEntityArgument arg, CommercePipelineExecutionContext context) { var itemKey = string.IsNullOrEmpty(arg.Entity.CompositeKey) ? $"{ arg.Entity.Id}" : $"{ arg.Entity.CompositeKey}"; var model = context.GetModel((Func <CacheRequest, bool>)(x => x.EntityId.Equals(arg.Entity.Id, StringComparison.OrdinalIgnoreCase))); if (model?.Version != null) { itemKey += $"-{model.Version}"; } context.RemoveModel(model); EntityMemoryCachingPolicy memoryCachingPolicy1 = null; if (!string.IsNullOrEmpty(arg.Entity?.GetType().FullName)) { memoryCachingPolicy1 = context.CommerceContext.Environment.Policies.OfType <EntityMemoryCachingPolicy>().FirstOrDefault(p => p.EntityFullName.Equals(arg.Entity.GetType().FullName, StringComparison.OrdinalIgnoreCase)); } var memoryCachingPolicy2 = memoryCachingPolicy1 ?? context.CommerceContext.Environment.Policies.OfType <EntityMemoryCachingPolicy>().FirstOrDefault(p => p.EntityFullName.Equals("*", StringComparison.OrdinalIgnoreCase)); if (memoryCachingPolicy2 != null) { var cachePipeline = _cachePipeline; var environmentCacheArgument = new EnvironmentCacheArgument { CacheName = memoryCachingPolicy2.CacheName }; var pipelineContextOptions = context.CommerceContext.GetPipelineContextOptions(); await(await cachePipeline.Run(environmentCacheArgument, pipelineContextOptions)).Remove(itemKey); context.Logger.LogDebug($"Core.MemCache.Remove: {itemKey}", Array.Empty <object>()); } return(arg); }
public override async Task <string> Run(string arg, CommercePipelineExecutionContext context) { var priceBookName = arg; if (!context.GetPolicy <PriceBookPolicy>().UseCommerceShopPriceBook) { return(await Task.FromResult(priceBookName)); } Sitecore.Commerce.Plugin.Shops.Shop shop = context.CommerceContext.Objects.OfType <Sitecore.Commerce.Plugin.Shops.Shop>().FirstOrDefault(); if (shop == null) { return(await Task.FromResult(priceBookName)); } string storefrontItemPath = $"{context.GetPolicy<SitecoreControlPanelItemsPolicy>().StorefrontsPath}/{shop.Name}"; string cacheKey = storefrontItemPath; ManagementCachePolicy cachePolicy = context.GetPolicy <ManagementCachePolicy>(); ICache cache = null; ItemModel storefrontItemModel; if (cachePolicy.AllowCaching) { EnvironmentCacheArgument environmentCacheArgument = new EnvironmentCacheArgument(); environmentCacheArgument.CacheName = cachePolicy.ItemsCacheName; cache = await _cachePipeline.Run(environmentCacheArgument, context); storefrontItemModel = await cache.Get(cacheKey) as ItemModel; if (storefrontItemModel != null) { return(await Task.FromResult(ResolvePriceBookName(priceBookName, GetPricebookName(storefrontItemModel)))); } } context.Logger.LogInformation($"Feature.Pricing.GetStorefront.{cacheKey}"); try { ItemModelArgument itemModelArgument = new ItemModelArgument(storefrontItemPath); itemModelArgument.Language = context.GetPolicy <GlobalEnvironmentPolicy>().DefaultLocale; storefrontItemModel = await _getItemByPathPipeline.Run(itemModelArgument, context); if (storefrontItemModel != null) { if (cachePolicy.AllowCaching) { await cache.Set(cacheKey, new Cachable <ItemModel>(storefrontItemModel, 1L), cachePolicy.GetCacheEntryOptions()); } return(await Task.FromResult(ResolvePriceBookName(priceBookName, GetPricebookName(storefrontItemModel)))); } } catch (Exception ex) { string str = await context.CommerceContext.AddMessage(context.GetPolicy <KnownResultCodes>().Error, "CommerceTermsNotFound", new object[2] { storefrontItemPath, ex }, string.Format("Sitecore commerce terms at {0} were not found.", storefrontItemPath)); } return(await Task.FromResult(priceBookName)); }
public override async Task <List <string> > Run(string catalogName, CommercePipelineExecutionContext context) { List <InventorySet> inventorySets = new List <InventorySet>(); GetProductsToUpdateInventoryBlock getProductsToUpdateInventoryBlock = this; // get the sitecoreid from catalog based on catalogname var catalogSitecoreId = ""; FindEntitiesInListArgument entitiesInListArgumentCatalog = await getProductsToUpdateInventoryBlock._findEntitiesInListPipeline.Run(new FindEntitiesInListArgument(typeof(Catalog), string.Format("{0}", (object)CommerceEntity.ListName <Catalog>()), 0, int.MaxValue), context); foreach (CommerceEntity commerceEntity in (await getProductsToUpdateInventoryBlock._findEntitiesInListPipeline.Run(entitiesInListArgumentCatalog, (IPipelineExecutionContextOptions)context.ContextOptions)).List.Items) { var item = commerceEntity as Catalog; if (item.Name == catalogName) { catalogSitecoreId = item.SitecoreId; break; } } if (string.IsNullOrEmpty(catalogSitecoreId)) { return(null); } List <string> productIds = new List <string>(); string cacheKey = string.Format("{0}|{1}|{2}", context.CommerceContext.Environment.Name, context.CommerceContext.CurrentLanguage(), context.CommerceContext.CurrentShopName() ?? ""); CatalogCachePolicy cachePolicy = context.GetPolicy <CatalogCachePolicy>(); ICache cache = null; List <SellableItem> sellableItems = null; if (cachePolicy.AllowCaching) { IGetEnvironmentCachePipeline cachePipeline = getProductsToUpdateInventoryBlock._cachePipeline; EnvironmentCacheArgument environmentCacheArgument = new EnvironmentCacheArgument(); environmentCacheArgument.CacheName = cachePolicy.CatalogsCacheName; CommercePipelineExecutionContext context1 = context; cache = await cachePipeline.Run(environmentCacheArgument, context1).ConfigureAwait(false); sellableItems = await cache.Get(cacheKey).ConfigureAwait(false) as List <SellableItem>; if (sellableItems != null) { foreach (var item in sellableItems) { await GetProductId(context, getProductsToUpdateInventoryBlock, catalogSitecoreId, productIds, item); } } } else { sellableItems = new List <SellableItem>(); FindEntitiesInListArgument entitiesInListArgument = new FindEntitiesInListArgument(typeof(SellableItem), string.Format("{0}", (object)CommerceEntity.ListName <SellableItem>()), 0, int.MaxValue); foreach (CommerceEntity commerceEntity in (await getProductsToUpdateInventoryBlock._findEntitiesInListPipeline.Run(entitiesInListArgument, context.ContextOptions).ConfigureAwait(false)).List.Items) { await GetProductId(context, getProductsToUpdateInventoryBlock, catalogSitecoreId, productIds, commerceEntity as SellableItem).ConfigureAwait(false); } if (cachePolicy.AllowCaching) { if (cache != null) { await cache.Set(cacheKey, new Cachable <List <SellableItem> >(sellableItems, 1L), cachePolicy.GetCacheEntryOptions()).ConfigureAwait(false); } } } return(productIds); }