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; })); }