public async Task Process()
{
var criteria = new SubscriptionSearchCriteria
{
Statuses = new[] { SubscriptionStatus.Active, SubscriptionStatus.PastDue, SubscriptionStatus.Trialing, SubscriptionStatus.Unpaid }.Select(x => x.ToString()).ToArray(),
Take = 0,
};
var result = await _subscriptionSearchService.SearchSubscriptionsAsync(criteria);
var batchSize = 20;
for (var i = 0; i < result.TotalCount; i += batchSize)
{
criteria.Skip = i;
criteria.Take = batchSize;
result = await _subscriptionSearchService.SearchSubscriptionsAsync(criteria);
var subscriptions = await _subscriptionService.GetByIdsAsync(result.Results.Select(x => x.Id).ToArray());
foreach (var subscription in subscriptions)
{
var subscriptionBuilder = await _subscriptionBuilder.TakeSubscription(subscription).ActualizeAsync();
var newOrder = await subscriptionBuilder.TryToCreateRecurrentOrderAsync();
if (newOrder != null)
{
await _customerOrderService.SaveChangesAsync(new[] { newOrder });
}
}
}
}
// "DisableConcurrentExecutionAttribute" prevents to start simultaneous job payloads.
// Should have short timeout, because this attribute implemented by following manner: newly started job falls into "processing" state immediately.
// Then it tries to receive job lock during timeout. If the lock received, the job starts payload.
// When the job is awaiting desired timeout for lock release, it stucks in "processing" anyway. (Therefore, you should not to set long timeouts (like 24*60*60), this will cause a lot of stucked jobs and performance degradation.)
// Then, if timeout is over and the lock NOT acquired, the job falls into "scheduled" state (this is default fail-retry scenario).
// Failed job goes to "Failed" state (by default) after retries exhausted.
public async Task Process()
{
var criteria = new SubscriptionSearchCriteria
{
Statuses = new[] { SubscriptionStatus.Active, SubscriptionStatus.PastDue, SubscriptionStatus.Trialing, SubscriptionStatus.Unpaid }.Select(x => x.ToString()).ToArray(),
Take = 0
};
var result = await _subscriptionSearchService.SearchSubscriptionsAsync(criteria);
var batchSize = 20;
for (var i = 0; i < result.TotalCount; i += batchSize)
{
criteria.Skip = i;
criteria.Take = batchSize;
result = await _subscriptionSearchService.SearchSubscriptionsAsync(criteria);
var subscriptions = await _subscriptionService.GetByIdsAsync(result.Results.Select(x => x.Id).ToArray());
foreach (var subscription in subscriptions)
{
await _subscriptionBuilder.TakeSubscription(subscription).ActualizeAsync();
}
await _subscriptionService.SaveSubscriptionsAsync(subscriptions);
}
}
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 static Task WithUserSubscriptionsAsync(this IWorkContextBuilder builder)
{
if (builder.WorkContext.CurrentUser != null)
{
var serviceProvider = builder.HttpContext.RequestServices;
var subscriptionService = serviceProvider.GetRequiredService <ISubscriptionService>();
Func <int, int, IEnumerable <SortInfo>, NameValueCollection, IPagedList <Subscription> > factory = (pageNumber, pageSize, sortInfos, @params) =>
{
var subscriptionSearchCriteria = new SubscriptionSearchCriteria
{
PageNumber = pageNumber,
PageSize = pageSize,
Sort = sortInfos?.ToString(),
CustomerId = builder.WorkContext.CurrentUser.Id
};
if (@params != null)
{
subscriptionSearchCriteria.CopyFrom(@params);
}
return(subscriptionService.SearchSubscription(subscriptionSearchCriteria));
};
return(builder.WithUserSubscriptionsAsync(new MutablePagedList <Subscription>(factory, 1, SubscriptionSearchCriteria.DefaultPageSize)));
}
return(Task.CompletedTask);
}
public IHttpActionResult SearchSubscriptions(SubscriptionSearchCriteria criteria)
{
var result = _subscriptionSearchService.SearchSubscriptions(criteria);
var retVal = new SubscriptionSearchResult
{
Subscriptions = result.Results.ToList(),
TotalCount = result.TotalCount
};
return(Ok(retVal));
}
public async Task <IActionResult> SearchSubscriptions([FromBody] SubscriptionSearchCriteria criteria)
{
var result = await _subscriptionSearchService.SearchSubscriptionsAsync(criteria);
var retVal = new SubscriptionSearchResult
{
Subscriptions = result.Results.ToList(),
TotalCount = result.TotalCount
};
return(Ok(retVal));
}
public async Task <ActionResult> SearchCustomerSubscriptions([FromBody] SubscriptionSearchCriteria searchCriteria)
{
if (searchCriteria == null)
{
searchCriteria = new SubscriptionSearchCriteria();
}
//Does not allow to see a other subscriptions
searchCriteria.CustomerId = WorkContext.CurrentUser.Id;
var result = await _subscriptionService.SearchSubscriptionsAsync(searchCriteria);
return(Json(new { TotalCount = result.TotalItemCount, Results = result.ToArray() }));
}
private async Task <Subscription> GetSubscriptionByNumberAsync(string number)
{
var criteria = new SubscriptionSearchCriteria
{
Number = number
};
var retVal = (await _subscriptionService.SearchSubscriptionsAsync(criteria)).FirstOrDefault();
if (retVal == null || retVal.CustomerId != WorkContext.CurrentUser.Id)
{
throw new StorefrontException($"Subscription with number {{ number }} not found (or not belongs to current user)");
}
return(retVal);
}
public static subscriptionDto.SubscriptionSearchCriteria ToSearchCriteriaDto(this SubscriptionSearchCriteria criteria)
{
var result = new subscriptionDto.SubscriptionSearchCriteria
{
CustomerId = criteria.CustomerId,
Sort = criteria.Sort,
Number = criteria.Number,
Skip = criteria.Start,
Take = criteria.PageSize
};
result.Sort = criteria.Sort;
return(result);
}
public async Task <IPagedList <Subscription> > SearchSubscriptionsAsync(SubscriptionSearchCriteria criteria)
{
var workContext = _workContextAccessor.WorkContext;
var cacheKey = CacheKey.With(GetType(), "SearchSubscription", criteria.GetCacheKey());
return(await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
//Observe all subscriptions for current user and invalidate them in cache if any changed (one limitation - this toke doesn't detect subscriptions deletions)
cacheEntry.AddExpirationToken(new PollingApiSubscriptionsChangeToken(_subscriptionApi, _options.ChangesPollingInterval));
cacheEntry.AddExpirationToken(SubscriptionCacheRegion.CreateCustomerSubscriptionChangeToken(criteria.CustomerId));
var result = await _subscriptionApi.SearchSubscriptionsAsync(criteria.ToSearchCriteriaDto());
return new StaticPagedList <Subscription>(result.Subscriptions.Select(x => x.ToSubscription(workContext.AllCurrencies, workContext.CurrentLanguage)),
criteria.PageNumber, criteria.PageSize, result.TotalCount.Value);
}));
}
protected virtual async Task HandleEvent(DomainEvent domainEvent, CancellationToken cancellationToken)
{
var eventId = domainEvent.GetType().FullName;
var criteria = new SubscriptionSearchCriteria()
{
EventIds = new[] { eventId },
Skip = 0,
Take = int.MaxValue,
};
var searchResult = await _subscriptionSearchService.SearchAsync(criteria);
if (searchResult.TotalCount > 0)
{
var entities = domainEvent.GetObjectsWithDerived <IEntity>()
.Select(x => new EventData {
ObjectId = x.Id, ObjectType = x.GetType().FullName, EventId = eventId
})
.ToArray();
var valueObjects = domainEvent.GetObjectsWithDerived <ValueObject>()
.Select(x => new EventData {
ObjectId = x.GetCacheKey(), ObjectType = x.GetType().FullName, EventId = eventId
})
.ToArray();
var eventData = entities.Union(valueObjects).ToArray();
var activeSubscritions = new List <SubscriptionInfo>();
foreach (var subscription in searchResult.Results)
{
var provider = _eventBusFactory.CreateProvider(subscription.Provider);
if (provider != null)
{
var result = await provider.SendEventAsync(subscription, eventData);
subscription.Status = result.Status;
if (!string.IsNullOrEmpty(result.ErrorMessage))
{
subscription.ErrorMessage = new string(result.ErrorMessage.Take(1024).ToArray());
}
activeSubscritions.Add(subscription);
}
}
await _subscriptionService.SaveChangesAsync(activeSubscritions.ToArray());
}
}
protected virtual IQueryable <SubscriptionEntity> BuildQuery(SubscriptionSearchCriteria searchCriteria, ISubscriptionRepository repository)
{
var query = repository.Subscriptions;
if (!string.IsNullOrEmpty(searchCriteria.Provider))
{
query = query.Where(x => x.Provider.Contains(searchCriteria.Provider));
}
if (!searchCriteria.EventIds.IsNullOrEmpty())
{
query = query.Where(x => x.Events.Any(y => searchCriteria.EventIds.Contains(y.EventId)));
}
return(query);
}
protected virtual IList <SortInfo> BuildSortExpression(SubscriptionSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo {
SortColumn = nameof(SubscriptionEntity.CreatedDate)
}
};
}
return(sortInfos);
}
protected virtual IMutablePagedList <Subscription> LazyLoadCustomerSubscriptions(Contact customer)
{
var subscriptionSearchcriteria = new SubscriptionSearchCriteria
{
CustomerId = customer.Id
};
Func <int, int, IEnumerable <SortInfo>, IPagedList <Subscription> > subscriptionGetter = (pageNumber, pageSize, sortInfos) =>
{
subscriptionSearchcriteria.PageNumber = pageNumber;
subscriptionSearchcriteria.PageSize = pageSize;
return(_subscriptionService.SearchSubscription(subscriptionSearchcriteria));
};
return(new MutablePagedList <Subscription>(subscriptionGetter, 1, SubscriptionSearchCriteria.DefaultPageSize));
}
public IPagedList <Subscription> SearchSubscription(SubscriptionSearchCriteria criteria)
{
var workContext = _workContextAccessor.WorkContext;
//It is very important to have both versions for Sync and Async methods with same cache key due to performance for multithreaded requests
//you should avoid of call async version with TaskFactory.StartNew() out of the cache getter function
var cacheKey = CacheKey.With(GetType(), "SearchSubscription", criteria.GetCacheKey());
return(_memoryCache.GetOrCreateExclusive(cacheKey, (cacheEntry) =>
{
//Observe all subscriptions for current user and invalidate them in cache if any changed (one limitation - this toke doesn't detect subscriptions deletions)
cacheEntry.AddExpirationToken(new PoolingApiSubscriptionsChangeToken(_subscriptionApi, _options.ChangesPoolingInterval));
cacheEntry.AddExpirationToken(SubscriptionCacheRegion.CreateCustomerSubscriptionChangeToken(criteria.CustomerId));
var result = _subscriptionApi.SearchSubscriptions(criteria.ToSearchCriteriaDto());
return new StaticPagedList <Subscription>(result.Subscriptions.Select(x => x.ToSubscription(workContext.AllCurrencies, workContext.CurrentLanguage)),
criteria.PageNumber, criteria.PageSize, result.TotalCount.Value);
}));
}
public async Task <ActionResult> SearchCustomerSubscriptions(SubscriptionSearchCriteria searchCriteria)
{
if (searchCriteria == null)
{
searchCriteria = new SubscriptionSearchCriteria();
}
//Does not allow to see a other subscriptions
searchCriteria.CustomerId = WorkContext.CurrentCustomer.Id;
var result = await _subscriptionApi.SubscriptionModule.SearchAsync(searchCriteria.ToSearchCriteriaDto());
return(Json(new
{
Results = result.Subscriptions.Select(x => x.ToSubscription(WorkContext.AllCurrencies, WorkContext.CurrentLanguage)).ToArray(),
TotalCount = result.TotalCount,
}));
}
public static subscriptionDto.SubscriptionSearchCriteria ToSearchCriteriaDto(this SubscriptionSearchCriteria criteria)
{
var result = new subscriptionDto.SubscriptionSearchCriteria
{
CustomerId = criteria.CustomerId,
Sort = criteria.Sort,
Number = criteria.Number,
Skip = criteria.Start,
Take = criteria.PageSize,
ResponseGroup = ((int)criteria.ResponseGroup).ToString(),
ModifiedSinceDate = criteria.ModifiedSinceDate
};
result.Sort = criteria.Sort;
return(result);
}
public void Process()
{
var criteria = new SubscriptionSearchCriteria
{
Statuses = new[] { SubscriptionStatus.Active, SubscriptionStatus.PastDue, SubscriptionStatus.Trialing, SubscriptionStatus.Unpaid }.Select(x => x.ToString()).ToArray(),
};
var result = _subscriptionSearchService.SearchSubscriptions(criteria);
var batchSize = 20;
for (int i = 0; i < result.TotalCount; i += batchSize)
{
var subscriptions = _subscriptionService.GetByIds(result.Results.Skip(i).Take(batchSize).Select(x => x.Id).ToArray());
foreach (var subscription in subscriptions)
{
_subscriptionBuilder.TakeSubscription(subscription).Actualize();
}
_subscriptionService.SaveSubscriptions(subscriptions);
}
}
public void Process()
{
var criteria = new SubscriptionSearchCriteria
{
Statuses = new[] { SubscriptionStatus.Active, SubscriptionStatus.PastDue, SubscriptionStatus.Trialing, SubscriptionStatus.Unpaid }.Select(x => x.ToString()).ToArray(),
};
var result = _subscriptionSearchService.SearchSubscriptions(criteria);
var batchSize = 20;
for (int i = 0; i < result.TotalCount; i += batchSize)
{
var subscriptions = _subscriptionService.GetByIds(result.Results.Skip(i).Take(batchSize).Select(x => x.Id).ToArray());
foreach (var subscription in subscriptions)
{
var newOrder = _subscriptionBuilder.TakeSubscription(subscription).Actualize().TryToCreateRecurrentOrder();
if (newOrder != null)
{
_customerOrderService.SaveChanges(new[] { newOrder });
}
}
}
}
public async Task TestDataExportImport()
{
// Arrange
var firstSubscriptionCriteria = new SubscriptionSearchCriteria {
Take = 0, ResponseGroup = SubscriptionResponseGroup.Default.ToString()
};
var firstSubscriptionResult = new SubscriptionSearchResult {
TotalCount = TestSubscriptions.Count
};
_subscriptionSearchService
.Setup(subscriptionSearchService => subscriptionSearchService.SearchSubscriptionsAsync(firstSubscriptionCriteria))
.ReturnsAsync(firstSubscriptionResult);
var secondSubscriptionCriteria = new SubscriptionSearchCriteria {
Skip = 0, Take = ExpectedBatchSize, ResponseGroup = SubscriptionResponseGroup.Default.ToString()
};
var secondSubscriptionResult = new SubscriptionSearchResult {
TotalCount = TestSubscriptions.Count, Results = TestSubscriptions
};
_subscriptionSearchService
.Setup(subscriptionSearchService => subscriptionSearchService.SearchSubscriptionsAsync(secondSubscriptionCriteria))
.ReturnsAsync(secondSubscriptionResult);
var firstPaymentPlanCriteria = new PaymentPlanSearchCriteria {
Take = 0
};
var firstPaymentPlanResult = new PaymentPlanSearchResult {
TotalCount = TestPaymentPlans.Count
};
_paymentPlanSearchService.Setup(service => service.SearchPlansAsync(firstPaymentPlanCriteria))
.ReturnsAsync(firstPaymentPlanResult);
var secondPaymentPlanCriteria = new PaymentPlanSearchCriteria {
Skip = 0, Take = ExpectedBatchSize
};
var secondPaymentPlanResult = new PaymentPlanSearchResult {
TotalCount = TestPaymentPlans.Count, Results = TestPaymentPlans
};
_paymentPlanSearchService.Setup(service => service.SearchPlansAsync(secondPaymentPlanCriteria))
.ReturnsAsync(secondPaymentPlanResult);
Subscription[] actualSubscriptions = null;
_subscriptionService.Setup(service => service.SaveSubscriptionsAsync(It.IsAny <Subscription[]>()))
.Callback <Subscription[]>(subscriptions => actualSubscriptions = subscriptions)
.Returns(Task.CompletedTask);
PaymentPlan[] actualPaymentPlans = null;
_paymentPlanService.Setup(service => service.SavePlansAsync(It.IsAny <PaymentPlan[]>()))
.Callback <PaymentPlan[]>(paymentPlans => actualPaymentPlans = paymentPlans)
.Returns(Task.CompletedTask);
// Act
string actualJson;
using (var targetStream = new MemoryStream())
{
await _subscriptionExportImport.DoExportAsync(targetStream, IgnoreProgressInfo, _cancellationToken.Object);
// DoExportAsync() closes targetStream, so extracting data from it is a bit tricky...
var streamContents = targetStream.ToArray();
using (var copiedStream = new MemoryStream(streamContents))
using (var textReader = new StreamReader(copiedStream))
{
actualJson = await textReader.ReadToEndAsync();
}
}
var importStream = GetStreamFromString(actualJson);
await _subscriptionExportImport.DoImportAsync(importStream, IgnoreProgressInfo, _cancellationToken.Object);
//Assert
TestSubscriptions.Should().BeEquivalentTo(actualSubscriptions);
TestPaymentPlans.Should().BeEquivalentTo(actualPaymentPlans);
}
protected virtual IQueryable <SubscriptionEntity> BuildQuery(ISubscriptionRepository repository, SubscriptionSearchCriteria criteria)
{
var query = repository.Subscriptions;
if (!string.IsNullOrEmpty(criteria.Number))
{
query = query.Where(x => x.Number == criteria.Number);
}
else if (criteria.Keyword != null)
{
query = query.Where(x => x.Number.Contains(criteria.Keyword));
}
if (criteria.CustomerId != null)
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.Statuses != null && criteria.Statuses.Any())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (criteria.StoreId != null)
{
query = query.Where(x => criteria.StoreId == x.StoreId);
}
if (criteria.StartDate != null)
{
query = query.Where(x => x.CreatedDate >= criteria.StartDate);
}
if (criteria.EndDate != null)
{
query = query.Where(x => x.CreatedDate <= criteria.EndDate);
}
if (criteria.ModifiedSinceDate != null)
{
query = query.Where(x => x.ModifiedDate >= criteria.ModifiedSinceDate);
}
if (!string.IsNullOrEmpty(criteria.CustomerOrderId))
{
var order = _customerOrderService.GetByIdsAsync(new[] { criteria.CustomerOrderId }).GetAwaiter().GetResult().FirstOrDefault();
if (order != null && !string.IsNullOrEmpty(order.SubscriptionId))
{
query = query.Where(x => x.Id == order.SubscriptionId);
}
else
{
query = query.Where(x => false);
}
}
if (criteria.OuterId != null)
{
query = query.Where(x => x.OuterId == criteria.OuterId);
}
return(query);
}
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 GenericSearchResult <Subscription> SearchSubscriptions(SubscriptionSearchCriteria criteria)
{
var retVal = new GenericSearchResult <Subscription>();
using (var repository = _subscriptionRepositoryFactory())
{
repository.DisableChangesTracking();
var query = repository.Subscriptions;
if (!string.IsNullOrEmpty(criteria.Number))
{
query = query.Where(x => x.Number == criteria.Number);
}
else if (criteria.Keyword != null)
{
query = query.Where(x => x.Number.Contains(criteria.Keyword));
}
if (criteria.CustomerId != null)
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.Statuses != null && criteria.Statuses.Any())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (criteria.StoreId != null)
{
query = query.Where(x => criteria.StoreId == x.StoreId);
}
if (criteria.StartDate != null)
{
query = query.Where(x => x.CreatedDate >= criteria.StartDate);
}
if (criteria.EndDate != null)
{
query = query.Where(x => x.CreatedDate <= criteria.EndDate);
}
if (criteria.ModifiedSinceDate != null)
{
query = query.Where(x => x.ModifiedDate >= criteria.ModifiedSinceDate);
}
if (!string.IsNullOrEmpty(criteria.CustomerOrderId))
{
var order = _customerOrderService.GetByIds(new[] { criteria.CustomerOrderId }).FirstOrDefault();
if (order != null && !string.IsNullOrEmpty(order.SubscriptionId))
{
query = query.Where(x => x.Id == order.SubscriptionId);
}
else
{
query = query.Where(x => false);
}
}
if (criteria.OuterId != null)
{
query = query.Where(x => x.OuterId == criteria.OuterId);
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <Subscription>(x => x.CreatedDate), SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
retVal.TotalCount = query.Count();
var subscriptionsIds = query.Skip(criteria.Skip)
.Take(criteria.Take)
.ToArray()
.Select(x => x.Id)
.ToArray();
//Load subscriptions with preserving sorting order
retVal.Results = GetByIds(subscriptionsIds, criteria.ResponseGroup).OrderBy(x => Array.IndexOf(subscriptionsIds, x.Id)).ToArray();
return(retVal);
}
}
public async Task <IPagedList <Subscription> > SearchSubscriptionsAsync(SubscriptionSearchCriteria criteria)
{
var workContext = _workContextAccessor.WorkContext;
return(await InnerSearchSubscriptionsAsync(criteria, workContext));
}
protected virtual async Task <IPagedList <Subscription> > InnerSearchSubscriptionsAsync(SubscriptionSearchCriteria criteria, WorkContext workContext)
{
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
var result = await _subscriptionApi.SearchSubscriptionsAsync(criteria.ToSearchCriteriaDto());
return(new StaticPagedList <Subscription>(result.Subscriptions.Select(x => x.ToSubscription(workContext.AllCurrencies, workContext.CurrentLanguage)),
criteria.PageNumber, criteria.PageSize, result.TotalCount.Value));
}
public virtual async Task <GenericSearchResult <Subscription> > 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 = new GenericSearchResult <Subscription>();
using (var repository = SubscriptionRepositoryFactory())
{
repository.DisableChangesTracking();
var query = await GetSubscriptionsQueryForCriteria(repository, criteria);
retVal.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var subscriptionEntities = await query.Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
var subscriptionsIds = subscriptionEntities.Select(x => x.Id).ToArray();
//Load subscriptions with preserving sorting order
var unorderedResults = await GetByIdsAsync(subscriptionsIds, criteria.ResponseGroup);
retVal.Results = unorderedResults.OrderBy(x => Array.IndexOf(subscriptionsIds, x.Id)).ToArray();
}
return retVal;
}
}));
}
public static subscriptionDto.SubscriptionSearchCriteria ToSearchCriteriaDto(this SubscriptionSearchCriteria criteria)
{
return(SubscriptionConverterInstance.ToSearchCriteriaDto(criteria));
}
protected virtual async Task <IQueryable <SubscriptionEntity> > GetSubscriptionsQueryForCriteria(
ISubscriptionRepository repository, SubscriptionSearchCriteria criteria)
{
var query = repository.Subscriptions;
if (!string.IsNullOrEmpty(criteria.Number))
{
query = query.Where(x => x.Number == criteria.Number);
}
else if (criteria.Keyword != null)
{
query = query.Where(x => x.Number.Contains(criteria.Keyword));
}
if (criteria.CustomerId != null)
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.Statuses != null && criteria.Statuses.Any())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (criteria.StoreId != null)
{
query = query.Where(x => criteria.StoreId == x.StoreId);
}
if (criteria.StartDate != null)
{
query = query.Where(x => x.CreatedDate >= criteria.StartDate);
}
if (criteria.EndDate != null)
{
query = query.Where(x => x.CreatedDate <= criteria.EndDate);
}
if (criteria.ModifiedSinceDate != null)
{
query = query.Where(x => x.ModifiedDate >= criteria.ModifiedSinceDate);
}
if (!string.IsNullOrEmpty(criteria.CustomerOrderId))
{
var order = (await _customerOrderService.GetByIdsAsync(new[] { criteria.CustomerOrderId })).FirstOrDefault();
if (order != null && !string.IsNullOrEmpty(order.SubscriptionId))
{
query = query.Where(x => x.Id == order.SubscriptionId);
}
else
{
query = query.Where(x => false);
}
}
if (criteria.OuterId != null)
{
query = query.Where(x => x.OuterId == criteria.OuterId);
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <Subscription>(x => x.CreatedDate), SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
return(query);
}
public virtual subscriptionDto.SubscriptionSearchCriteria ToSearchCriteriaDto(SubscriptionSearchCriteria criteria)
{
var result = new subscriptionDto.SubscriptionSearchCriteria();
result.InjectFrom(criteria);
result.Skip = criteria.Start;
result.Take = criteria.PageSize;
result.Sort = criteria.Sort;
return(result);
}
public async Task <ActionResult <SubscriptionSearchResult> > Search([FromBody] SubscriptionSearchCriteria searchCriteria)
{
var searchResult = await _subscriptionSearchService.SearchAsync(searchCriteria);
return(Ok(searchResult));
}
