[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");
}
