public async Task <IEnumerable <QuoteRequest> > GetByIdsAsync(params string[] ids)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", ids));
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var retVal = new List <QuoteRequest>();
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(QuoteCacheRegion.CreateChangeToken(ids));
repository.DisableChangesTracking();
var dbQuotes = await repository.GetQuoteRequestByIdsAsync(ids);
foreach (var dbQuote in dbQuotes)
{
var quote = dbQuote.ToModel(AbstractTypeFactory <QuoteRequest> .TryCreateInstance());
retVal.Add(quote);
}
}
return retVal.ToArray();
}));
}
public virtual async Task <PromotionSearchResult> SearchPromotionsAsync(PromotionSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), "SearchPromotionsAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(PromotionCacheRegion.CreateChangeToken());
var retVal = AbstractTypeFactory <PromotionSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var query = GetPromotionsQuery(repository, criteria);
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <Promotion>(x => x.Priority), SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
retVal.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var ids = await query.Select(x => x.Id)
.Skip(criteria.Skip)
.Take(criteria.Take).ToArrayAsync();
var promotions = await _promotionService.GetPromotionsByIdsAsync(ids);
retVal.Results = promotions.OrderBy(p => ids.ToList().IndexOf(p.Id)).ToList();
}
}
return retVal;
}));
}
public async Task <GenericSearchResult <Coupon> > SearchCouponsAsync(CouponSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
var cacheKey = CacheKey.With(GetType(), "SearchCouponsAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(CouponCacheRegion.CreateChangeToken());
using (var repository = _repositoryFactory())
{
var query = repository.Coupons;
if (!string.IsNullOrEmpty(criteria.PromotionId))
{
query = query.Where(c => c.PromotionId == criteria.PromotionId);
}
if (!string.IsNullOrEmpty(criteria.Code))
{
query = query.Where(c => c.Code == criteria.Code);
}
if (!criteria.Codes.IsNullOrEmpty())
{
query = query.Where(c => criteria.Codes.Contains(c.Code));
}
var sortInfos = criteria.SortInfos;
//TODO: Sort by TotalUsesCount
if (sortInfos.IsNullOrEmpty() || sortInfos.Any(x => x.SortColumn.EqualsInvariant(ReflectionUtility.GetPropertyName <Coupon>(p => p.TotalUsesCount))))
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <Coupon>(x => x.Code), SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
var totalCount = await query.CountAsync();
var searchResult = new GenericSearchResult <Coupon> {
TotalCount = totalCount
};
if (criteria.Take > 0)
{
var ids = await query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
searchResult.Results = await GetByIdsAsync(ids);
}
return searchResult;
}
}));
}
/// <summary>
/// Evaluate pricelists for special context. All resulting pricelists ordered by priority
/// </summary>
/// <param name="evalContext"></param>
/// <returns></returns>
public virtual async Task <IEnumerable <Pricelist> > EvaluatePriceListsAsync(PriceEvaluationContext evalContext)
{
var cacheKey = CacheKey.With(GetType(), nameof(EvaluatePriceListsAsync));
var priceListAssignments = await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
cacheEntry.AddExpirationToken(PricingCacheRegion.CreateChangeToken());
return(await GetAllPricelistAssignments());
});
var query = priceListAssignments.AsQueryable();
if (evalContext.CatalogId != null)
{
//filter by catalog
query = query.Where(x => x.CatalogId == evalContext.CatalogId);
}
if (evalContext.Currency != null)
{
//filter by currency
query = query.Where(x => x.Pricelist.Currency == evalContext.Currency.ToString());
}
if (evalContext.CertainDate != null)
{
//filter by date expiration
query = query.Where(x => (x.StartDate == null || evalContext.CertainDate >= x.StartDate) && (x.EndDate == null || x.EndDate >= evalContext.CertainDate));
}
var assignments = query.AsNoTracking().ToArray();
var assignmentsToReturn = assignments.Where(x => x.DynamicExpression == null).ToList();
foreach (var assignment in assignments.Where(x => x.DynamicExpression != null))
{
try
{
if (assignment.DynamicExpression.IsSatisfiedBy(evalContext) && assignmentsToReturn.All(x => x.PricelistId != assignment.PricelistId))
{
assignmentsToReturn.Add(assignment);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to evaluate price assignment condition.");
}
}
return(assignmentsToReturn.OrderByDescending(x => x.Priority).ThenByDescending(x => x.Name).Select(x => x.Pricelist));
}
public async Task <DynamicContentItem[]> GetContentItemsByIdsAsync(string[] ids)
{
var cacheKey = CacheKey.With(GetType(), "GetContentItemsByIdsAsync", string.Join("-", ids));
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(DynamicContentItemCacheRegion.CreateChangeToken());
DynamicContentItem[] retVal = null;
using (var repository = _repositoryFactory())
{
retVal = (await repository.GetContentItemsByIdsAsync(ids)).Select(x => x.ToModel(AbstractTypeFactory <DynamicContentItem> .TryCreateInstance())).ToArray();
}
return retVal;
}));
}
public virtual Task <PriceSearchResult> SearchPricesAsync(PricesSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchPricesAsync), criteria.GetCacheKey());
return(_platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
cacheEntry.AddExpirationToken(PricesCacheRegion.CreateChangeToken());
cacheEntry.AddExpirationToken(PricingSearchCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <PriceSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var query = await BuildQueryAsync(repository, criteria);
var sortInfos = BuildSortExpression(criteria);
//Try to replace sorting columns names
TryTransformSortingInfoColumnNames(_pricesSortingAliases, sortInfos);
if (criteria.GroupByProducts)
{
var groupedQuery = query.Select(x => x.ProductId).OrderBy(x => x).Distinct();
result.TotalCount = await groupedQuery.CountAsync();
if (criteria.Take > 0)
{
query = query.Where(x => groupedQuery.Contains(x.ProductId));
}
}
else
{
result.TotalCount = await query.CountAsync();
}
if (criteria.Take > 0)
{
var priceIds = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.Select(x => x.Id)
.AsNoTracking()
.ToArrayAsync();
var unorderedResults = await _pricingService.GetPricesByIdAsync(priceIds);
result.Results = unorderedResults.OrderBy(x => Array.IndexOf(priceIds, x.Id)).ToList();
}
}
return result;
}));
}
protected virtual async Task <IList <ImageChange> > GetChangeFiles(ThumbnailTask task, DateTime?changedSince, ICancellationToken token)
{
var options = await GetOptionsCollection();
var cacheKey = CacheKey.With(GetType(), "GetChangeFiles", task.WorkPath, changedSince?.ToString(), string.Join(":", options.Select(x => x.FileSuffix)));
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(BlobChangesCacheRegion.CreateChangeToken(task, changedSince));
var allBlobInfos = await ReadBlobFolderAsync(task.WorkPath, token);
var orignalBlobInfos = GetOriginalItems(allBlobInfos, options.Select(x => x.FileSuffix).ToList());
var result = new List <ImageChange>();
foreach (var blobInfo in orignalBlobInfos)
{
token?.ThrowIfCancellationRequested();
var imageChange = new ImageChange
{
Name = blobInfo.Name,
Url = blobInfo.Url,
ModifiedDate = blobInfo.ModifiedDate,
ChangeState = !changedSince.HasValue ? EntryState.Added : GetItemState(blobInfo, changedSince, task.ThumbnailOptions)
};
result.Add(imageChange);
}
return result.Where(x => x.ChangeState != EntryState.Unchanged).ToList();
}));
}
protected virtual async Task <IDictionary <string, Category> > PreloadCategoriesAsync(string catalogId)
{
var cacheKey = CacheKey.With(GetType(), "PreloadCategories", catalogId);
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(CatalogCacheRegion.CreateChangeToken());
CategoryEntity[] entities;
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
entities = await repository.GetCategoriesByIdsAsync(repository.Categories.Select(x => x.Id).ToArray(), CategoryResponseGroup.Full);
}
var result = entities.Select(x => x.ToModel(AbstractTypeFactory <Category> .TryCreateInstance()))
.ToDictionary(x => x.Id, StringComparer.OrdinalIgnoreCase)
.WithDefaultValue(null);
await LoadDependenciesAsync(result.Values, result);
ApplyInheritanceRules(result.Values);
// Fill outlines for categories
_outlineService.FillOutlinesForObjects(result.Values, catalogId);
return result;
}));
}
public virtual async Task <TaxProvider[]> GetByIdsAsync(string[] ids, string responseGroup)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", ids));
return(await _memCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var result = new List <TaxProvider>();
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var existEntities = await repository.GetStoreTaxProviderByIdsAsync(ids, responseGroup);
foreach (var existEntity in existEntities)
{
var taxProvider = AbstractTypeFactory <TaxProvider> .TryCreateInstance(string.IsNullOrEmpty(existEntity.TypeName) ? $"{existEntity.Code}TaxProvider" : existEntity.TypeName);
if (taxProvider != null)
{
existEntity.ToModel(taxProvider);
await _settingManager.DeepLoadSettingsAsync(taxProvider);
result.Add(taxProvider);
}
}
cacheEntry.AddExpirationToken(TaxCacheRegion.CreateChangeToken());
return result.ToArray();
}
}));
}
public async Task <ShoppingCartSearchResult> SearchCartAsync(ShoppingCartSearchCriteria criteria)
{
var result = AbstractTypeFactory <ShoppingCartSearchResult> .TryCreateInstance();
var cacheKey = CacheKey.With(GetType(), nameof(SearchCartAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
cacheEntry.AddExpirationToken(CartSearchCacheRegion.CreateChangeToken());
using (var repository = _repositoryFactory())
{
//Optimize performance and CPU usage
repository.DisableChangesTracking();
var sortInfos = BuildSortExpression(criteria);
var query = BuildQuery(repository, criteria);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var ids = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
result.Results = (await _cartService.GetByIdsAsync(ids, criteria.ResponseGroup)).OrderBy(x => Array.IndexOf(ids, x.Id)).ToList();
}
return result;
}
}));
}
public virtual async Task <DemoProductPart[]> GetByIdsAsync(string[] partIds)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", partIds.OrderBy(x => x)));
var result = await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
var parts = Array.Empty <DemoProductPart>();
if (!partIds.IsNullOrEmpty())
{
using var repository = (DemoCatalogRepository)_repositoryFactory();
//Optimize performance and CPU usage
repository.DisableChangesTracking();
var entities = await repository.GetProductPartsByIdsAsync(partIds);
parts = entities
.Select(x => x.ToModel(AbstractTypeFactory <DemoProductPart> .TryCreateInstance()))
.ToArray();
cacheEntry.AddExpirationToken(DemoProductPartCacheRegion.CreateChangeToken(partIds));
}
return(parts);
});
return(result);
}
public async Task <DynamicContentItemSearchResult> SearchContentItemsAsync(DynamicContentItemSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchContentItemsAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(DynamicContentItemCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <DynamicContentItemSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var sortInfos = BuildSortExpression(criteria);
var query = BuildQuery(criteria, repository);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var ids = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
result.Results = (await _dynamicContentService.GetContentItemsByIdsAsync(ids))
.OrderBy(x => Array.IndexOf(ids, x.Id)).ToList();
}
}
return result;
}));
}
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 async Task <CustomerSegment[]> GetByIdsAsync(string[] ids)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", ids.OrderBy(x => x)));
var result = await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
var rules = Array.Empty <CustomerSegment>();
if (!ids.IsNullOrEmpty())
{
using var customerSegmentsRepository = _customerSegmentRepositoryFactory();
//Optimize performance and CPU usage
customerSegmentsRepository.DisableChangesTracking();
var entities = await customerSegmentsRepository.GetByIdsAsync(ids);
rules = entities
.Select(x => x.ToModel(AbstractTypeFactory <CustomerSegment> .TryCreateInstance()))
.ToArray();
cacheEntry.AddExpirationToken(CustomerSegmentCacheRegion.CreateChangeToken(ids));
}
return(rules);
});
return(result);
}
public async Task <ProductVideoSearchResult> SearchVideoLinksAsync(ProductVideoSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchVideoLinksAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(ProductVideoCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <ProductVideoSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var query = repository.VideoLinks.Where(x => criteria.ProductIds.Contains(x.ProductId));
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var videoLinksIds = await query.OrderByDescending(x => x.CreatedDate).Skip(criteria.Skip)
.Take(criteria.Take)
.Select(x => x.Id)
.ToArrayAsync();
var priorResults = await _productVideoService.GetByIdsAsync(videoLinksIds);
//TODO warning EF1001: Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions is an internal API that supports the Entity Framework Core infrastructure and not subject to the same compatibility standards as public APIs.
result.Results = priorResults;
}
return result;
}
}));
}
#pragma warning disable S4457 // Parameter validation in "async"/"await" methods should be wrapped
public virtual async Task <PromotionUsageSearchResult> SearchUsagesAsync(PromotionUsageSearchCriteria criteria)
#pragma warning restore S4457 // Parameter validation in "async"/"await" methods should be wrapped
{
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
var cacheKey = CacheKey.With(GetType(), nameof(SearchUsagesAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(PromotionUsageSearchCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <PromotionUsageSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var sortInfos = BuildSortExpression(criteria);
var query = BuildQuery(repository, criteria);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var usages = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
result.Results = usages.Select(x => x.ToModel(AbstractTypeFactory <PromotionUsage> .TryCreateInstance())).ToList();
}
return result;
}
}));
}
public virtual async Task <IEnumerable <ShoppingCart> > GetByIdsAsync(string[] cartIds, string responseGroup = null)
{
var retVal = new List <ShoppingCart>();
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", cartIds), responseGroup);
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
using (var repository = _repositoryFactory())
{
//Disable DBContext change tracking for better performance
repository.DisableChangesTracking();
var cartEntities = await repository.GetShoppingCartsByIdsAsync(cartIds, responseGroup);
foreach (var cartEntity in cartEntities)
{
var cart = cartEntity.ToModel(AbstractTypeFactory <ShoppingCart> .TryCreateInstance());
//Calculate totals only for full responseGroup
if (responseGroup == null)
{
_totalsCalculator.CalculateTotals(cart);
}
retVal.Add(cart);
cacheEntry.AddExpirationToken(CartCacheRegion.CreateChangeToken(cart));
}
}
await _dynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal.ToArray <IHasDynamicProperties>());
return retVal;
}));
}
public async virtual Task <Association[]> GetByIdsAsync(string[] itemIds)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", itemIds.OrderBy(x => x)));
var result = await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
var rules = Array.Empty <Association>();
if (!itemIds.IsNullOrEmpty())
{
using (var dynamicAssociationsRepository = _associationsRepositoryFactory())
{
//Optimize performance and CPU usage
dynamicAssociationsRepository.DisableChangesTracking();
var entities = await dynamicAssociationsRepository.GetAssociationsByIdsAsync(itemIds);
rules = entities
.Select(x => x.ToModel(AbstractTypeFactory <Association> .TryCreateInstance()))
.ToArray();
cacheEntry.AddExpirationToken(AssociationCacheRegion.CreateChangeToken(itemIds));
}
}
return(rules);
});
return(result);
}
public async Task <Store[]> GetByIdsAsync(string[] ids)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", ids));
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var stores = new List <Store>();
using (var repository = _repositoryFactory())
{
var dbStores = await repository.GetStoresByIdsAsync(ids);
foreach (var dbStore in dbStores)
{
var store = AbstractTypeFactory <Store> .TryCreateInstance();
dbStore.ToModel(store);
PopulateStore(store, dbStore);
await _settingManager.DeepLoadSettingsAsync(store);
stores.Add(store);
cacheEntry.AddExpirationToken(StoreCacheRegion.CreateChangeToken(store));
}
}
var result = stores.ToArray();
var taskLoadDynamicPropertyValues = _dynamicPropertyService.LoadDynamicPropertyValuesAsync(result);
var taskLoadSeoForObjects = _seoService.LoadSeoForObjectsAsync(result);
await Task.WhenAll(taskLoadDynamicPropertyValues, taskLoadSeoForObjects);
return result;
}));
}
public virtual async Task <PromotionSearchResult> SearchPromotionsAsync(PromotionSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchPromotionsAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(PromotionSearchCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <PromotionSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var sortInfos = BuildSortExpression(criteria);
var query = BuildQuery(repository, criteria);
//https://github.com/zzzprojects/EntityFramework-Plus/issues/293
//Workaround ArgumentException with CountAsync have no predicate when query has a Cast or OfType expression
result.TotalCount = await query.CountAsync(x => true);
if (criteria.Take > 0)
{
var ids = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
result.Results = (await _promotionService.GetPromotionsByIdsAsync(ids))
.OrderBy(x => Array.IndexOf(ids, x.Id)).ToList();
}
}
return result;
}));
}
public async Task <ShoppingCartSearchResult> SearchCartAsync(ShoppingCartSearchCriteria criteria)
{
var retVal = AbstractTypeFactory <ShoppingCartSearchResult> .TryCreateInstance();
var cacheKey = CacheKey.With(GetType(), "SearchCartAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
cacheEntry.AddExpirationToken(CartSearchCacheRegion.CreateChangeToken());
using (var repository = _repositoryFactory())
{
var sortInfos = GetSortInfos(criteria);
var query = GetQuery(repository, criteria, sortInfos);
retVal.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var cartIds = await query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
retVal.Results = (await _cartService.GetByIdsAsync(cartIds, criteria.ResponseGroup)).AsQueryable().OrderBySortInfos(sortInfos).ToArray();
}
return retVal;
}
}));
}
public virtual async Task <StoreSearchResult> SearchStoresAsync(StoreSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), "SearchStoresAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(StoreCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <StoreSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = "Name"
}
};
}
var query = GetStoresQuery(repository, criteria, sortInfos);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var storeIds = await query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
result.Results = (await _storeService.GetByIdsAsync(storeIds)).AsQueryable().OrderBySortInfos(sortInfos).ToList();
}
}
return result;
}));
}
public override async Task <Role> FindByNameAsync(string roleName)
{
var cacheKey = CacheKey.With(GetType(), "FindByNameAsync", roleName);
var result = await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(SecurityCacheRegion.CreateChangeToken());
var role = await base.FindByNameAsync(roleName);
if (role != null)
{
await LoadRolePermissionsAsync(role);
}
return(role);
}, cacheNullValue : false);
return(result);
}
public async Task <SubscriptionSearchResult> SearchAsync(SubscriptionSearchCriteria searchCriteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchAsync), searchCriteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(SubscriptionSearchCacheRegion.CreateChangeToken());
var result = new SubscriptionSearchResult();
using (var repository = _subscriptionRepositoryFactory())
{
repository.DisableChangesTracking();
var sortInfos = BuildSortExpression(searchCriteria);
var query = BuildQuery(searchCriteria, repository);
result.TotalCount = await query.CountAsync();
if (searchCriteria.Take > 0 && result.TotalCount > 0)
{
var subscriptionIds = query.OrderBySortInfos(sortInfos)
.ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(searchCriteria.Skip)
.Take(searchCriteria.Take)
.ToArray();
result.Results = (await _subscriptionService.GetByIdsAsync(subscriptionIds, searchCriteria.ResponseGroup)).OrderBy(x => Array.IndexOf(subscriptionIds, x.Id)).ToArray();
}
}
return result;
}));
}
public async Task <ProductAssociationSearchResult> SearchProductAssociationsAsync(ProductAssociationSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
var cacheKey = CacheKey.With(GetType(), "SearchProductAssociationsAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(AssociationSearchCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <ProductAssociationSearchResult> .TryCreateInstance();
if (!criteria.ObjectIds.IsNullOrEmpty())
{
using (var repository = _catalogRepositoryFactory())
{
//Optimize performance and CPU usage
repository.DisableChangesTracking();
var dbResult = await repository.SearchAssociations(criteria);
result.TotalCount = dbResult.TotalCount;
result.Results = dbResult.Results
.Select(x => x.ToModel(AbstractTypeFactory <ProductAssociation> .TryCreateInstance())).ToList();
}
}
return result;
}));
}
public async Task <PaymentMethod[]> GetByIdsAsync(string[] ids, string responseGroup)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", ids));
return(await _memCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var result = new List <PaymentMethod>();
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var existEntities = await repository.GetStorePaymentMethodsByIdsAsync(ids, responseGroup);
foreach (var existEntity in existEntities)
{
var paymentMethod = AbstractTypeFactory <PaymentMethod> .TryCreateInstance(string.IsNullOrEmpty(existEntity.TypeName) ? existEntity.Code : existEntity.TypeName);
if (paymentMethod != null)
{
existEntity.ToModel(paymentMethod);
await _settingManager.DeepLoadSettingsAsync(paymentMethod);
result.Add(paymentMethod);
}
}
cacheEntry.AddExpirationToken(PaymentCacheRegion.CreateChangeToken());
return result.ToArray();
}
}));
}
public override async Task <ApplicationUser> FindByLoginAsync(string loginProvider, string providerKey)
{
var cacheKey = CacheKey.With(GetType(), nameof(FindByLoginAsync), loginProvider, providerKey);
var result = await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var user = await base.FindByLoginAsync(loginProvider, providerKey);
if (user != null)
{
await LoadUserDetailsAsync(user);
cacheEntry.AddExpirationToken(SecurityCacheRegion.CreateChangeTokenForUser(user));
}
return(user);
}, cacheNullValue : false);
return(result);
}
public virtual async Task <SubscriptionSearchResult> SearchSubscriptionsAsync(SubscriptionSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchSubscriptionsAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
cacheEntry.AddExpirationToken(SubscriptionSearchCacheRegion.CreateChangeToken());
var retVal = AbstractTypeFactory <SubscriptionSearchResult> .TryCreateInstance();
using (var repository = _subscriptionRepositoryFactory())
{
repository.DisableChangesTracking();
var query = BuildQuery(repository, criteria);
var sortInfos = BuildSortExpression(criteria);
retVal.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var subscriptionsIds = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
//Load subscriptions with preserving sorting order
var unorderedResults = await _subscriptionService.GetByIdsAsync(subscriptionsIds, criteria.ResponseGroup);
retVal.Results = unorderedResults.OrderBy(x => Array.IndexOf(subscriptionsIds, x.Id)).ToArray();
}
return retVal;
}
}));
}
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 virtual async Task <ChangeLogSearchResult> SearchAsync(ChangeLogSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchAsync), criteria.GetCacheKey());
var result = await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(ChangeLogCacheRegion.CreateChangeToken());
var searchResult = AbstractTypeFactory <ChangeLogSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var sortInfos = GetSortInfos(criteria);
var query = GetQuery(repository, criteria, sortInfos);
searchResult.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
searchResult.Results = (await query.AsNoTracking().Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync()).Select(x => x.ToModel(AbstractTypeFactory <OperationLog> .TryCreateInstance())).ToList();
}
}
return(searchResult);
});
return(result);
}
