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 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 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();
}
if (retVal != null)
{
await _dynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal);
}
return retVal;
}));
}
public virtual async Task <CustomerOrder[]> GetByIdsAsync(string[] orderIds, string responseGroup = null)
{
var cacheKey = CacheKey.With(GetType(), "GetByIdsAsync", string.Join("-", orderIds), responseGroup);
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
var retVal = new List <CustomerOrder>();
var orderResponseGroup = EnumUtility.SafeParse(responseGroup, CustomerOrderResponseGroup.Full);
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var orderEntities = await repository.GetCustomerOrdersByIdsAsync(orderIds, orderResponseGroup);
foreach (var orderEntity in orderEntities)
{
var customerOrder = AbstractTypeFactory <CustomerOrder> .TryCreateInstance();
if (customerOrder != null)
{
customerOrder = orderEntity.ToModel(customerOrder) as CustomerOrder;
//Calculate totals only for full responseGroup
if (orderResponseGroup == CustomerOrderResponseGroup.Full)
{
_totalsCalculator.CalculateTotals(customerOrder);
}
LoadOrderDependencies(customerOrder);
retVal.Add(customerOrder);
cacheEntry.AddExpirationToken(OrderCacheRegion.CreateChangeToken(customerOrder));
}
}
}
await _dynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal.ToArray <IHasDynamicProperties>());
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(), "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));
}
}
}
await _dynamicPropertyService.LoadDynamicPropertyValuesAsync(retVal.ToArray <IHasDynamicProperties>());
return retVal.ToArray();
}));
}