public async Task Handle_ProductsToMatch_Incorrect_With_Scope_UnSucceded()
{
// Arrange
var storeMock = CreateStoreServiceMock();
storeMock
.Setup(x => x.GetByIdAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new Store {
Catalog = "testCatalog",
});
var authorizationHandler = CreateAuthorizationHandler(storeMock.Object, null);
var productsToMatchCriteria = new AssociationEvaluationContext();
var context = CreateAuthorizationHandlerContext(
_permission,
$"{_permission}|[{{\"catalogId\":\"testCatalog1\",\"type\":\"SelectedCatalogScope\",\"label\":\"Electronics\",\"scope\":\"testCatalog1\"}}]",
productsToMatchCriteria);
// Act
await authorizationHandler.HandleAsync(context);
// Assert
Assert.False(context.HasSucceeded);
}
private static void ValidateParameters(AssociationEvaluationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
}
public async Task <string[]> EvaluateAssociationsAsync(AssociationEvaluationContext context)
{
if (context.ProductsToMatch.IsNullOrEmpty())
{
return(Array.Empty <string>());
}
var store = await _storeService.GetByIdAsync(context.StoreId);
var products = await _itemService.GetByIdsAsync(context.ProductsToMatch,
$"{ItemResponseGroup.WithProperties | ItemResponseGroup.WithOutlines}", store.Catalog);
var result = new HashSet <string>();
foreach (var product in products)
{
var associationCondition = await _associationsConditionSelector.GetAssociationConditionAsync(context, product);
if (associationCondition != null)
{
var searchResult = await _associationsConditionEvaluator.EvaluateAssociationConditionAsync(associationCondition);
result.AddRange(searchResult);
}
}
return(result.ToArray());
}
public async Task <ActionResult <string[]> > EvaluateDynamicAssociations([FromBody] AssociationEvaluationContext context)
{
ValidateParameters(context);
var authorizationResult = await _authorizationService.AuthorizeAsync(
User,
context,
new AssociationAuthorizationRequirement(CatalogModuleConstants.Security.Permissions.Read)
);
if (!authorizationResult.Succeeded)
{
return(Unauthorized());
}
var result = await _associationEvaluator.EvaluateAssociationsAsync(context);
return(Ok(result));
}
public virtual async Task <AssociationConditionEvaluationRequest> GetAssociationConditionAsync(AssociationEvaluationContext context, CatalogProduct product)
{
AssociationConditionEvaluationRequest result = null;
var associationRules = (await _associationSearchService
.SearchAssociationsAsync(new AssociationSearchCriteria
{
Groups = new[] { context.Group },
StoreIds = new[] { context.StoreId },
Take = int.MaxValue,
SortInfos = { new SortInfo
{
SortColumn = nameof(Association.Priority),
SortDirection = SortDirection.Descending,
} },
IsActive = true,
}))
.Results;
var expressionContext = AbstractTypeFactory <AssociationExpressionEvaluationContext> .TryCreateInstance();
expressionContext.Products.Add(product);
foreach (var associationRule in associationRules)
{
var matchingRule = associationRule.ExpressionTree.Children.OfType <BlockMatchingRules>().FirstOrDefault()
?? throw new InvalidOperationException($"Matching rules block for \"{associationRule.Name}\" dynamic association rule is missing");
if (matchingRule.IsSatisfiedBy(expressionContext))
{
var resultRule = associationRule.ExpressionTree.Children.OfType <BlockResultingRules>().FirstOrDefault()
?? throw new InvalidOperationException($"Resulting rules block for \"{associationRule.Name}\" dynamic association rule is missing");
var outputTuningBlock = associationRule.ExpressionTree.Children.OfType <BlockOutputTuning>().FirstOrDefault()
?? throw new InvalidOperationException($"Output tuning block for \"{associationRule.Name}\" dynamic association rule is missing");
result = AbstractTypeFactory <AssociationConditionEvaluationRequest> .TryCreateInstance();
result.PropertyValues = resultRule.GetPropertyValues();
result.CatalogId = resultRule.GetCatalogId();
result.CategoryIds = resultRule.GetCategoryIds();
result.Sort = outputTuningBlock.Sort;
result.Skip = context.Skip;
result.Take = Math.Min(Math.Max(outputTuningBlock.OutputLimit - context.Skip, 0), context.Take);
break;
}
}
return(result);
}
