public void CompositeFilter_ItemsMustMatchByAll()
{
var filter = AllFilter.Wrap(new DelegateFilter(i => false), new CountFilter(1, 1));
var items = filter.Pipe(CreateItems(3)).ToList();
Assert.That(items.Count(), Is.EqualTo(0));
}
public void Wrap_Creates_CompositeFilter_ForTwoParameters()
{
var filter = AllFilter.Wrap(new CountFilter(0, 1), new TypeFilter(typeof(INameable)));
Assert.That(filter, Is.InstanceOf <AllFilter>());
Assert.That((filter as AllFilter).Filters.Length, Is.EqualTo(2));
}
public virtual IList <T> Select <T>() where T : ContentItem
{
var retrievedItems = CreateQuery().List <T>();
ItemList <T> items;
if (retrievedItems.Count == 0)
{
items = new ItemList <T>();
}
else if (Filters != null)
{
var filter = AllFilter.Wrap(Filters);
items = ToListWithFillup <T>(retrievedItems, filter, /*maxRequeries*/ 10);
}
else
{
items = new ItemList <T>(retrievedItems);
}
if (SortExpression != null)
{
items.Sort(SortExpression);
}
return(items);
}
public void OnSetUp()
{
var filter1 = new FilterOnlyTag(TestTag1);
var filter2 = new FilterOnlyMessageType(AllowedMessageType);
_allFilter = new AllFilter(filter1, filter2);
}
/// <summary>
/// Creates the tree walker
/// </summary>
/// <param name="leafNodesOnly">if true, the walker will return only leaf nodes</param>
/// <param name="typeFilter">if true, the walker will filter by type</param>
/// <param name="types">The types to filter by</param>
/// <param name="reverse">if true, the walker order will be reversed</param>
/// <returns>
/// the tree walker
/// </returns>
public TreeWalker Create(bool leafNodesOnly, bool reverse, bool typeFilter, IEnumerable <string> types)
{
var allFilter = new AllFilter();
if (leafNodesOnly)
{
allFilter.Add(new LeafFilter());
}
if (typeFilter)
{
foreach (string type in types)
{
allFilter.Add(new TypeFilter(type));
}
}
TreeWalker walker;
if (reverse)
{
walker = this.CreateReversed(allFilter);
}
else
{
walker = this.Create(allFilter);
}
return(walker);
}
public void Test_AllFilterFilter_Returns_true()
{
var filter = new AllFilter(new DelegateFilter(x => true), new DelegateFilter(x => true), new DelegateFilter(x => true));
var article = new Article();
Assert.IsTrue(filter.Matches(article));
}
public void CompositeFilter_PipesItem_MatchedByAllFilters()
{
var filter = AllFilter.Wrap(new DelegateFilter(i => true), new CountFilter(1, 1));
var items = filter.Pipe(CreateItems(3)).ToList();
Assert.That(items.Count(), Is.EqualTo(1));
Assert.That(items.First().Name, Is.EqualTo("1"));
}
public void Test_AllFilterFilter_Returns_False_If_Any_returns_false()
{
var filter = new AllFilter(new DelegateFilter(x => true), new DelegateFilter(x => true), new DelegateFilter(x => false));
var article = new Article();
Assert.IsFalse(filter.Matches(article));
}
public void Wrap_Creates_SameFilter_ForOneCountList()
{
var filter = AllFilter.Wrap(new List <ItemFilter> {
new CountFilter(0, 1)
});
Assert.That(filter, Is.InstanceOf <CountFilter>());
}
public virtual ItemFilter GetEditorFilter(IPrincipal user)
{
ItemFilter filter = new AccessFilter(user, securityManager);
if (!settings.DisplayDataItems)
{
filter = new AllFilter(new PageFilter(), filter);
}
return(filter);
}
public IEnumerable <T> FindAllDescendentsOf <T>(ContentItem ancestor, AccessFilter accessFilter = null, PublishedFilter publishedFilter = null) where T : ContentItem
{
if (accessFilter == null && publishedFilter == null)
{
return(_itemFinder.AllOfType <T>().Where(i => i.AncestralTrail.StartsWith(ancestor.GetTrail())));
}
var filter = new AllFilter(accessFilter ?? new AccessFilter(), publishedFilter ?? new PublishedFilter());
return(_itemFinder.AllOfType <T>().Where(i => i.AncestralTrail.StartsWith(ancestor.GetTrail())).Where(filter.Match));
}
private IEnumerable <Translation> GetTranslations()
{
ItemFilter languageFilter = new AllFilter(new AccessFilter(), new PublishedFilter());
IEnumerable <ContentItem> translations = _languageGateway.FindTranslations(Find.ClosestStartPage);
foreach (ContentItem translation in languageFilter.Pipe(translations))
{
ILanguage language = _languageGateway.GetLanguage(translation);
// Hide translations when filtered access to their language
ContentItem languageItem = language as ContentItem;
if (languageItem == null || languageFilter.Match(languageItem))
{
yield return(new Translation(translation, language));
}
}
}
public void LongUrl()
{
_mockHttp
.When($"{_baseUrl}/items")
.Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, $"Fixtures{Path.DirectorySeparatorChar}DeliveryClient{Path.DirectorySeparatorChar}items.json")));
var client = DeliveryClientFactory.GetMockedDeliveryClientWithProjectId(_guid, _mockHttp);
A.CallTo(() => client.ResiliencePolicyProvider.Policy)
.Returns(Policy.HandleResult <HttpResponseMessage>(result => true)
.RetryAsync(client.DeliveryOptions.MaxRetryAttempts));
var elements = new ElementsParameter(Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var inFilter = new InFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var allFilter = new AllFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var anyFilter = new AnyFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
// Act
var response = client.GetItemsAsync(elements, inFilter, allFilter, anyFilter).Result;
// Assert
Assert.NotNull(response);
}
public void LongUrl()
{
_mockHttp.When($"{_baseUrl}/items")
.Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, "Fixtures\\DeliveryClient\\items.json")));
var httpClient = _mockHttp.ToHttpClient();
var client = new DeliveryClient(_guid)
{
HttpClient = httpClient
};
var elements = new ElementsParameter(Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var inFilter = new InFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var allFilter = new AllFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
var anyFilter = new AnyFilter("test", Enumerable.Range(0, 1000).Select(i => "test").ToArray());
// Act
var response = client.GetItemsAsync(elements, inFilter, allFilter, anyFilter).Result;
// Assert
Assert.NotNull(response);
}
public void Wrap_Creates_NullFilter_ForZeroParameters()
{
var filter = AllFilter.Wrap();
Assert.That(filter, Is.InstanceOf <NullFilter>());
}
public void OnTearDown()
{
_allFilter = null;
}
private static List <MGLStyleLayer> ExtractStyles(string sourceName, IEnumerable <JsonStyleLayer> jsonStyleLayers, MGLSpriteAtlas spriteAtlas)
{
var styleLayers = new List <MGLStyleLayer>();
foreach (var jsonStyleLayer in jsonStyleLayers)
{
// styleLayer for background is independent from any source
if (jsonStyleLayer.Type.ToLower().Equals("background"))
{
// We handled this already in CreateBackgroundTileSource
continue;
}
if (!sourceName.Equals(jsonStyleLayer.Source, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
IFilter filter = new AllFilter(null);
// Create filters for each style layer
if (jsonStyleLayer.NativeFilter != null)
{
filter = FilterConverter.ConvertFilter(jsonStyleLayer.NativeFilter);
}
MGLStyleLayer styleLayer = new MGLStyleLayer
{
Id = jsonStyleLayer.Id,
MinZoom = jsonStyleLayer.MinZoom ?? 0,
MaxZoom = jsonStyleLayer.MaxZoom ?? 30,
Filter = filter,
SourceLayer = jsonStyleLayer.SourceLayer,
IsVisible = !(jsonStyleLayer.Layout?.Visibility != null && jsonStyleLayer.Layout.Visibility.Equals("none")),
};
// We have a raster style or one of the vector styles "fill", "line", "symbol", "circle", "heatmap", "fill-extrusion"
switch (jsonStyleLayer.Type.ToLower())
{
case "raster":
styleLayer.Type = StyleType.Raster;
var rasterPaints = StyleLayerConverter.ConvertRasterLayer(jsonStyleLayer);
if (rasterPaints != null)
{
((List <MGLPaint>)styleLayer.Paints).AddRange(rasterPaints);
}
break;
case "fill":
styleLayer.Type = StyleType.Fill;
var fillPaints = StyleLayerConverter.ConvertFillLayer(jsonStyleLayer, spriteAtlas);
if (fillPaints != null)
{
((List <MGLPaint>)styleLayer.Paints).AddRange(fillPaints);
}
break;
case "line":
styleLayer.Type = StyleType.Line;
var linePaints = StyleLayerConverter.ConvertLineLayer(jsonStyleLayer, spriteAtlas);
if (linePaints != null)
{
((List <MGLPaint>)styleLayer.Paints).AddRange(linePaints);
}
break;
case "symbol":
styleLayer.Type = StyleType.Symbol;
styleLayer.SymbolStyler = StyleLayerConverter.ConvertSymbolLayer(jsonStyleLayer, spriteAtlas);
break;
case "circle":
break;
case "heatmap":
break;
case "fill-extrusion":
break;
default:
throw new ArgumentException($"Unknown layer type ${jsonStyleLayer.Type}");
break;
}
styleLayers.Add(styleLayer);
}
return(styleLayers);
}
public void Wrap_Creates_NullFilter_ForNull()
{
var filter = AllFilter.Wrap(null);
Assert.That(filter, Is.InstanceOf <NullFilter>());
}
public IEnumerable <T> FindAll <T>(AccessFilter accessFilter, PublishedFilter publishedFilter) where T : ContentItem
{
var filter = new AllFilter(accessFilter ?? new AccessFilter(), publishedFilter ?? new PublishedFilter());
return(_itemFinder.AllOfType <T>().Where(filter.Match));
}
public void Wrap_Creates_SameFilter_ForOneParameter()
{
var filter = AllFilter.Wrap(new CountFilter(0, 1));
Assert.That(filter, Is.InstanceOf <CountFilter>());
}
public void Wrap_Creates_NullFilter_ForZeroCountList()
{
var filter = AllFilter.Wrap(new List <ItemFilter>());
Assert.That(filter, Is.InstanceOf <NullFilter>());
}
// ReSharper disable once InconsistentNaming
public ActionResult Index(int content_item_id,
string actionCode,
bool live = false,
string[] filters = null,
bool includeRelevanceInfo = true,
bool localize = false,
string lang = null,
bool changeLang = false
)
{
ViewBag.HostId = _qpHelper.HostId;
if (content_item_id <= 0)
{
ViewBag.Message = ProductCardStrings.СontentItemIdPositive;
return(View());
}
var sw = Stopwatch.StartNew();
var originalProduct = _productService.GetProductById(content_item_id, live);
var product = originalProduct;
var cultures = new CultureInfo[0];
var currentCulture = CultureInfo.InvariantCulture;
var productLoadedIn = sw.ElapsedMilliseconds;
if (product == null)
{
ViewBag.Message = ProductCardStrings.ProductNotFound;
return(View());
}
if (localize)
{
cultures = _localizationService.GetCultures();
if (lang == null)
{
var cookie = Request.Cookies[actionCode + DefaultCultureKey];
currentCulture = (string.IsNullOrEmpty(cookie) || changeLang) ? cultures[0] : CultureInfo.GetCultureInfo(cookie);
}
else
{
currentCulture = CultureInfo.GetCultureInfo(lang);
Response.Cookies.Append(actionCode + DefaultCultureKey, lang);
}
product = _localizationService.Localize(product, currentCulture);
}
var productLocalized = sw.ElapsedMilliseconds;
var control = ObjectFactoryBase.Resolve <IProductControlProvider>().GetControlForProduct(product);
if (control == null)
{
ViewBag.Message = ProductCardStrings.ProductIsNotVisual;
return(View());
}
var controlLoadedIn = sw.ElapsedMilliseconds;
filters = filters ?? new string[] {};
var allFilter = new AllFilter(filters.Select(ObjectFactoryBase.Resolve <IArticleFilter>).ToArray());
product = ArticleFilteredCopier.Copy(product, allFilter);
if (localize)
{
originalProduct = ArticleFilteredCopier.Copy(originalProduct, allFilter);
}
var productCopied = sw.ElapsedMilliseconds;
var relevanceResolved = productCopied;
if (includeRelevanceInfo)
{
var relevanceService = ObjectFactoryBase.Resolve <IProductRelevanceService>();
relevanceResolved = sw.ElapsedMilliseconds;
var relevanceItems = relevanceService.GetProductRelevance(localize ? originalProduct : product, live, localize);
var relevanceField = new MultiArticleField()
{
FieldName = "Relevance"
};
var id = 0;
product.AddField(relevanceField);
foreach (var relevanceItem in relevanceItems)
{
var localizedRelevanceArticle = new Article();
if (Equals(relevanceItem.Culture, CultureInfo.InvariantCulture))
{
AddRelevanceData(product, relevanceItem);
}
relevanceField.Items.Add(++id, localizedRelevanceArticle);
AddRelevanceData(localizedRelevanceArticle, relevanceItem);
}
var isRelevant = relevanceItems.All(r => r.Relevance == ProductRelevance.Relevant);
if (!isRelevant)
{
product.AddPlainField("IsRelevant", false, ProductCardStrings.ProductRelevance);
}
}
var relevanceLoaded = sw.ElapsedMilliseconds;
IModelPostProcessor processor = new HierarchySorter(new HierarchySorterParameter
{
Domain = 100,
ConstructHierarchy = true,
ParentRelativePath = "Parent",
PathToCollection = "Parameters",
PathToSortOrder = "SortOrder",
PropertyToSet = "NewSortOrder"
});
product = processor.ProcessModel(product);
var hierarchySorted = sw.ElapsedMilliseconds;
product.AddArticle("Diagnostics",
new Article()
.AddPlainField("ProductLoaded", productLoadedIn, ProductCardStrings.ProductLoaded)
.AddPlainField("ProductLocalized", productLocalized, ProductCardStrings.ProductLocalized)
.AddPlainField("ControlLoaded", controlLoadedIn, ProductCardStrings.ControlLoaded)
.AddPlainField("ProductCopied", productCopied, ProductCardStrings.ProductCopied)
.AddPlainField("RelevanceResolved", relevanceResolved, ProductCardStrings.RelevanceResolved)
.AddPlainField("RelevanceLoaded", relevanceLoaded, ProductCardStrings.RelevanceLoaded)
.AddPlainField("HierarchySorted", hierarchySorted, ProductCardStrings.HierarchySorted));
control.DataContext = product;
return(View("Index", new CardModel {
Control = control, Cultures = cultures, CurrentCultute = currentCulture
}));
}
public void Wrap_Creates_NullFilter_ForZeroLengthArray()
{
var filter = AllFilter.Wrap(new ItemFilter[0]);
Assert.That(filter, Is.InstanceOf <NullFilter>());
}
