protected virtual void InnerHandle(UserChangedEvent @event)
{
foreach (var change in @event.ChangedEntries ?? Array.Empty <GenericChangedEntry <ApplicationUser> >())
{
CustomerCacheRegion.ExpireMemberById(change.NewEntry.MemberId);
}
}
protected virtual void ClearCache(IEnumerable <Member> members)
{
CustomerSearchCacheRegion.ExpireRegion();
foreach (var member in members.Where(x => !x.IsTransient()))
{
CustomerCacheRegion.ExpireMemberById(member.Id);
}
}
protected virtual void ClearCache(IEnumerable <Member> entities)
{
CustomerSearchCacheRegion.ExpireRegion();
foreach (var entity in entities)
{
CustomerCacheRegion.ExpireInventory(entity);
}
}
public Task Handle(DemoCustomerSegmentChangedEvent message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
// Expire cache for all members
CustomerCacheRegion.ExpireRegion();
return(Task.CompletedTask);
}
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("~/"));
}
/// <summary>
/// Return members by requested ids can be override for load extra data for resulting members
/// </summary>
/// <param name="memberIds"></param>
/// <param name="responseGroup"></param>
/// <param name="memberTypes"></param>
/// <returns></returns>
public virtual async Task <Member[]> GetByIdsAsync(string[] memberIds, string responseGroup = null, string[] memberTypes = null)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", memberIds), responseGroup, memberTypes == null ? null : string.Join("-", memberTypes));
return(await PlatformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var retVal = new List <Member>();
using (var repository = RepositoryFactory())
{
repository.DisableChangesTracking();
//There is loading for all corresponding members conceptual model entities types
//query performance when TPT inheritance used it is too slow, for improve performance we are passing concrete member types in to the repository
var memberTypeInfos = AbstractTypeFactory <Member> .AllTypeInfos.Where(t => t.MappedType != null);
if (memberTypes != null)
{
memberTypeInfos = memberTypeInfos.Where(x => memberTypes.Any(mt => x.IsAssignableTo(mt)));
}
memberTypes = memberTypeInfos.Select(t => t.MappedType.AssemblyQualifiedName).Distinct().ToArray();
var dataMembers = await repository.GetMembersByIdsAsync(memberIds, responseGroup, memberTypes);
foreach (var dataMember in dataMembers)
{
var member = AbstractTypeFactory <Member> .TryCreateInstance(dataMember.MemberType);
if (member != null)
{
dataMember.ToModel(member);
retVal.Add(member);
cacheEntry.AddExpirationToken(CustomerCacheRegion.CreateChangeToken(member));
}
}
}
var taskDynamicProperty = DynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal.ToArray <IHasDynamicProperties>());
var taskSeo = SeoService.LoadSeoForObjectsAsync(retVal.OfType <ISeoSupport>().ToArray());
await Task.WhenAll(taskDynamicProperty, taskSeo);
return retVal.ToArray();
}));
}
/// <summary>
/// Return members by requested ids can be override for load extra data for resulting members
/// </summary>
/// <param name="memberIds"></param>
/// <param name="responseGroup"></param>
/// <param name="memberTypes"></param>
/// <returns></returns>
public virtual async Task <Member[]> GetByIdsAsync(string[] memberIds, string responseGroup = null, string[] memberTypes = null)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", memberIds), responseGroup, memberTypes == null ? null : string.Join("-", memberTypes));
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var retVal = new List <Member>();
using (var repository = _repositoryFactory())
{
//It is so important to generate change tokens for all ids even for not existing members to prevent an issue
//with caching of empty results for non - existing objects that have the infinitive lifetime in the cache
//and future unavailability to create objects with these ids.
cacheEntry.AddExpirationToken(CustomerCacheRegion.CreateChangeToken(memberIds));
repository.DisableChangesTracking();
//There is loading for all corresponding members conceptual model entities types
//query performance when TPT inheritance used it is too slow, for improve performance we are passing concrete member types in to the repository
var memberTypeInfos = AbstractTypeFactory <Member> .AllTypeInfos.Where(t => t.MappedType != null);
if (memberTypes != null)
{
memberTypeInfos = memberTypeInfos.Where(x => memberTypes.Any(mt => x.IsAssignableTo(mt)));
}
memberTypes = memberTypeInfos.Select(t => t.MappedType.AssemblyQualifiedName).Distinct().ToArray();
var dataMembers = await repository.GetMembersByIdsAsync(memberIds, responseGroup, memberTypes);
foreach (var dataMember in dataMembers)
{
var member = AbstractTypeFactory <Member> .TryCreateInstance(dataMember.MemberType);
if (member != null)
{
dataMember.ToModel(member);
member.ReduceDetails(responseGroup);
retVal.Add(member);
}
}
var ancestorIds = dataMembers.SelectMany(r => r.MemberRelations)
.Where(x => !string.IsNullOrEmpty(x.AncestorId))
.Select(x => x.AncestorId)
.ToArray();
cacheEntry.AddExpirationToken(CustomerCacheRegion.CreateChangeToken(ancestorIds));
var descendantIds = dataMembers.SelectMany(x => x.MemberRelations)
.Where(x => !string.IsNullOrEmpty(x.DescendantId))
.Select(x => x.DescendantId)
.ToArray();
cacheEntry.AddExpirationToken(CustomerCacheRegion.CreateChangeToken(descendantIds));
}
var memberRespGroup = EnumUtility.SafeParseFlags(responseGroup, MemberResponseGroup.Full);
//Load member security accounts by separate request
if (memberRespGroup.HasFlag(MemberResponseGroup.WithSecurityAccounts))
{
var hasSecurityAccountMembers = retVal.OfType <IHasSecurityAccounts>().ToArray();
if (hasSecurityAccountMembers.Any())
{
var usersSearchResult = await _userSearchService.SearchUsersAsync(new UserSearchCriteria {
MemberIds = hasSecurityAccountMembers.Select(x => x.Id).ToList(), Take = int.MaxValue
});
foreach (var hasAccountMember in hasSecurityAccountMembers)
{
hasAccountMember.SecurityAccounts = usersSearchResult.Results.Where(x => x.MemberId.EqualsInvariant(hasAccountMember.Id)).ToList();
}
}
}
return retVal.ToArray();
}));
}
