[Ignore] // TODO. See TSI-3635. public void GetNavigationSubtree_IncludeAncestorsAndChildrenKeywordOrdered_Success() // See TSI-1964 { TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(null, -1); TaxonomyNode testTopLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(testTopLevelKeyword1, "testTopLevelKeyword1"); TaxonomyNode testKeyword12 = testTopLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_2Title) as TaxonomyNode; Assert.IsNotNull(testKeyword12, "testKeyword12"); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 1 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testKeyword12.Id, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); // Result should be the Taxonomy Root only; the ancestor chain is formed using SitemapItem.Items. Assert.AreEqual(1, ancestorItems.Length, "ancestorItems.Length"); TaxonomyNode taxonomyRoot = ancestorItems[0] as TaxonomyNode; AssertExpectedTaxonomyNode(taxonomyRoot, testTaxonomyRoot.Title, 2, "taxonomyRoot"); TaxonomyNode topLevelKeyword1 = taxonomyRoot.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword1, testTopLevelKeyword1.Title, 2, "topLevelKeyword1"); // Check that the context Keyword and its siblings are ordered correctly (context Keyword should be second because of its title) AssertExpectedTaxonomyNode(topLevelKeyword1.Items[0] as TaxonomyNode, TestFixture.Keyword1_1Title, 0, "topLevelKeyword1.Items[0]"); AssertExpectedTaxonomyNode(topLevelKeyword1.Items[1] as TaxonomyNode, TestFixture.Keyword1_2Title, 3, "topLevelKeyword1.Items[1]"); }
private static void AssertExpectedTaxonomyNode(TaxonomyNode taxonomyNode, string expectedTitle, int expectedNumberOfChildItems, string subjectName) { Assert.IsNotNull(taxonomyNode, subjectName); Assert.AreEqual(expectedTitle, taxonomyNode.Title, subjectName + ".Title"); Assert.IsNotNull(taxonomyNode.Items, subjectName + ".Items"); Assert.AreEqual(expectedNumberOfChildItems, taxonomyNode.Items.Count, subjectName + ".Items.Count"); }
private void ProcessCatalog() { _project = (from project in CurrentDb.Projects where project.ID == _args.ProjectId select project).First(); var aryaUser = CurrentDb.Users.First(u => u.ID == _project.CreatedBy); var lastUpdatedTimestamp = TimestampRecordType.FromValues(_project.CreatedOn, User.FromAryaUser(aryaUser)); CurrentLogWriter.Debug("Processing " + _project); _productCatalog = new ProductCatalog { Id = _project.ID, Company = _project.ClientDescription, Type = "STANDARD", ProductCatalogNames = ProductCatalogProductCatalogName.FromName(_project.SetName), TaxonomyMetaDataLanguageVersionss = ProductCatalogTaxonomyMetaDataLanguageVersions.FromAryaProject( _project), SchemaMetaDataLanguageVersionss = ProductCatalogSchemaMetaDataLanguageVersions.FromAryaProject( _project), LastUpdatedTimestamp = lastUpdatedTimestamp }; var taxonomyNode = TaxonomyNode.FromValues(_project.CreatedOn, _project.ID, _project.ToString(), Guid.Empty, _project.ID); taxonomyNode.IsRoot = true; taxonomyNode.SerializeObject(GetSaveFilePath("Node", _project.ID.ToString())); _productCatalog.SerializeObject(GetSaveFilePath("Catalog", _productCatalog.Id.ToString())); ProcessTaxonomyNodes(); }
public void GetNavigationSubtree_FullTaxonomies_Success() { NavigationFilter testNavFilter = new NavigationFilter { DescendantLevels = -1 }; SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(taxonomyRoots, "taxonomyRoots"); OutputJson(taxonomyRoots); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots); Assert.IsNotNull(testTaxonomyRoot.Items, "testTaxonomyRoot.Items"); Assert.AreEqual(2, testTaxonomyRoot.Items.Count, "testTaxonomyRoot.Items.Count"); SitemapItem topLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title); Assert.IsNotNull(topLevelKeyword1, "topLevelKeyword1"); SitemapItem keyword11 = topLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title); Assert.IsNotNull(keyword11, "keyword11"); SitemapItem keyword112 = keyword11.Items.FirstOrDefault(i => i.Title == "Keyword 1.1.2"); Assert.IsNotNull(keyword112, "keyword112"); Assert.IsNotNull(keyword112.Items, "keyword112.Items"); Assert.AreEqual(1, keyword112.Items.Count, "keyword112.Items.Count"); }
public void Trigger(TaxonomyNode trigger, bool withChildren = false) { if (trigger == null) { return; } var states = relationService.GetRelated <StateEntity>(trigger, RelationDirection.Both, triggerRelation); //TODO: optimize if (withChildren) { foreach (var taxonChild in trigger.GetAllChildren()) { var childStates = relationService.GetRelated <StateEntity>(taxonChild, RelationDirection.Both, triggerRelation); foreach (var childState in childStates) { states.Add(childState); } } } foreach (var state in states) { log.Debug("DeleteTrigger for: " + state.Name); this.Delete(state); } }
public StateEntity CreateAndPersist(string key, object obj, TaxonomyNode trigger = null, long durationSeconds = 0, string description = null) { if (trigger == null && durationSeconds <= 0) { throw new DataLayerException("Select at least one trigger"); } StateEntity entity = new StateEntity() { DieDate = DateTime.Now.AddSeconds(durationSeconds > 0 ? durationSeconds : TimeSpan.FromDays(1).TotalSeconds), Name = key, Description = description }; entity.SetValue(obj); if (this.IsValid(entity)) { this.Save(entity); if (trigger != null) { relationService.AddRelation(trigger, entity, RelationDirection.Both, triggerRelation); } return(entity); } log.Debug("There is an attempt to save an invalid state"); return(null); }
private static void AddDescendants(TaxonomyNode taxonomyNode, NavigationFilter filter, Localization localization) { using (new Tracer(taxonomyNode, filter, localization)) { // First recurse (depth-first) IList <SitemapItem> children = taxonomyNode.Items; foreach (TaxonomyNode childNode in children.OfType <TaxonomyNode>()) { AddDescendants(childNode, filter, localization); } // Add descendants (on the way back) string taxonomyId; string keywordId; string pageId; ParseSitemapItemId(taxonomyNode.Id, out taxonomyId, out keywordId, out pageId); string taxonomyUri = localization.GetCmUri(taxonomyId, (int)ItemType.Category); string keywordUri = string.IsNullOrEmpty(keywordId) ? taxonomyUri : localization.GetCmUri(keywordId, (int)ItemType.Keyword); IEnumerable <SitemapItem> additionalChildren = ExpandDescendants(keywordUri, taxonomyUri, filter, localization); foreach (SitemapItem additionalChildItem in additionalChildren.Where(childItem => children.All(i => i.Id != childItem.Id))) { children.Add(additionalChildItem); } // Ensure that children are ordered correctly taxonomyNode.Items = children.OrderBy(i => i.OriginalTitle).ToList(); } }
private static TaxonomyNode ExpandAncestorsForPage(string pageUri, string taxonomyUri, NavigationFilter filter, Localization localization) { using (new Tracer(pageUri, taxonomyUri, filter, localization)) { // Get TaxonomyRelationManager.GetTaxonomyKeywords may return multiple paths towards the (same) Taxonomy root. TaxonomyRelationManager taxonomyRelationManager = new TaxonomyRelationManager(); Keyword[] contextKeywords = new Keyword[0]; Keyword[] taxonomyRoots = taxonomyRelationManager.GetTaxonomyKeywords(taxonomyUri, pageUri, contextKeywords, new DepthFilter(-1, DepthFilter.FilterUp), (int)ItemType.Page); if (taxonomyRoots == null || taxonomyRoots.Length == 0) { Log.Debug("Page '{0}' is not classified in Taxonomy '{1}.", pageUri, taxonomyUri); return(null); } TaxonomyNode[] taxonomyRootNodes = taxonomyRoots.Select(kw => CreateTaxonomyNode(kw, -1, filter, localization)).ToArray(); // Merge all returned paths into a single subtree TaxonomyNode mergedSubtreeRootNode = taxonomyRootNodes[0]; foreach (TaxonomyNode taxonomyRootNode in taxonomyRootNodes.Skip(1)) { MergeSubtrees(taxonomyRootNode, mergedSubtreeRootNode); } return(mergedSubtreeRootNode); } }
public void GetNavigationSubtree_IncludeAncestorsKeyword_Success() { TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(null, -1); TaxonomyNode testTopLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(testTopLevelKeyword1, "testTopLevelKeyword1"); TaxonomyNode testKeyword11 = testTopLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title) as TaxonomyNode; Assert.IsNotNull(testKeyword11, "testKeyword11"); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 0 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testKeyword11.Id, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); // Result should be the Taxonomy Root only; the ancestor chain is formed using SitemapItem.Items. Assert.AreEqual(1, ancestorItems.Length, "ancestorItems.Length"); TaxonomyNode taxonomyRoot = ancestorItems[0] as TaxonomyNode; AssertExpectedTaxonomyNode(taxonomyRoot, testTaxonomyRoot.Title, 1, "taxonomyRoot"); TaxonomyNode topLevelKeyword1 = taxonomyRoot.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword1, testTopLevelKeyword1.Title, 1, "topLevelKeyword1"); // This is the context node TaxonomyNode keyword11 = topLevelKeyword1.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword11, testKeyword11.Title, 0, "keyword11"); }
/// <summary> /// Get site map item. /// </summary> public TaxonomyNode GetSitemapItem(Localization localization) { try { SitemapItemModelRequest request = new SitemapItemModelRequest { PublicationId = int.Parse(localization.Id), Binder = _binder }; TaxonomyNode result = _modelServiceClient.PerformRequest <TaxonomyNode>(request).Response; NullifyEmptyUrl(result); return(result); } catch (ModelServiceException e) { Log.Error("{0} returned an unexpected response for URL '{1}':\n{2} ", ModelServiceName, _modelServiceClient.ModelServiceBaseUri, e.Message); throw new DxaException($"{ModelServiceName} returned an unexpected response.", e); } catch (ItemNotFoundException) { return(null); } }
public SettingsRepository( IDbContext context, TaxonomyTree taxonomyTree, RelationService relationService, ILog log) : base(context, log, relationService) { settingsRelation = taxonomyTree.GetOrCreatePath(SETTINGS_PATH, "SettingsRepository relations"); this.relationService = relationService; }
dynamic ToJson(TaxonomyNode node) { return(new { id = node.Path, text = node.Name, description = node.Description, expanded = false, hasChildren = node.Children.Count }); }
IEnumerable <dynamic> GetMenuItems(TaxonomyNode node) { return(node.Children.Select( n => new { name = n.Name, action = n.Description, menuitems = GetMenuItems(n), weight = 0 })); }
/// <summary> /// This method expands and collapses the Tree List. /// </summary> /// <param name="node"></param> /// <param name="currentLevel"></param> /// <param name="collapseLevel"></param> private static void ExpandCollapse(TaxonomyNode node, int currentLevel, int collapseLevel) { if (node == null) { return; } node.IsExpanded = (currentLevel < collapseLevel); foreach (var child in node.Children) { ExpandCollapse(child, currentLevel + 1, collapseLevel); } }
public StateRepository( IDbContext context, TaxonomyTree taxonomyTree, RelationService relationService, ILog log) : base(context, log, relationService) { triggerRelation = taxonomyTree.GetOrCreatePath(TRIGGER_PATH, "StateRepository trigger relations"); this.taxonomyTree = taxonomyTree; this.relationService = relationService; }
internal static SitemapItem Convert(ISitemapItem item) { if (item == null) { return(null); } SitemapItem result = null; if (item is TaxonomySitemapItem) { result = new TaxonomyNode(); } else if (item is PageSitemapItem) { result = new SitemapItem(); } result.Type = item.Type; result.Title = item.Title; result.Id = item.Id; result.OriginalTitle = item.OriginalTitle; if (item.Visible.HasValue) { result.Visible = item.Visible.Value; } if (item.PublishedDate != null) { result.PublishedDate = DateTime.ParseExact(item.PublishedDate, "MM/dd/yyyy HH:mm:ss", null); } result.Url = item.Url; if (!(item is TaxonomySitemapItem)) { return(result); } TaxonomySitemapItem tsi = (TaxonomySitemapItem)item; TaxonomyNode node = (TaxonomyNode)result; node.Key = tsi.Key; node.ClassifiedItemsCount = tsi.ClassifiedItemsCount ?? 0; node.Description = tsi.Description; node.HasChildNodes = tsi.HasChildNodes.HasValue && tsi.HasChildNodes.Value; node.IsAbstract = tsi.Abstract.HasValue && tsi.Abstract.Value; if (tsi.Items == null || tsi.Items.Count <= 0) { return(result); } foreach (var x in tsi.Items) { result.Items.Add(Convert(x)); } return(result); }
protected override TaxonomyNode CreateTaxonomyNode(Keyword keyword, int expandLevels, NavigationFilter filter, ILocalization localization) { TaxonomyNode node = base.CreateTaxonomyNode(keyword, expandLevels, filter, localization); string ishRefUri = (string)keyword.KeywordMeta.GetFirstValue("ish.ref.uri"); if (ishRefUri != null) { var ish = CmUri.FromString(ishRefUri); node.Url = $"/{ish.PublicationId}/{ish.ItemId}"; } node.Visible = true; return(node); }
protected Tuple <TaxonomyNode, MetricsEntity> ResolveMetrics(string metrixName, string name) { var key = metrixName + name; if (!resolveMetrics.ContainsKey(key)) { TaxonomyNode metricsNode = tree.GetOrCreatePath(metrixName.StartsWith("/") ? metrixName : TAXON_HEALTH_ROOT + "/" + metrixName); resolveMetrics.Add(key, new Tuple <TaxonomyNode, MetricsEntity>(metricsNode, metrixSvc.GetOrCreateFor(metricsNode, name))); } return(resolveMetrics[key]); }
public StatefullBrowsingSessionWrapper( StateService stateService, TaxonomyTree tree) { StoringFlags = StateStoringFlags.Get; StateCaching = StateCaching.LikeBrowser; StoringDuration = TimeSpan.FromHours(3); //default storing duration 3 hours //one day this.stateService = stateService; this.tree = tree; RootBrowsingStateTriggers = tree.GetOrCreatePath(STATE_TRIGGER_PATH, "Trigger to flush all Browsing cache"); }
public TaxonomyNode(GroupListGenerator.GroupNode node) { Name = node.Header; TotalCount = Count = node.Nodes.Count; Children = new ObservableCollection <TaxonomyNode>(); foreach (var child in node.Children) { var tn = new TaxonomyNode(child); TotalCount += tn.TotalCount; Children.Add(tn); } }
/// <summary> /// Gets a Navigation subtree for the given Sitemap Item. /// </summary> /// <param name="sitemapItemId">The context <see cref="SitemapItem"/> identifier. Can be <c>null</c>.</param> /// <param name="filter">The <see cref="NavigationFilter"/> used to specify which information to put in the subtree.</param> /// <param name="localization">The context <see cref="Localization"/>.</param> /// <returns>A set of Sitemap Items representing the requested subtree.</returns> public IEnumerable <SitemapItem> GetNavigationSubtree(string sitemapItemId, NavigationFilter filter, Localization localization) { using (new Tracer(sitemapItemId, filter, localization)) { if (string.IsNullOrEmpty(sitemapItemId)) { return(ExpandTaxonomyRoots(filter, localization)); } // Extract Taxonomy TCM UI, Keyword TCM URI and/or Page TCM URI from the Sitemap Item ID string taxonomyId; string keywordId; string pageId; ParseSitemapItemId(sitemapItemId, out taxonomyId, out keywordId, out pageId); string taxonomyUri = localization.GetCmUri(taxonomyId, (int)ItemType.Category); string keywordUri = string.IsNullOrEmpty(keywordId) ? taxonomyUri : localization.GetCmUri(keywordId, (int)ItemType.Keyword); string pageUri = localization.GetCmUri(pageId, (int)ItemType.Page); IEnumerable <SitemapItem> result = new SitemapItem[0]; if (filter.IncludeAncestors) { TaxonomyNode taxonomyRoot = null; if (!string.IsNullOrEmpty(keywordId)) { taxonomyRoot = ExpandAncestorsForKeyword(keywordUri, taxonomyUri, filter, localization); } else if (!string.IsNullOrEmpty(pageId)) { taxonomyRoot = ExpandAncestorsForPage(pageUri, taxonomyUri, filter, localization); } if (taxonomyRoot != null) { if (filter.DescendantLevels != 0) { AddDescendants(taxonomyRoot, filter, localization); } result = new[] { taxonomyRoot }; } } else if (filter.DescendantLevels != 0 && string.IsNullOrEmpty(pageId)) { result = ExpandDescendants(keywordUri, taxonomyUri, filter, localization); } return(result); } }
public HttpProxyDecoratorBase( HttpProxyRepository repo, TaxonomyTree tree, StateService stateService, ILog log) { _repo = repo; _tree = tree; _stateService = stateService; _log = log; StoringDuration = TimeSpan.FromHours(3); //default storing duration 3 hours //one day RootDescriminatorStateTriggers = tree.GetOrCreatePath(STATE_TRIGGER_PATH, "Trigger to flush all Browsing cache"); }
private static TaxonomyNode GetTestTaxonomy(IEnumerable <SitemapItem> taxonomyRoots = null, int descendantLevels = 1) { if (taxonomyRoots == null) { NavigationFilter navFilter = new NavigationFilter { DescendantLevels = descendantLevels }; taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, navFilter, TestFixture.ParentLocalization); } TaxonomyNode result = taxonomyRoots.FirstOrDefault(tn => tn.Title == TestFixture.NavigationTaxonomyTitle) as TaxonomyNode; Assert.IsNotNull(result, "Test Taxonomy not found: " + TestFixture.NavigationTaxonomyTitle); return(result); }
public void GetNavigationSubtree_TestTaxonomyChildren_Success() { TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(); NavigationFilter testNavFilter = new NavigationFilter(); SitemapItem[] childItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testTaxonomyRoot.Id, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(childItems, "childItems"); OutputJson(childItems); Assert.AreEqual(2, childItems.Length, "childItems.Length"); AssertNoChildItems(childItems, "childItems"); TaxonomyNode topLevelKeyword1 = childItems.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(topLevelKeyword1, "topLevelkeyword1"); }
public void GetNavigationSubtree_TaxonomyRootsOnly_Success() { NavigationFilter testNavFilter = new NavigationFilter(); SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(taxonomyRoots, "taxonomyRoots"); OutputJson(taxonomyRoots); AssertNoChildItems(taxonomyRoots, "taxonomyRoots"); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots); Assert.AreEqual(true, testTaxonomyRoot.HasChildNodes, "testTaxonomyRoot.HasChildNodes"); Assert.AreEqual(4, testTaxonomyRoot.ClassifiedItemsCount, "testTaxonomyRoot.ClassifiedItemsCount"); }
public void GetNavigationSubtree_IncludeAncestorsAndChildrenClassifiedPage_Success() { Localization testLocalization = TestFixture.ParentLocalization; string testPageUrlPath = testLocalization.GetAbsoluteUrlPath(TestFixture.TaxonomyTestPage1RelativeUrlPath); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(null, -1); TaxonomyNode testTopLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(testTopLevelKeyword1, "testTopLevelKeyword1"); TaxonomyNode testKeyword11 = testTopLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title) as TaxonomyNode; Assert.IsNotNull(testKeyword11, "testKeyword11"); PageModel testPageModel = SiteConfiguration.ContentProvider.GetPageModel(testPageUrlPath, testLocalization); string testPageSitemapItemId = string.Format("{0}-p{1}", testTaxonomyRoot.Id, testPageModel.Id); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 1 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testPageSitemapItemId, testNavFilter, testLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); // Result should be the Taxonomy Root only; it acts as the subtree root for all ancestors. Assert.AreEqual(1, ancestorItems.Length, "ancestorItems.Length"); TaxonomyNode taxonomyRoot = ancestorItems[0] as TaxonomyNode; AssertExpectedTaxonomyNode(taxonomyRoot, testTaxonomyRoot.Title, 2, "taxonomyRoot"); TaxonomyNode topLevelKeyword1 = taxonomyRoot.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword1, testTopLevelKeyword1.Title, 2, "topLevelKeyword1"); TaxonomyNode keyword11 = topLevelKeyword1.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword11, testKeyword11.Title, 2, "keyword11"); TaxonomyNode keyword112 = keyword11.Items[1] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword112, "Keyword 1.1.2", 1, "keyword112"); TaxonomyNode keyword12 = topLevelKeyword1.Items[1] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword12, "Keyword 1.2", 3, "keyword12"); TaxonomyNode topLevelKeyword2 = taxonomyRoot.Items[1] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword2, TestFixture.TopLevelKeyword2Title, 3, "topLevelKeyword2"); // Assert that child nodes are added because of DescendantLevels = 1: TaxonomyNode keyword111 = keyword11.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword111, "Keyword 1.1.1", 0, "keyword111"); }
public void GetNavigationSubtree_TaxonomyRootsAndChildren_Success() { NavigationFilter testNavFilter = new NavigationFilter { DescendantLevels = 2 }; SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(taxonomyRoots, "taxonomyRoots"); OutputJson(taxonomyRoots); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots); Assert.IsNotNull(testTaxonomyRoot.Items, "testTaxonomyRoot.Items"); Assert.AreEqual(2, testTaxonomyRoot.Items.Count, "testTaxonomyRoot.Items.Count"); AssertNoChildItems(testTaxonomyRoot.Items, "testTaxonomyRoot.Items"); }
private static IEnumerable <SitemapItem> ExpandDescendants(string keywordUri, string taxonomyUri, NavigationFilter filter, Localization localization) { using (new Tracer(keywordUri, taxonomyUri, filter, localization)) { TaxonomyFactory taxonomyFactory = new TaxonomyFactory(); TaxonomyFilter taxonomyFilter = new DepthFilter(filter.DescendantLevels, DepthFilter.FilterDown); Keyword contextKeyword = taxonomyFactory.GetTaxonomyKeywords(taxonomyUri, taxonomyFilter, keywordUri); if (contextKeyword == null) { Log.Warn("Keyword '{0}' in Taxonomy '{1}' not found.", keywordUri, taxonomyUri); return(new SitemapItem[0]); } TaxonomyNode contextTaxonomyNode = CreateTaxonomyNode(contextKeyword, filter.DescendantLevels, filter, localization); return(contextTaxonomyNode.Items); } }
protected override IEnumerable <SitemapItem> ExpandDescendants(string keywordUri, string taxonomyUri, NavigationFilter filter, ILocalization localization) { TaxonomyFactory taxonomyFactory = new TaxonomyFactory(); TaxonomyFilter taxonomyFilter = new DepthFilter(filter.DescendantLevels, DepthFilter.FilterDown); Keyword contextKeyword = taxonomyFactory.GetTaxonomyKeywords(taxonomyUri, taxonomyFilter, keywordUri); if (contextKeyword == null) { throw new TridionDocsApiException(); } TaxonomyNode contextTaxonomyNode = CreateTaxonomyNode(contextKeyword, filter.DescendantLevels, filter, localization); return(contextTaxonomyNode.Items); }
/// <summary> /// This method changes the current grouping and is called whenever the grouping /// parameters are changed. /// </summary> /// <param name="allData">List of entities</param> /// <param name="groupLevel">Grouping level</param> public void ChangedGrouping(IList <IAlignedBioEntity> allData, int groupLevel) { _root = new TaxonomyNode(new GroupListGenerator(allData.OrderBy(r => r.Entity.TaxonomyId).GroupBy(r => r.Entity.TaxonomyId)).GetRoot(groupLevel)); _maxLevels = FindMaxLevel(_root, 0); if (_maxLevels < _collapseLevel) { CollapseLevel = _maxLevels; } else { int lastLevel = _collapseLevel; _collapseLevel = 0; CollapseLevel = lastLevel; } OnPropertyChanged("Root"); }