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 <DynamicContentItem[]> EvaluateItemsAsync(IEvaluationContext context)
{
if (!(context is DynamicContentEvaluationContext dynamicContext))
{
throw new ArgumentException("The context must be a DynamicContentEvaluationContext.");
}
if (dynamicContext.ToDate == default)
{
dynamicContext.ToDate = DateTime.UtcNow;
}
var result = new List <DynamicContentItem>();
var criteria = AbstractTypeFactory <DynamicContentPublicationSearchCriteria> .TryCreateInstance();
criteria = criteria.FromEvalContext(dynamicContext);
var publishings = await _contentPublicationsSearchService.SearchContentPublicationsAsync(criteria);
foreach (var publishing in publishings.Results)
{
try
{
//Next step need filter assignments contains dynamicexpression
if (publishing.DynamicExpression != null && publishing.DynamicExpression.IsSatisfiedBy(context))
{
result.AddRange(publishing.ContentItems);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
}
return(await _dynamicContentService.GetContentItemsByIdsAsync(result.Select(x => x.Id).ToArray()));
}
public async Task <ActionResult <coreModel.DynamicContentItem> > GetDynamicContentById(string id)
{
var items = await _dynamicContentService.GetContentItemsByIdsAsync(new[] { id });
var retVal = items.FirstOrDefault();
if (retVal != null)
{
return(Ok(retVal));
}
return(NotFound());
}
public async Task <DynamicContentItem[]> EvaluateItemsAsync(IEvaluationContext context)
{
if (!(context is DynamicContentEvaluationContext dynamicContext))
{
throw new ArgumentException("The context must be a DynamicContentEvaluationContext.");
}
if (dynamicContext.ToDate == default(DateTime))
{
dynamicContext.ToDate = DateTime.UtcNow;
}
var retVal = new List <DynamicContentItem>();
using (var repository = _repositoryFactory())
{
var publishings = await repository.PublishingGroups
.Include(x => x.ContentItems)
.Where(x => x.IsActive)
.Where(x => x.StoreId == dynamicContext.StoreId)
.Where(x => (x.StartDate == null || dynamicContext.ToDate >= x.StartDate) && (x.EndDate == null || x.EndDate >= dynamicContext.ToDate))
.Where(x => x.ContentPlaces.Any(y => y.ContentPlace.Name == dynamicContext.PlaceName))
.OrderBy(x => x.Priority)
.ToArrayAsync();
//Get content items ids for publishings without ConditionExpression
var contentItemIds = publishings.Where(x => x.ConditionExpression == null)
.SelectMany(x => x.ContentItems)
.Select(x => x.DynamicContentItemId)
.ToList();
foreach (var publishing in publishings.Where(x => x.ConditionExpression != null))
{
try
{
//Next step need filter assignments contains dynamicexpression
var conditions = JsonConvert.DeserializeObject <Condition[]>(publishing.ConditionExpression, new ConditionJsonConverter());
if (conditions.All(c => c.Evaluate(context)))
{
contentItemIds.AddRange(publishing.ContentItems.Select(x => x.DynamicContentItemId));
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
}
var dunamicContentItems = await _dynamicContentService.GetContentItemsByIdsAsync(contentItemIds.ToArray());
retVal.AddRange(dunamicContentItems);
}
return(retVal.ToArray());
}
public async Task <DynamicContentItemSearchResult> SearchContentItemsAsync(DynamicContentItemSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), "SearchContentItemsAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(DynamicContentItemCacheRegion.CreateChangeToken());
var retVal = AbstractTypeFactory <DynamicContentItemSearchResult> .TryCreateInstance();
using (var repository = _repositoryFactory())
{
var query = repository.Items;
if (!string.IsNullOrEmpty(criteria.FolderId))
{
query = query.Where(x => x.FolderId == criteria.FolderId);
}
if (!string.IsNullOrEmpty(criteria.Keyword))
{
query = query.Where(q => q.Name.Contains(criteria.Keyword));
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <DynamicContentItem>(x => x.Name), SortDirection = SortDirection.Ascending
} };
}
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();
retVal.Results = await _dynamicContentService.GetContentItemsByIdsAsync(ids);
}
}
return retVal;
}));
}