public async Task SaveChangesAsync(PaymentMethod[] paymentMethods)
{
var pkMap = new PrimaryKeyResolvingMap();
using (var repository = _repositoryFactory())
{
var dataExistEntities = await repository.GetStorePaymentMethodsByIdsAsync(paymentMethods.Where(x => !x.IsTransient())
.Select(x => x.Id)
.ToArray());
foreach (var paymentMethod in paymentMethods)
{
var originalEntity = dataExistEntities.FirstOrDefault(x => x.Id == paymentMethod.Id);
var modifiedEntity = AbstractTypeFactory <StorePaymentMethodEntity> .TryCreateInstance().FromModel(paymentMethod, pkMap);
if (originalEntity != null)
{
modifiedEntity.Patch(originalEntity);
}
else
{
repository.Add(modifiedEntity);
}
}
//Raise domain events
await repository.UnitOfWork.CommitAsync();
pkMap.ResolvePrimaryKeys();
//Save settings
await _settingManager.DeepSaveSettingsAsync(paymentMethods);
}
PaymentCacheRegion.ExpireRegion();
}
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 async Task <PaymentMethodsSearchResult> SearchPaymentMethodsAsync(PaymentMethodsSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), "SearchPaymentMethodsAsync", criteria.GetCacheKey());
return(await _memCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(PaymentCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <PaymentMethodsSearchResult> .TryCreateInstance();
var tmpSkip = 0;
var tmpTake = 0;
var sortInfos = GetSortInfos(criteria);
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var query = GetQuery(repository, criteria, sortInfos);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var paymentMethodsIds = await query.Select(x => x.Id)
.Skip(criteria.Skip)
.Take(criteria.Take)
.ToArrayAsync();
result.Results = (await _paymentMethodsService.GetByIdsAsync(paymentMethodsIds, criteria.ResponseGroup))
.AsQueryable()
.OrderBySortInfos(sortInfos)
.ToArray();
}
}
//Need to concatenate persistent methods with registered types and still not persisted
tmpSkip = Math.Min(result.TotalCount, criteria.Skip);
tmpTake = Math.Min(criteria.Take, Math.Max(0, result.TotalCount - criteria.Skip));
criteria.Skip = criteria.Skip - tmpSkip;
criteria.Take = criteria.Take - tmpTake;
if (criteria.Take > 0)
{
var transientMethodsQuery = AbstractTypeFactory <PaymentMethod> .AllTypeInfos.Select(x => AbstractTypeFactory <PaymentMethod> .TryCreateInstance(x.Type.Name))
.OfType <PaymentMethod>().AsQueryable();
if (!string.IsNullOrEmpty(criteria.Keyword))
{
transientMethodsQuery = transientMethodsQuery.Where(x => x.Code.Contains(criteria.Keyword));
}
var allPersistentTypes = result.Results.Select(x => x.GetType()).Distinct();
transientMethodsQuery = transientMethodsQuery.Where(x => !allPersistentTypes.Contains(x.GetType()));
result.TotalCount += transientMethodsQuery.Count();
var transientProviders = transientMethodsQuery.Skip(criteria.Skip).Take(criteria.Take).ToList();
foreach (var transientProvider in transientProviders)
{
await _settingsManager.DeepLoadSettingsAsync(transientProvider);
}
result.Results = result.Results.Concat(transientProviders).AsQueryable().OrderBySortInfos(sortInfos).ToList();
}
return result;
}));
}
