public async Task <string> GetDynamicContentHtmlAsync(string storeId, string placeholderName)
{
string htmlContent = null;
//TODO: make full context
var evaluationContext = new DynamicContentEvaluationContext
{
StoreId = storeId,
PlaceName = placeholderName
};
var cacheKey = "MarketingServiceImpl.GetDynamicContentHtmlAsync-" + storeId + "-" + placeholderName;
var dynamicContent = await _cacheManager.GetAsync(cacheKey, "ApiRegion", async() => await _marketingApi.MarketingModuleDynamicContentEvaluateDynamicContentAsync(evaluationContext));
if (dynamicContent != null)
{
var htmlDynamicContent = dynamicContent.FirstOrDefault(dc => !string.IsNullOrEmpty(dc.ContentType) && dc.ContentType.Equals("Html", StringComparison.OrdinalIgnoreCase));
if (htmlDynamicContent != null)
{
var dynamicProperty = htmlDynamicContent.DynamicProperties.FirstOrDefault(dp => !string.IsNullOrEmpty(dp.Name) && dp.Name.Equals("Html", StringComparison.OrdinalIgnoreCase));
if (dynamicProperty != null && dynamicProperty.Values.Any(v => v.Value != null))
{
htmlContent = dynamicProperty.Values.First().Value.ToString();
}
}
}
return(htmlContent);
}
public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
if (bindingContext.ModelType != typeof(DynamicContentEvaluationContext))
{
return(false);
}
var qs = HttpUtility.ParseQueryString(actionContext.Request.RequestUri.Query as string);
var result = new DynamicContentEvaluationContext();
result.StoreId = qs.Get("storeId") ?? qs.Get("evalContext.storeId");
result.PlaceName = qs.Get("placeName") ?? qs.Get("evalContext.placeName");
result.Tags = qs.GetValues("tags");
if (result.Tags == null)
{
var tags = qs.Get("evalContext.tags");
if (!String.IsNullOrEmpty(tags))
{
result.Tags = tags.Split(',');
}
}
var toDate = qs.Get("toDate") ?? qs.Get("evalContext.toDate");
if (toDate != null)
{
result.ToDate = Convert.ToDateTime(toDate, CultureInfo.InvariantCulture);
}
bindingContext.Model = result;
return(true);
}
public virtual async Task <string> GetDynamicContentHtmlAsync(string storeId, string placeholderName)
{
string htmlContent = null;
//TODO: make full context
var evaluationContext = new DynamicContentEvaluationContext
{
StoreId = storeId,
PlaceName = placeholderName
};
var cacheKey = CacheKey.With(GetType(), "GetDynamicContentHtmlAsync", storeId, placeholderName);
return(await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(MarketingCacheRegion.CreateChangeToken());
cacheEntry.AddExpirationToken(_apiChangesWatcher.CreateChangeToken());
var dynamicContentItems = (await _dynamicContentApi.EvaluateDynamicContentAsync(evaluationContext)).Select(x => x.ToDynamicContentItem());
if (dynamicContentItems != null)
{
var htmlContentSpec = new HtmlDynamicContentSpecification();
var htmlDynamicContent = dynamicContentItems.FirstOrDefault(htmlContentSpec.IsSatisfiedBy);
if (htmlDynamicContent != null)
{
var dynamicProperty = htmlDynamicContent.DynamicProperties.FirstOrDefault(htmlContentSpec.IsSatisfiedBy);
if (dynamicProperty != null && dynamicProperty.Values.Any(v => v.Value != null))
{
htmlContent = dynamicProperty.Values.First().Value.ToString();
}
}
}
return htmlContent;
}));
}
public void EvaluateItemsAsync_Evaluate()
{
//Arrange
var expected = new List<DynamicContentItem>();
var evalContext = new DynamicContentEvaluationContext() { GeoCity = "NY" };
var dynamicContentItem = new DynamicContentItem()
{
Id = Guid.NewGuid().ToString()
};
expected.Add(dynamicContentItem);
var expectedArray = expected.ToArray();
var groups = new List<DynamicContentPublication>
{
new DynamicContentPublication
{
DynamicExpression = JsonConvert.DeserializeObject<DynamicContentConditionTree>(GetConditionJson(), new ConditionJsonConverter(), new RewardJsonConverter()),
IsActive = true,
ContentItems = new ObservableCollection<DynamicContentItem> { dynamicContentItem },
}
};
_dynamicContentSearchServiceMock.Setup(dcs => dcs.SearchContentPublicationsAsync(It.IsAny<DynamicContentPublicationSearchCriteria>()))
.ReturnsAsync(new Core.Model.DynamicContent.Search.DynamicContentPublicationSearchResult { Results = groups.ToArray() });
_dynamicContentServiceMock.Setup(dcs => dcs.GetContentItemsByIdsAsync(new[] { dynamicContentItem.Id }))
.ReturnsAsync(expectedArray);
var evaluator = new DefaultDynamicContentEvaluator(_dynamicContentSearchServiceMock.Object, _dynamicContentServiceMock.Object, _loggerMock.Object);
//Act
var results = evaluator.EvaluateItemsAsync(evalContext).GetAwaiter().GetResult();
//Assert
Assert.Equal(expectedArray, results);
}
public static DynamicContentEvaluationContext ToDynamicContentEvaluationContext(this WorkContext workContext, IEnumerable <Product> products = null)
{
var result = new DynamicContentEvaluationContext(workContext.CurrentLanguage, workContext.CurrentCurrency)
{
User = workContext.CurrentUser,
StoreId = workContext.CurrentStore.Id,
};
return(result);
}
public async Task EvaluateItemsAsync(DynamicContentEvaluationContext context, DynamicContentConditionTree expression, bool expectedResult)
{
// Arrange
var dynamicContentItem = new DynamicContentItem {
Id = Guid.NewGuid().ToString()
};
var dynamicContentItems = new DynamicContentItem[] { dynamicContentItem };
var evaluator = GetEvaluator(dynamicContentItem, dynamicContentItems, expression);
// Act
var results = await evaluator.EvaluateItemsAsync(context);
// Assert
Assert.Equal(expectedResult, dynamicContentItems.Equals(results));
}
public IHttpActionResult GetDynamicContent(string store,
string[] placeHolders,
[FromUri] string[] tags,
string language = "en-us")
{
var tagSet = new TagSet();
if (tags != null)
{
foreach (var tagArray in tags.Select(tag => tag.Split(new[] { ':' })))
{
tagSet.Add(tagArray[0], tagArray[1]);
}
}
// TODO: add tags ?tags={users:[id1,id2]}
// TODO: add caching
//Mutiple placeholders can be requested
var groups = new List <webModel.DynamicContentItemGroup>();
foreach (var holder in placeHolders)
{
var group = new webModel.DynamicContentItemGroup(holder);
var ctx = new DynamicContentEvaluationContext(store, holder, DateTime.Now, tagSet);
var results = _contentEvaluator.EvaluateItems(ctx);
if (results != null && results.Any())
{
group.Items.AddRange(results.Select(x => x.ToWebModel()));
groups.Add(group);
}
}
var retVal = new webModel.ResponseCollection <webModel.DynamicContentItemGroup>
{
Items = groups,
TotalCount = groups.Count()
};
return(this.Ok(retVal));
//return this.StatusCode(HttpStatusCode.NoContent);
}
public static marketingDto.DynamicContentEvaluationContext ToDynamicContentEvaluationContextDto(this DynamicContentEvaluationContext dynamicContentEvalContext)
{
var result = new marketingDto.DynamicContentEvaluationContext
{
UserGroups = dynamicContentEvalContext?.User?.Contact?.UserGroups,
Language = dynamicContentEvalContext.Language != null ? dynamicContentEvalContext.Language.CultureName : null,
StoreId = dynamicContentEvalContext.StoreId,
Tags = dynamicContentEvalContext.Tags,
ToDate = dynamicContentEvalContext.ToDate,
PlaceName = dynamicContentEvalContext.PlaceName
};
return(result);
}
public virtual async Task <IEnumerable <DynamicContentItem> > EvaluateDynamicContentItemsAsync(DynamicContentEvaluationContext evalContext)
{
var cacheKey = CacheKey.With(GetType(), "EvaluateDynamicContentItemsAsync", evalContext.GetCacheKey());
return(await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(MarketingCacheRegion.CreateChangeToken());
cacheEntry.AddExpirationToken(_apiChangesWatcher.CreateChangeToken());
var evalContextDto = evalContext.ToDynamicContentEvaluationContextDto();
var dynamicContentItems = (await _dynamicContentApi.EvaluateDynamicContentAsync(evalContextDto)).Select(x => x.ToDynamicContentItem());
return dynamicContentItems;
}));
}
