public virtual async Task <Subscription[]> GetByIdsAsync(string[] subscriptionIds, string responseGroup = null)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", subscriptionIds), responseGroup);
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
var retVal = new List <Subscription>();
var subscriptionResponseGroup = EnumUtility.SafeParseFlags(responseGroup, SubscriptionResponseGroup.Full);
using (var repository = _subscriptionRepositoryFactory())
{
repository.DisableChangesTracking();
var subscriptionEntities = await repository.GetSubscriptionsByIdsAsync(subscriptionIds, responseGroup);
foreach (var subscriptionEntity in subscriptionEntities)
{
var subscription = AbstractTypeFactory <Subscription> .TryCreateInstance();
if (subscription != null)
{
subscription = subscriptionEntity.ToModel(subscription);
retVal.Add(subscription);
}
}
}
CustomerOrder[] orderPrototypes = null;
CustomerOrder[] subscriptionOrders = null;
if (subscriptionResponseGroup.HasFlag(SubscriptionResponseGroup.WithOrderPrototype))
{
orderPrototypes = await _customerOrderService.GetByIdsAsync(retVal.Select(x => x.CustomerOrderPrototypeId).ToArray());
}
if (subscriptionResponseGroup.HasFlag(SubscriptionResponseGroup.WithRelatedOrders))
{
//Loads customer order prototypes and related orders for each subscription via order service
var criteria = new CustomerOrderSearchCriteria
{
SubscriptionIds = subscriptionIds
};
subscriptionOrders = (await _customerOrderSearchService.SearchCustomerOrdersAsync(criteria)).Results.ToArray();
}
foreach (var subscription in retVal)
{
if (!orderPrototypes.IsNullOrEmpty())
{
subscription.CustomerOrderPrototype = orderPrototypes.FirstOrDefault(x => x.Id == subscription.CustomerOrderPrototypeId);
}
if (!subscriptionOrders.IsNullOrEmpty())
{
subscription.CustomerOrders = subscriptionOrders.Where(x => x.SubscriptionId == subscription.Id).ToList();
subscription.CustomerOrdersIds = subscription.CustomerOrders.Select(x => x.Id).ToArray();
}
cacheEntry.AddExpirationToken(SubscriptionCacheRegion.CreateChangeToken(subscription));
}
return retVal.ToArray();
}));
}
public async Task <SubscriptionInfo[]> GetByIdsAsync(string[] ids, string responseGroup = null)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", ids));
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(SubscriptionCacheRegion.CreateChangeToken());
var result = new List <SubscriptionInfo>();
if (!ids.IsNullOrEmpty())
{
using (var repository = _subscriptionRepositoryFactory())
{
var entities = await repository.GetSubscriptionsByIdsAsync(ids);
if (!entities.IsNullOrEmpty())
{
result.AddRange(entities.Select(x => x.ToModel(AbstractTypeFactory <SubscriptionInfo> .TryCreateInstance())));
}
}
}
return result.ToArray();
}));
}
public virtual Task Handle(OrderPlacedEvent @event)
{
if (@event.Order != null)
{
SubscriptionCacheRegion.ExpireCustomerSubscription(@event.Order.CustomerId);
}
return(Task.CompletedTask);
}
protected virtual void ClearCacheFor(Subscription[] subscriptions)
{
foreach (var subscription in subscriptions)
{
SubscriptionCacheRegion.ExpireSubscription(subscription);
}
SubscriptionSearchCacheRegion.ExpireRegion();
}
public ActionResult ResetCache()
{
//TODO: Replace to some other (maybe with using reflection)
ThemeEngineCacheRegion.ExpireRegion();
CartCacheRegion.ExpireRegion();
CatalogCacheRegion.ExpireRegion();
ContentBlobCacheRegion.ExpireRegion();
CustomerCacheRegion.ExpireRegion();
MarketingCacheRegion.ExpireRegion();
PricingCacheRegion.ExpireRegion();
QuoteCacheRegion.ExpireRegion();
RecommendationsCacheRegion.ExpireRegion();
StaticContentCacheRegion.ExpireRegion();
StoreCacheRegion.ExpireRegion();
TaxCacheRegion.ExpireRegion();
SubscriptionCacheRegion.ExpireRegion();
SecurityCacheRegion.ExpireRegion();
return(StoreFrontRedirect("~/"));
}
protected virtual void ClearCache()
{
SubscriptionCacheRegion.ExpireRegion();
SubscriptionSearchCacheRegion.ExpireRegion();
}
