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");
}
[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 ParseSingleFile()
{
var path = Path.Combine(@"f:\GIT\Geodesy\Rinex3Parser\TestFiles\", "cibg0880.16o");
var path2 = Path.Combine(Environment.CurrentDirectory, "rnxheader.txt");
sw1 = new StreamWriter("123.321");
var z = new Dictionary <SatelliteSystem, int[]>();
var vals = Enum.GetValues(typeof(BdsSatellite));
z.Add(SatelliteSystem.Bds, vals.Cast <int>().ToArray());
var filter = new NavigationFilter(new DateTime(2016, 04, 29, 08, 0, 0), new DateTime(2016, 04, 29, 9, 0, 0),
z);
//var rinexObsParser = new RinexObsParser(path, ParseType.StoreAndRaise);
var rinexObsParser = new RinexObsWithFilter(path, ParseType.StoreAndRaise,
new ObservationFilter(null, null,
SatelliteSystem.Qzss | SatelliteSystem.Glo | SatelliteSystem.Gps | SatelliteSystem.Bds |
SatelliteSystem.Sbas, null));
rinexObsParser.ObsDataEvents += ObsParserObsDataEvents;
rinexObsParser.HeaderInfoEvent += ObsParserHeaderInfoEvent;
rinexObsParser.Parse();
sw1.Flush();
sw1.Dispose();
}
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");
}
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();
}
}
public virtual ActionResult GetNavigationSubtree(string sitemapItemId)
{
using (new Tracer(sitemapItemId))
{
NavigationFilter navFilter = new NavigationFilter
{
IncludeAncestors = GetRequestParameter <bool>("includeAncestors")
};
int descendantLevels;
if (TryGetRequestParameter("descendantLevels", out descendantLevels))
{
navFilter.DescendantLevels = descendantLevels;
}
IOnDemandNavigationProvider onDemandNavigationProvider = SiteConfiguration.NavigationProvider as IOnDemandNavigationProvider;
if (onDemandNavigationProvider == null)
{
Log.Warn("Request for Navigation subtree received, but current Navigation Provider ({0}) does not implement interface {1}",
SiteConfiguration.NavigationProvider.GetType().Name, typeof(IOnDemandNavigationProvider).Name);
return(new EmptyResult());
}
IEnumerable <SitemapItem> model = onDemandNavigationProvider.GetNavigationSubtree(sitemapItemId, navFilter, WebRequestContext.Localization);
return(Json(model, JsonRequestBehavior.AllowGet));
}
}
private static SitemapItem BuildNavigationModel(string navTaxonomyUri, Localization localization)
{
using (new Tracer(navTaxonomyUri, localization))
{
TaxonomyFactory taxonomyFactory = new TaxonomyFactory();
Keyword taxonomyRoot = taxonomyFactory.GetTaxonomyKeywords(navTaxonomyUri, new DepthFilter(DepthFilter.UnlimitedDepth, DepthFilter.FilterDown));
NavigationFilter navFilter = new NavigationFilter();
return(CreateTaxonomyNode(taxonomyRoot, -1, navFilter, localization));
}
}
/// <summary>Creates a navigation using unordered list elements.</summary>
public static N2.Web.Tree Tree(this HtmlHelper html,
ContentItem startsFrom = null,
ContentItem current = null,
int takeLevels = 2,
bool parallelRoot = true,
bool appendCreatorNode = false,
ItemFilter filter = null,
object htmlAttributes = null)
{
if (startsFrom == null)
{
startsFrom = html.StartPage();
}
if (current == null)
{
current = html.CurrentPage();
}
if (filter == null)
{
filter = new NavigationFilter(html.ViewContext.HttpContext.User, html.ContentEngine().SecurityManager);
}
var builder = parallelRoot
? (HierarchyBuilder) new ParallelRootHierarchyBuilder(startsFrom, takeLevels)
: (HierarchyBuilder) new TreeHierarchyBuilder(startsFrom, takeLevels);
if (builder == null)
{
throw new ArgumentException("builder == null");
}
if (appendCreatorNode && ControlPanelExtensions.GetControlPanelState(html).IsFlagSet(ControlPanelState.DragDrop))
{
builder.GetChildren = (i) => i == null ? null : i.Children.FindNavigatablePages().Where(filter).AppendCreatorNode(html.ContentEngine(), i);
}
else
{
builder.GetChildren = (i) => i == null ? null : i.Children.FindNavigatablePages().Where(filter);
}
var tree = N2.Web.Tree.Using(builder);
if (htmlAttributes != null)
{
tree.Tag(BootstrapTagAlterations(startsFrom, current, htmlAttributes));
}
ClassifyAnchors(startsFrom, current, parallelRoot, tree);
return(tree);
}
private static IEnumerable <SitemapItem> ExpandTaxonomyRoots(NavigationFilter filter, Localization localization)
{
using (new Tracer(filter, localization))
{
TaxonomyFactory taxonomyFactory = new TaxonomyFactory();
string[] taxonomyIds = taxonomyFactory.GetTaxonomies(localization.GetCmUri());
int depth = filter.DescendantLevels > 0 ? (filter.DescendantLevels - 1) : filter.DescendantLevels;
TaxonomyFilter taxonomyFilter = new DepthFilter(depth, DepthFilter.FilterDown);
IEnumerable <Keyword> taxonomyRoots = taxonomyIds.Select(id => taxonomyFactory.GetTaxonomyKeywords(id, taxonomyFilter));
return(taxonomyRoots.Select(kw => CreateTaxonomyNode(kw, depth, filter, localization)));
}
}
/// <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);
}
}
/// <summary>
/// Build a tree that is bootstrap friendly
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="helper"></param>
/// <param name="startFrom"></param>
/// <param name="currentItem"></param>
/// <param name="takeLevel"></param>
/// <param name="filter"></param>
/// <param name="appendCreatorNode"></param>
/// <param name="includeRoot"></param>
/// <param name="onHoverDropdowns"></param>
/// <returns></returns>
public static N2.Web.Tree BootstrapTree <TModel>(this HtmlHelper <TModel> helper,
ContentItem startFrom = null,
ContentItem currentItem = null,
int takeLevel = 2,
ItemFilter filter = null,
bool appendCreatorNode = false,
bool includeRoot = true,
bool onHoverDropdowns = false)
{
// prep
if (startFrom == null)
{
startFrom = helper.StartPage();
}
if (currentItem == null)
{
currentItem = helper.CurrentPage();
}
if (filter == null)
{
filter = new NavigationFilter(helper.ViewContext.RequestContext.HttpContext.User, helper.ContentEngine().SecurityManager);
}
HierarchyBuilder builder = new ParallelRootHierarchyBuilder(startFrom, takeLevel);
builder.GetChildren = (builder.GetChildren = (item) =>
{
var items = item.Children.Where(filter);
if (appendCreatorNode && item.IsPage && helper.GetControlPanelState().IsFlagSet(ControlPanelState.DragDrop))
{
items = items.AppendCreatorNode(helper.ContentEngine(), item);
}
return(items.ToList());
});
var node = builder.Build();
if (!includeRoot)
{
node.Children.RemoveAt(0);
}
var tree = N2.Web.Tree.Using(node);
tree.HtmlAttibutes(new { @class = "nav" });
ClassifyAnchors(startFrom, currentItem, tree);
return(tree);
}
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 SitemapItem SiteMap(Common.Configuration.Localization localization)
{
return(SiteConfiguration.CacheProvider.GetOrAdd(
$"sitemap-{localization.Id ?? "full"}", CacheRegion.Sitemap,
() =>
{
// Workaround: Currently the content service is not returning a sitemap for Docs only content
// so the workaround is for each publication get the entire subtree and merge the results.
// This will cause several requests to be issued and results in quite a slow performance.
IOnDemandNavigationProvider provider =
SiteConfiguration.NavigationProvider as IOnDemandNavigationProvider;
if (provider == null)
{
return null;
}
NavigationFilter navigationFilter = new NavigationFilter
{
DescendantLevels = -1,
IncludeAncestors = false
};
List <SitemapItem> sitemapItems = new List <SitemapItem>();
if (!string.IsNullOrEmpty(localization?.Id))
{
sitemapItems.AddRange(provider.GetNavigationSubtree(null, navigationFilter, localization));
}
else
{
var pubs = new PublicationProvider().PublicationList;
foreach (var pub in pubs)
{
var items = provider.GetNavigationSubtree(null, navigationFilter,
new DocsLocalization(int.Parse(pub.Id)));
foreach (var item in items)
{
sitemapItems.AddRange(item.Items);
}
}
}
return new SitemapItem {
Items = FixupSitemap(sitemapItems, false, false)
};
}));
}
/// <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))
{
Match sitemapItemIdMatch = SitemapItemIdRegex.Match(sitemapItemId);
if (!sitemapItemIdMatch.Success)
{
throw new DxaException($"Invalid Sitemap Item identifier: '{sitemapItemId}'");
}
}
if (filter == null)
{ // default
filter = new NavigationFilter {
DescendantLevels = 1, IncludeAncestors = false
};
}
IEnumerable <SitemapItem> cachedNavModel = SiteConfiguration.CacheProvider.GetOrAdd(
$"GetNavigationSubtree:{sitemapItemId}-{localization.Id}-{filter.IncludeAncestors}-{filter.DescendantLevels}",
CacheRegions.DynamicNavigation,
() =>
{
try
{
IEnumerable <SitemapItem> items = SiteConfiguration.ModelServiceProvider.GetChildSitemapItems(sitemapItemId, localization,
filter.IncludeAncestors,
filter.DescendantLevels) ?? new SitemapItem[0];
items = items.OrderBy(i => i.OriginalTitle);
RebuildParentRelationships(items, null);
return(items);
}
catch
{
return(new SitemapItem[0]);
}
});
if (cachedNavModel == null)
{
return(null);
}
RebuildParentRelationships(cachedNavModel, null);
return(cachedNavModel);
}
}
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);
}
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");
}
public void GetNavigationSubtree_IncludeAncestorsUnclassifiedPage_Success()
{
Localization testLocalization = TestFixture.ParentLocalization;
string testPageUrlPath = testLocalization.GetAbsoluteUrlPath(TestFixture.ArticlePageRelativeUrlPath);
TaxonomyNode testTaxonomyRoot = GetTestTaxonomy();
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 = 0
};
SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testPageSitemapItemId, testNavFilter, testLocalization).ToArray();
Assert.IsNotNull(ancestorItems, "ancestorItems");
OutputJson(ancestorItems);
Assert.AreEqual(0, ancestorItems.Length, "ancestorItems.Length");
}
public void GetNavigationSubtree_PageDescendants_Success()
{
Localization testLocalization = TestFixture.ParentLocalization;
TaxonomyNode testTaxonomyRoot = GetTestTaxonomy();
string testPageUrlPath = testLocalization.GetAbsoluteUrlPath(TestFixture.TaxonomyTestPage1RelativeUrlPath);
PageModel testPageModel = SiteConfiguration.ContentProvider.GetPageModel(testPageUrlPath, testLocalization);
string testPageSitemapItemId = string.Format("{0}-p{1}", testTaxonomyRoot.Id, testPageModel.Id);
NavigationFilter testNavFilter = new NavigationFilter {
DescendantLevels = 1
};
SitemapItem[] childItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testPageSitemapItemId, testNavFilter, testLocalization).ToArray();
Assert.IsNotNull(childItems, "childItems");
OutputJson(childItems);
Assert.AreEqual(0, childItems.Length, "childItems.Length");
}
public IEnumerable <SitemapItem> GetToc(int publicationId, string sitemapItemId, bool includeAncestors,
int descendantLevels)
{
bool caching = ServiceCacheProvider.Instance.DisableCaching;
ServiceCacheProvider.Instance.DisableCaching = true;
IOnDemandNavigationProvider onDemandNavigationProvider = SiteConfiguration.NavigationProvider as IOnDemandNavigationProvider;
NavigationFilter navigationFilter = new NavigationFilter
{
DescendantLevels = descendantLevels,
IncludeAncestors = includeAncestors
};
ILocalization localization = WebRequestContext.Localization;
localization.Id = publicationId.ToString();
var result = onDemandNavigationProvider.GetNavigationSubtree(sitemapItemId, navigationFilter, localization);
ServiceCacheProvider.Instance.DisableCaching = caching;
return(result);
}
public void GetNavigationSubtree_NonExistingItem_Success()
{
NavigationFilter descendantsFilter = new NavigationFilter();
NavigationFilter ancestorsFilter = new NavigationFilter {
IncludeAncestors = true, DescendantLevels = 0
};
Localization testLocalization = TestFixture.ParentLocalization;
IEnumerable <SitemapItem> sitemapItems = _testOnDemandNavigationProvider.GetNavigationSubtree("t666-k666", ancestorsFilter, testLocalization);
Assert.IsNotNull(sitemapItems, "sitemapItems");
Assert.IsFalse(sitemapItems.Any(), "sitemapItems.Any()");
IEnumerable <SitemapItem> sitemapItems2 = _testOnDemandNavigationProvider.GetNavigationSubtree("t666-p666", ancestorsFilter, testLocalization);
Assert.IsNotNull(sitemapItems2, "sitemapItems2");
Assert.IsFalse(sitemapItems2.Any(), "sitemapItems2.Any()");
IEnumerable <SitemapItem> sitemapItems3 = _testOnDemandNavigationProvider.GetNavigationSubtree("t666", descendantsFilter, testLocalization);
Assert.IsNotNull(sitemapItems3, "sitemapItems3");
Assert.IsFalse(sitemapItems3.Any(), "sitemapItems3.Any()");
}
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 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);
}
private static TaxonomyNode ExpandAncestorsForKeyword(string keywordUri, string taxonomyUri, NavigationFilter filter, Localization localization)
{
using (new Tracer(keywordUri, taxonomyUri, filter, localization))
{
TaxonomyFactory taxonomyFactory = new TaxonomyFactory();
TaxonomyFilter taxonomyFilter = new DepthFilter(DepthFilter.UnlimitedDepth, DepthFilter.FilterUp);
Keyword taxonomyRoot = taxonomyFactory.GetTaxonomyKeywords(taxonomyUri, taxonomyFilter, keywordUri);
if (taxonomyRoot == null)
{
Log.Warn("Keyword '{0}' in Taxonomy '{1}' not found.", keywordUri, taxonomyUri);
return(null);
}
return(CreateTaxonomyNode(taxonomyRoot, -1, filter, localization));
}
}
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 IEnumerable <SitemapItem> GetToc(Common.Configuration.Localization localization, string sitemapItemId, bool includeAncestors,
int descendantLevels)
{
return(SiteConfiguration.CacheProvider.GetOrAdd(
$"toc-{localization.Id}-{sitemapItemId}-{includeAncestors}-{WebRequestContext.CacheKeySalt}", CacheRegion.Toc,
() =>
{
new PublicationProvider().CheckPublicationOnline(int.Parse(localization.Id));
IOnDemandNavigationProvider provider =
SiteConfiguration.NavigationProvider as IOnDemandNavigationProvider;
NavigationFilter navigationFilter = new NavigationFilter
{
DescendantLevels = descendantLevels,
IncludeAncestors = includeAncestors
};
var sitemapItems =
provider.GetNavigationSubtree(sitemapItemId, navigationFilter, localization).ToList();
if (sitemapItems.Count == 0)
{
throw new DxaItemNotFoundException("No sitemap items found.");
}
if (includeAncestors)
{
// if we are including ancestors we also need to get all the direct siblings for each
// level in the hirarchy.
SitemapItem node = FindNode(sitemapItems, sitemapItemId);
// for each parent node get sibling nodes
while (node.Parent != null)
{
var siblings = provider.GetNavigationSubtree(node.Parent.Id,
new NavigationFilter {
DescendantLevels = 1, IncludeAncestors = false
}, localization);
HashSet <string> children = new HashSet <string>();
foreach (var item in node.Parent.Items)
{
children.Add(item.Id);
}
// filter out duplicates and Page types since we don't wish to include them in TOC
foreach (
var sibling in
siblings.Where(
sibling =>
sibling.Id != node.Id && sibling.Type != "Page" &&
!children.Contains(sibling.Id)))
{
node.Parent.Items.Add(sibling);
}
node = node.Parent;
}
}
return FixupSitemap(sitemapItems, true, true);
}));
}
private static TaxonomyNode CreateTaxonomyNode(Keyword keyword, int expandLevels, NavigationFilter filter, Localization localization)
{
if (keyword == null)
{
return(null);
}
string taxonomyId = keyword.TaxonomyUri.Split('-')[1];
bool isRoot = (keyword.KeywordUri == keyword.TaxonomyUri);
int classifiedItemsCount = keyword.ReferencedContentCount;
string taxonomyNodeUrl = null;
List <SitemapItem> childItems = new List <SitemapItem>();
if (expandLevels != 0)
{
// Add child SitemapItems for child Taxonomy Nodes (ordered by title, including sequence prefix if any)
IEnumerable <TaxonomyNode> childTaxonomyNodes = keyword.KeywordChildren.Cast <Keyword>()
.Select(kw => CreateTaxonomyNode(kw, expandLevels - 1, filter, localization));
childItems.AddRange(childTaxonomyNodes);
if (classifiedItemsCount > 0 && filter.DescendantLevels != 0)
{
// Add child SitemapItems for classified Pages (ordered by title)
SitemapItem[] pageSitemapItems = ExpandClassifiedPages(keyword, taxonomyId, localization);
childItems.AddRange(pageSitemapItems);
// If the Taxonomy Node contains an Index Page (i.e. URL path ending with "/index"), we put the Page's SG URL on the Taxonomy Node.
string indexPageUrlPath = pageSitemapItems.Select(i => i.Url).FirstOrDefault(url => url.EndsWith(Constants.IndexPageUrlSuffix, StringComparison.InvariantCultureIgnoreCase));
if (indexPageUrlPath != null)
{
// Strip off "/index" URL suffix so we get the Page's SG URL (except for the Site Home Page, where we use "/")
taxonomyNodeUrl = (indexPageUrlPath.Equals(Constants.IndexPageUrlSuffix, StringComparison.InvariantCultureIgnoreCase)) ? "/" :
indexPageUrlPath.Substring(0, indexPageUrlPath.Length - Constants.IndexPageUrlSuffix.Length);
}
}
childItems = childItems.OrderBy(i => i.OriginalTitle).ToList();
}
string sequencePrefix;
TaxonomyNode result = new TaxonomyNode
{
Id = isRoot ? $"t{taxonomyId}" : FormatKeywordNodeId(keyword.KeywordUri, taxonomyId),
Type = SitemapItem.Types.TaxonomyNode,
OriginalTitle = keyword.KeywordName,
Title = StripSequencePrefix(keyword.KeywordName, out sequencePrefix),
Url = taxonomyNodeUrl,
Visible = !string.IsNullOrEmpty(sequencePrefix) && !string.IsNullOrEmpty(taxonomyNodeUrl),
Items = childItems,
Key = keyword.KeywordKey,
Description = keyword.KeywordDescription,
IsAbstract = keyword.IsAbstract,
HasChildNodes = keyword.HasChildren || (classifiedItemsCount > 0),
ClassifiedItemsCount = classifiedItemsCount
};
if (childItems != null)
{
foreach (SitemapItem childItem in childItems)
{
childItem.Parent = result;
}
}
return(result);
}
/// <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) => ((IOnDemandNavigationProvider)NavigationProvider).GetNavigationSubtree(sitemapItemId, filter, localization);
