public HtmlTextWriter buildItems(HtmlTextWriter writer, TermSet termSet)
{
var navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, Site.OpenWeb(),
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
return(BuildItems(writer, navTermSet));
}
/// <summary>
/// Add Terms
/// </summary>
/// <param name="name"></param>
/// <param name="navigation"></param>
/// <returns></returns>
public bool AddTerms(string name, bool navigation)
{
try
{
var session = new TaxonomySession(SpSite);
var termStore = session.TermStores[NameTermStore];
var group = termStore.Groups[NameGroup];
var term = group.CreateTermSet(name);
term.IsOpenForTermCreation = true;
if (navigation)
{
var navTermSet = NavigationTermSet.GetAsResolvedByWeb(term, SpSite.RootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
}
termStore.CommitAll();
return(true);
}
catch (Exception exception)
{
Logger.Error(string.Concat("Error AddTerms", exception.Message));
return(false);
}
}
/// <summary>
/// Function to add terms Navigation
/// </summary>
/// <param name="term"></param>
/// <param name="navigation">Objeto Navegación</param>
/// <returns></returns>
public bool AddTermsNavigation(string term, TaxonomyNavigationValue navigation)
{
try
{
var session = new TaxonomySession(SpSite);
var termStore = session.TermStores[NameTermStore];
var group = termStore.Groups[NameGroup];
TermSet termSet;
try
{
termSet = group.TermSets[term];
}
catch (Exception)
{
termSet = group.CreateTermSet(term);
}
var navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, SpSite.RootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
if (navigation != null)
{
var termNav = navTermSet.CreateTerm(navigation.Name, navigation.TypeLink);
termNav.SimpleLinkUrl = navigation.Link;
}
termStore.CommitAll();
return(true);
}
catch (Exception exception)
{
Logger.Error(string.Concat("Error GetAllTerms", exception.Message));
return(false);
}
}
/// <summary>
/// Add New Terms
/// </summary>
/// <param name="term"></param>
/// <param name="name"></param>
/// <returns></returns>
public Term AddNewTerms(string term, string name)
{
try
{
var session = new TaxonomySession(SpSite);
var termStore = session.TermStores[NameTermStore];
var group = termStore.Groups[NameGroup];
TermSet termSet;
try
{
termSet = group.TermSets[term];
}
catch (Exception)
{
termSet = group.CreateTermSet(term);
termSet.IsOpenForTermCreation = true;
if (Navigation)
{
var navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, SpSite.RootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
}
}
var result = termSet.CreateTerm(name, (int)SpSite.RootWeb.Language);
termStore.CommitAll();
return(result);
}
catch (Exception exception)
{
Logger.Error(string.Concat("Error AddNewTerms", exception.Message));
return(null);
}
}
private static NavigationTermSet GetEditableNavigationTermSetByProviderName(
Web web, ClientRuntimeContext context, String providerName)
{
// Get the current taxonomy session and update cache, just in case
TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(web.Context);
taxonomySession.UpdateCache();
context.ExecuteQueryRetry();
// Retrieve the Navigation TermSet for the current web
NavigationTermSet navigationTermSet = TaxonomyNavigation.GetTermSetForWeb(web.Context,
web, providerName, true);
context.Load(navigationTermSet);
context.ExecuteQueryRetry();
// Retrieve an editable TermSet for the current target navigation
NavigationTermSet editableNavigationTermSet = navigationTermSet.GetAsEditable(taxonomySession);
context.Load(editableNavigationTermSet);
context.ExecuteQueryRetry();
return(editableNavigationTermSet);
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
string authenticationToken = await helper.getSharePointToken(log, ConfigurationManager.AppSettings["tenantURL"]);
try
{
ITANavigation itaNavigation = new ITANavigation();
using (var clientContext = helper.GetClientContext(ConfigurationManager.AppSettings["tenantURL"], authenticationToken))
{
TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext);
TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore();
NavigationTermSet navigationTermset;
clientContext.Load(termStore, store => store.Groups.Where(g => g.IsSystemGroup == false && g.IsSiteCollectionGroup == false).Include(group => group.TermSets));
clientContext.ExecuteQuery();
foreach (var group in termStore.Groups)
{
foreach (var termSet in group.TermSets)
{
if (termSet.Name == "Offices")
{
List <ITANavigationItem> navigation = new List <ITANavigationItem>();
navigationTermset = NavigationTermSet.GetAsResolvedByWeb(clientContext, termSet, clientContext.Web, "GlobalNavigationTaxonomyProvider");
clientContext.Load(navigationTermset);
clientContext.ExecuteQuery();
var termCollection = navigationTermset.Terms;
clientContext.Load(termCollection, tc => tc.Include(t => t.Title, t => t.SimpleLinkUrl));
clientContext.ExecuteQuery();
string accessToken = await helper.getSharePointToken(log, "https://itadev.sharepoint.com");
foreach (var navTerm in termCollection)
{
navigation.Add(new ITANavigationItem()
{
title = navTerm.Title.Value,
link = navTerm.SimpleLinkUrl,
//visible = true,
//target = "_blank",
children = getChildTerms(navTerm, clientContext)
});
}
//getStaticLinks(itaNavigation, accessToken);
itaNavigation.navigation = navigation;
}
}
}
}
var output = JsonConvert.SerializeObject(itaNavigation);
var response = req.CreateResponse();
response.StatusCode = HttpStatusCode.OK;
response.Content = new StringContent(output, Encoding.UTF8, "application/json");
return(response);
}
catch (Exception ex)
{
return(req.CreateResponse(HttpStatusCode.OK, "Error occured : " + ex.Message));
}
}
public static NavigationTermSet CriarItemNaTermStore(string url, string urlweb, Guid NavTermSetId, Guid TaggingTermSetId)
{
SPSite site = new SPSite(url);
SPWeb web = site.AllWebs[urlweb];
TaxonomySession taxonomySession = new TaxonomySession(site);
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("O Serviço de taxonomia não existe");
}
TermStore termStore = taxonomySession.TermStores[0];
TermSet existingTermSet = termStore.GetTermSet(NavTermSetId);
if (existingTermSet != null)
{
existingTermSet.Delete();
termStore.CommitAll();
}
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(web.Site);
TermSet termSet = siteCollectionGroup.CreateTermSet("Teste01", NavTermSetId);
termStore.CommitAll();
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
termStore.CommitAll();
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "/en/Pages/default.aspx";
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink);
term1.SimpleLinkUrl = "http://h9j/pt/Paginas/default.aspx";
termStore.CommitAll();
/*
* NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
*
* term2.FriendlyUrlSegment.Value = "PAgInicial";
*
* term2.TargetUrl.Value = "/en/Pages/default.aspx";
*/
termStore.CommitAll();
return(navTermSet);
}
// 4. En el evento, en la activación de la feature, activar las etiquetas SEO.
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
SPSite site = (SPSite)properties.Feature.Parent;
using (SPWeb web = site.RootWeb)
{
// configure SEO properties for the home page (does not use Navigation Term SEO properites)
SPListItem welcomePage = web.GetListItem(web.RootFolder.WelcomePage);
// Aqui hay 3 Resources descritos en Resources.resx
welcomePage["SeoBrowserTitle"] = Resources.SeoBrowserTitle;
welcomePage["SeoMetaDescription"] = Resources.SeoDescription;
welcomePage["SeoKeywords"] = Resources.SeoKeywords;
welcomePage["SeoRobotsNoIndex"] = false.ToString();
welcomePage.SystemUpdate();
// configure SEO propertie on all navigation terms associated with Welcome Pages
TaxonomySession taxSession = new TaxonomySession(site, updateCache: true);
TermStore termStore = taxSession.DefaultSiteCollectionTermStore;
Group termGroup = termStore.GetSiteCollectionGroup(site, true);
// locate the navigation term set for the site collection (there can be only one)
foreach (TermSet termSet in termGroup.TermSets)
{
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, site.RootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
if (navTermSet.IsNavigationTermSet)
{
// determine which navigation nodes are associated with Welcome Page content types
foreach (NavigationTerm navTerm in navTermSet.Terms)
{
string pageUrl = SPUtility.GetServerRelativeUrlFromPrefixedUrl(navTerm.TargetUrl.Value);
SPListItem pageItem = web.GetListItem(pageUrl);
if (pageItem.ContentType.Name == "Welcome Page")
{
// set the SEO properties on the Navigation Term (all will have same SEO tags)
Term term = termSet.GetTerm(navTerm.Id);
term.SetLocalCustomProperty("_Sys_Seo_PropBrowserTitle", Resources.SeoBrowserTitle);
term.SetLocalCustomProperty("_Sys_Seo_PropDescription", Resources.SeoDescription);
term.SetLocalCustomProperty("_Sys_Seo_PropKeywords", Resources.SeoKeywords);
term.SetLocalCustomProperty("_Sys_Seo_PropSiteNoIndex", false.ToString());
}
}
break;
}
}
termStore.CommitAll();
web.Update();
}
}
public static NavigationTermSet RecreateSampleNavTermSet(TestContext testContext,
TaxonomySession taxonomySession, SPWeb web)
{
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): START");
// Use the first TermStore object in the list.
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("The Taxonomy Service is offline or missing.");
}
TermStore termStore = taxonomySession.TermStores[0];
// Does the TermSet object already exist?
TermSet existingTermSet = termStore.GetTermSet(TestConfig.NavTermSetId);
if (existingTermSet != null)
{
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): Deleting old TermSet");
existingTermSet.Delete();
termStore.CommitAll();
}
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): Creating new TermSet");
// Create a new TermSet object.
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(web.Site);
TermSet termSet = siteCollectionGroup.CreateTermSet("Navigation Demo", TestConfig.NavTermSetId);
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "~site/Pages/Topics/Topic.aspx";
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink);
term1.SimpleLinkUrl = "http://www.bing.com/";
NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl);
NavigationTerm term2a = term2.CreateTerm("Term 2 A", NavigationLinkType.FriendlyUrl);
NavigationTerm term2b = term2.CreateTerm("Term 2 B", NavigationLinkType.FriendlyUrl);
NavigationTerm term3 = navTermSet.CreateTerm("Term 3", NavigationLinkType.FriendlyUrl);
termStore.CommitAll();
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): FINISH");
return(navTermSet);
}
public void ConfigureTaxonomyNavigation()
{
using (SPSite site = new SPSite(TestConfig.ServerUrl))
{
using (SPWeb web = site.OpenWeb())
{
TaxonomySession taxonomySession = new TaxonomySession(site, updateCache: true);
NavigationTermSet termSet = DemoUtilities.RecreateSampleNavTermSet(
this.TestContext, taxonomySession, web);
// Clear any old settings.
WebNavigationSettings webNavigationSettings = new WebNavigationSettings(web);
webNavigationSettings.ResetToDefaults();
webNavigationSettings.Update(taxonomySession);
TaxonomyNavigation.FlushSiteFromCache(site);
this.WaitForSync();
// Verify the TermSet object is not running.
NavigationTermSet actualTermSet;
actualTermSet = TaxonomyNavigation.GetTermSetForWeb(web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider,
includeInheritedSettings: true);
Assert.IsTrue(actualTermSet == null);
// Assign the new settings.
webNavigationSettings = new WebNavigationSettings(web);
// GlobalNavigation = top menu (aka "top nav")
// CurrentNavigation = left menu (aka "quick launch")
webNavigationSettings.GlobalNavigation.Source = StandardNavigationSource.TaxonomyProvider;
webNavigationSettings.GlobalNavigation.TermStoreId = termSet.TermStoreId;
webNavigationSettings.GlobalNavigation.TermSetId = termSet.Id;
webNavigationSettings.Update(taxonomySession);
TaxonomyNavigation.FlushSiteFromCache(site);
this.WaitForSync();
actualTermSet = TaxonomyNavigation.GetTermSetForWeb(web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider,
includeInheritedSettings: true);
Assert.AreEqual(termSet.Id, actualTermSet.Id);
}
}
}
public static NavigationTermSet CriarItemNaTermStore(string url, string urlweb, Guid NavTermSetId, Guid TaggingTermSetId)
{
SPSite site = new SPSite(url);
SPWeb web = site.AllWebs[url];
TaxonomySession taxonomySession = new TaxonomySession(site);
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("O Serviço de taxonomia não existe");
}
TermStore termStore = taxonomySession.TermStores[0];
TermSet existingTermSet = termStore.GetTermSet(NavTermSetId);
if (existingTermSet != null)
{
existingTermSet.Delete();
termStore.CommitAll();
}
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(web.Site);
TermSet termSet = siteCollectionGroup.CreateTermSet("Teste01", NavTermSetId);
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "~site/Pages/Topics/Topic.aspx";
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink);
term1.SimpleLinkUrl = "https://ekisiot.sharepoint.com/";
NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl);
NavigationTerm term2a = term2.CreateTerm("Term 2 A", NavigationLinkType.FriendlyUrl);
NavigationTerm term2b = term2.CreateTerm("Term 2 B", NavigationLinkType.FriendlyUrl);
NavigationTerm term3 = navTermSet.CreateTerm("Term 3", NavigationLinkType.FriendlyUrl);
termStore.CommitAll();
return(navTermSet);
}
/// <summary>
/// Determines whether the current HTTP request can be resolved to a <see cref="NavigationTermSet"/> object.
/// When client is visiting the welcome page of the site where it is set to have a unique managed navigation,
/// <see cref="TaxonomyNavigationContext.HasNavigationContext"/> returns *false* even though this page can be referred by the friendly URL resolved by the <see cref="NavigationTermSet"/> object.
/// </summary>
/// <param name="navigationTermSet">The resolved <see cref="NavigationTermSet"/> object; otherwise *null*.</param>
/// <returns>*true* if the current HTTP request can be resolved to a <see cref="NavigationTermSet"/> object.</returns>
public static bool IsRequestingNavigationTermSet(out NavigationTermSet navigationTermSet)
{
if (SPContext.Current != null)
{
SPWeb currentWeb = SPContext.Current.Web;
navigationTermSet = TaxonomyNavigation.GetTermSetForWeb(currentWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider, true);
using (new SPSecurity.GrantAdditionalPermissionsInScope(SPBasePermissions.FullMask)) {
if (navigationTermSet != null && navigationTermSet.GetResolvedDisplayUrl(null) == currentWeb.ServerRelativeUrl && SPUrlUtility.CombineUrl(currentWeb.ServerRelativeUrl, currentWeb.RootFolder.WelcomePage) == SPUtility.OriginalServerRelativeRequestPath)
{
return(true);
}
}
}
navigationTermSet = null;
return(false);
}
// Uncomment the method below to handle the event raised after a feature has been activated.
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
SPSite site = (SPSite)properties.Feature.Parent;
using (SPWeb web = site.RootWeb)
{
SPListItem welcomePage = web.GetListItem(web.RootFolder.WelcomePage);
welcomePage["SeoBrowserTitle"] = Resources.SeoBrowserTitle;
welcomePage["SeoMetaDescription"] = Resources.SeoDescription;
welcomePage["SeoKeywords"] = Resources.SeoKeywords;
welcomePage["SeoRobotsNoIndex"] = false.ToString();
welcomePage.SystemUpdate();
TaxonomySession taxSession = new TaxonomySession(site, updateCache: true);
TermStore termStore = taxSession.DefaultSiteCollectionTermStore;
Group termGroup = termStore.GetSiteCollectionGroup(site, true);
foreach (TermSet termSet in termGroup.TermSets)
{
NavigationTermSet navigationTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, site.RootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
if (navigationTermSet.IsNavigationTermSet)
{
foreach (NavigationTerm navTerm in navigationTermSet.Terms)
{
string pageUrl = SPUtility.GetServerRelativeUrlFromPrefixedUrl(navTerm.TargetUrl.Value);
SPListItem pageItem = web.GetListItem(pageUrl);
if (pageItem.ContentType.Name == "Welcome page") // si no funciona verificar
{
Term term = termSet.GetTerm(navTerm.Id);
term.SetLocalCustomProperty("_Sys_Seo_PropBrowserTitle", Resources.SeoBrowserTitle);
term.SetLocalCustomProperty("_Sys_Seo_PropDescription", Resources.SeoDescription);
term.SetLocalCustomProperty("_Sys_Seo_PropKeywords", Resources.SeoKeywords);
term.SetLocalCustomProperty("_Sys_Seo_PropSiteNoIndex", false.ToString());
}
}
break;
}
}
termStore.CommitAll();
web.Update();
}
}
private List <Project_Pagemap> GetFriendlyURLSFromTaxonomy()
{
List <Project_Pagemap> lstPagemap = new List <Project_Pagemap>();
try
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite mySite = new SPSite(SPContext.Current.Site.Url))
{
using (SPWeb myWeb = mySite.OpenWeb())
{
TaxonomySession taxonomySession = new TaxonomySession(myWeb.Site);
TermStore termStore = taxonomySession.DefaultSiteCollectionTermStore;
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(myWeb.Site, createIfMissing: false);
TermSet termSet = siteCollectionGroup.TermSets["Lappia Education"];
NavigationTermSet tsList = NavigationTermSet.GetAsResolvedByWeb(termSet, myWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
for (int i = 0; i < tsList.Terms.Count; i++)
{
if (!string.IsNullOrEmpty(tsList.Terms[i].Title.Value.ToLower()))
{
Project_Pagemap objPagemap = new Project_Pagemap();
objPagemap.Name = tsList.Terms[i].Title.Value;
objPagemap.Subsection = "Root";
objPagemap.Url = "/" + tsList.Terms[i].FriendlyUrlSegment.Value;
objPagemap.TermId = tsList.Terms[i].Id;
lstPagemap.Add(objPagemap);
Bind(lstPagemap, tsList.Terms[i], tsList.Terms[i].Title.Value.ToLower(), tsList.Terms[i].FriendlyUrlSegment.Value);
}
}
}
}
});
}
catch (Exception ex)
{
lblMessage.Text = "GetFriendlyURLSFromTaxonomy Error : " + ex.Message;
}
return(lstPagemap);
}
public override void ItemAdded(SPItemEventProperties properties)
{
base.ItemAdded(properties);
try
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
SPWeb myWeb = properties.Web;
if (properties.ListTitle == "SectionDetails")
{
#region "Create Termstore Set For Friendly URL"
TaxonomySession taxonomySession = new TaxonomySession(myWeb.Site);
taxonomySession.UpdateCache();
TermStore termStore = taxonomySession.DefaultSiteCollectionTermStore;
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(myWeb.Site, createIfMissing: true);
TermSet ts = siteCollectionGroup.TermSets.Where(p => p.Name.ToLower() == "lappia education").FirstOrDefault();
if (ts != null)//check term set is exist or not
{
NavigationTermSet navigationTermSet = NavigationTermSet.GetAsResolvedByWeb(ts, myWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navigationTermSet.IsNavigationTermSet = true;
NavigationTerm subterm = navigationTermSet.CreateTerm(Convert.ToString(properties.ListItem["Title"].ToString()) + ".aspx", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
if ((uint)System.Globalization.CultureInfo.CurrentUICulture.LCID == 1033)
{
subterm.TargetUrl.Value = SPContext.Current.Web.Url + "/Pages/" + Convert.ToString(properties.ListItem["Title"].ToString()) + ".aspx";
}
else if ((uint)System.Globalization.CultureInfo.CurrentUICulture.LCID == 1035)
{
subterm.TargetUrl.Value = SPContext.Current.Web.Url + "/Pages/" + Convert.ToString(properties.ListItem["Title"].ToString()) + ".aspx";
}
}
termStore.CommitAll();
#endregion
}
});
}
catch (Exception ex)
{
}
}
/// <summary>
/// Gets a <see cref="NavigationTerm"/> object by the specified unique ID.
/// </summary>
/// <param name="termId">Term unique identifier.</param>
/// <returns>A <see cref="NavigationTerm"/> object.</returns>
public static NavigationTerm GetNavigationTerm(Guid termId)
{
if (SPContext.Current != null && termId != Guid.Empty)
{
SPWeb currentWeb = SPContext.Current.Web;
NavigationTermSet navigationTermSet = TaxonomyNavigation.GetTermSetForWeb(currentWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider, true);
if (navigationTermSet != null)
{
TaxonomySession session = new TaxonomySession(currentWeb, false);
Term term = navigationTermSet.GetTaxonomyTermSet(session).GetTerm(termId);
if (term != null)
{
using (SPWeb navigationRootWeb = currentWeb.Site.OpenWeb(navigationTermSet.GetResolvedDisplayUrl(null))) {
return(NavigationTerm.GetAsResolvedByWeb(term, navigationRootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider));
}
}
}
}
return(null);
}
private List <Project_Pagemap> GetFriendlyURLSFromTaxonomy()
{
List <Project_Pagemap> objtest = new List <Project_Pagemap>();
try
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite mySite = new SPSite(SPContext.Current.Site.Url))
{
using (SPWeb myWeb = mySite.OpenWeb())
{
TaxonomySession taxonomySession = new TaxonomySession(myWeb.Site);
TermStore termStore = taxonomySession.DefaultSiteCollectionTermStore;
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(myWeb.Site, createIfMissing: false);
TermSet termSet = siteCollectionGroup.TermSets["Lappia Education"];
NavigationTermSet tsList = NavigationTermSet.GetAsResolvedByWeb(termSet, myWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
string url = (uint)System.Globalization.CultureInfo.CurrentUICulture.LCID == 1033 ? "/sites/en-us" : "/sites/fi-fi";
for (int i = 0; i < tsList.Terms.Count; i++)
{
if (!string.IsNullOrEmpty(tsList.Terms[i].Title.Value.ToLower()))
{
Project_Pagemap ptest = new Project_Pagemap();
ptest.Name = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(tsList.Terms[i].Title.Value);
ptest.Subsection = "Root";
ptest.Url = url + "/" + tsList.Terms[i].FriendlyUrlSegment.Value;
ptest.TermId = tsList.Terms[i].Id;
objtest.Add(ptest);
Bind(objtest, tsList.Terms[i], tsList.Terms[i].Title.Value, i, 1, tsList.Terms[i].FriendlyUrlSegment.Value, url);
}
}
}
}
});
}
catch (Exception ex)
{
}
return(objtest);
}
/// Configures the web to use Taxonomy Navigation with the sample term set.
public static NavigationTermSet SetUpSampleNavTermSet(TestContext testContext,
TaxonomySession taxonomySession, SPWeb web)
{
NavigationTermSet termSet = RecreateSampleNavTermSet(testContext, taxonomySession, web);
// Clear any old settings.
WebNavigationSettings webNavigationSettings = new WebNavigationSettings(web);
webNavigationSettings.ResetToDefaults();
webNavigationSettings.GlobalNavigation.Source = StandardNavigationSource.TaxonomyProvider;
webNavigationSettings.GlobalNavigation.TermStoreId = termSet.TermStoreId;
webNavigationSettings.GlobalNavigation.TermSetId = termSet.Id;
webNavigationSettings.CurrentNavigation.Source = StandardNavigationSource.TaxonomyProvider;
webNavigationSettings.CurrentNavigation.TermStoreId = termSet.TermStoreId;
webNavigationSettings.CurrentNavigation.TermSetId = termSet.Id;
webNavigationSettings.Update(taxonomySession);
TaxonomyNavigation.FlushSiteFromCache(web.Site);
return(termSet);
}
// previously returned string
//public HtmlTextWriter buildItems(HtmlTextWriter writer, TermCollection terms)
public HtmlTextWriter BuildItems(HtmlTextWriter writer, NavigationTermSet navTerms)
{
//if (terms.Count > 0)
// Don't need this and maybe deprecate
//var termSet = navTerms.GetTaxonomyTermSet();
if (navTerms.IsNavigationTermSet)
{
Level++;
//foreach (Term term in terms)
//foreach (NavigationTerm navTerm in navTerms)
for (var i = 0; i <= navTerms.Terms.Count; i++)
{
try
{
var navTerm = navTerms.Terms[i];
if (navTerm.ExcludeFromGlobalNavigation)
{
continue;
}
//buildItem(writer, term);
buildItem(writer, navTerm);
}
catch (Exception)
{
// Add Exception stuff here...
}
}
Level--;
//html += "</ul>\n";
}
return(writer);
}
/// <summary>
/// Set term driven page settings in the term store
/// </summary>
/// <param name="site">The site</param>
/// <param name="termDrivenPageInfo">The term driven page setting info</param>
public void SetTermDrivenPageSettings(SPSite site, TermDrivenPageSettingInfo termDrivenPageInfo)
{
// Force the taxonomy session to update the cache due to previous changes
// Note: this is necessary in the context of the components installation script
var taxonomySession = new TaxonomySession(site, true);
if (taxonomySession.TermStores.Count > 0)
{
var defaultTermStore = taxonomySession.DefaultSiteCollectionTermStore;
// Term Set setting
if (termDrivenPageInfo.IsTermSet)
{
// Get the term set group by name
// Note, when you build the term store hierachy by XML using Gary Lapointe Cmdlet, the term group ID isn't kept
var group = this.taxonomyService.GetTermGroupFromStore(defaultTermStore, termDrivenPageInfo.TermSet.Group.Name);
if (group != null)
{
// Get the term set
var termSet = group.TermSets[termDrivenPageInfo.TermSet.Id];
// Set URLs
if (!string.IsNullOrEmpty(termDrivenPageInfo.TargetUrlForChildTerms))
{
termSet.SetCustomProperty("_Sys_Nav_TargetUrlForChildTerms", termDrivenPageInfo.TargetUrlForChildTerms);
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.CatalogTargetUrlForChildTerms))
{
termSet.SetCustomProperty("_Sys_Nav_CatalogTargetUrlForChildTerms", termDrivenPageInfo.CatalogTargetUrlForChildTerms);
}
termSet.TermStore.CommitAll();
}
}
// Term setting
if (termDrivenPageInfo.IsTerm)
{
// Get the taxonomy term
var term = this.taxonomyService.GetTermForId(site, termDrivenPageInfo.Term.Id);
if (term != null)
{
var terms = new List <Term> {
term
};
terms.AddRange(term.ReusedTerms);
// For the orginal term and its reuses
foreach (var currentTerm in terms)
{
string isNavigationTermSet;
// Check if the term term set is flagged as navigation term set
// By default a TermSet doesn't have the custom property "_Sys_Nav_IsNavigationTermSet" so we can't acces it directly in the collection
currentTerm.TermSet.CustomProperties.TryGetValue("_Sys_Nav_IsNavigationTermSet", out isNavigationTermSet);
// If the term set allow navigation
if (!string.IsNullOrEmpty(isNavigationTermSet))
{
// Get the associated navigation term set
var navigationTermSet = NavigationTermSet.GetAsResolvedByWeb(
currentTerm.TermSet,
site.RootWeb,
StandardNavigationProviderNames.CurrentNavigationTaxonomyProvider);
// Get the navigation term
var navigationTerm = navigationTermSet.Terms.FirstOrDefault(t => t.Id.Equals(currentTerm.Id));
if (navigationTerm != null)
{
navigationTerm.ExcludeFromCurrentNavigation =
termDrivenPageInfo.ExcludeFromCurrentNavigation;
navigationTerm.ExcludeFromGlobalNavigation =
termDrivenPageInfo.ExcludeFromGlobalNavigation;
}
if (termDrivenPageInfo.IsSimpleLinkOrHeader)
{
if (!string.IsNullOrEmpty(termDrivenPageInfo.SimpleLinkOrHeader))
{
currentTerm.SetLocalCustomProperty(
"_Sys_Nav_SimpleLinkUrl",
termDrivenPageInfo.SimpleLinkOrHeader);
}
}
else
{
// Set URLs properties
if (!string.IsNullOrEmpty(termDrivenPageInfo.TargetUrl))
{
currentTerm.SetLocalCustomProperty("_Sys_Nav_TargetUrl", termDrivenPageInfo.TargetUrl);
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.TargetUrlForChildTerms))
{
currentTerm.SetLocalCustomProperty(
"_Sys_Nav_TargetUrlForChildTerms",
termDrivenPageInfo.TargetUrlForChildTerms);
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.CatalogTargetUrl))
{
currentTerm.SetLocalCustomProperty(
"_Sys_Nav_CatalogTargetUrl",
termDrivenPageInfo.CatalogTargetUrl);
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.CatalogTargetUrlForChildTerms))
{
currentTerm.SetLocalCustomProperty(
"_Sys_Nav_CatalogTargetUrlForChildTerms",
termDrivenPageInfo.CatalogTargetUrlForChildTerms);
}
}
// Commit all updates
currentTerm.TermStore.CommitAll();
}
}
}
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Create a monitored scope for the developer dashboard, etc.
using (new SPMonitoredScope("iVision.Menu.ControlTemplates.iVision.Menu.GlobalMenu::Page_Load"))
{
if (!Page.IsPostBack)
{
Level = 0;
SPSecurity.RunWithElevatedPrivileges(delegate
{
using (
var thisSite =
new SPSite(SPContext.Current.Site.WebApplication.AlternateUrls[0].Uri.AbsoluteUri))
{
Site = thisSite;
// Get Taxonomy Session, Term Store
var session = new TaxonomySession(thisSite);
// Use the first TermStore in the list
if (session.TermStores.Count == 0)
{
throw new InvalidOperationException("The Taxonomy Service is offline or missing");
}
// Initialize StringWriter instance.
var stringWriter = new StringWriter();
// Put HtmlTextWriter in using block because it needs to call Dispose.
using (var writer = new HtmlTextWriter(stringWriter))
{
TermSet termSetForNav;
var stores = session.TermStores;
var termStoreGuid = Guid.Empty;
if (Guid.TryParse(TermStoreId, out termStoreGuid))
{
var termStore = TermStoreManager.GetTermStore(session, termStoreGuid);
var termSetGuid = Guid.Empty;
if (Guid.TryParse(TermSetId, out termSetGuid))
{
termSetForNav = termStore.GetTermSet(termSetGuid);
if (null == termSetForNav)
{
//termSetForNav = termStore.Groups["Navigation"].TermSets["Global"];
}
}
else
{
//nTermSet = termStore.Groups["Navigation"].TermSets.GetByName("Global");
termSetForNav = termStore.Groups["Navigation"].TermSets["Global"];
}
}
else
{
termSetForNav = stores[0].Groups["Navigation"].TermSets["Global"];
}
if (null == termSetForNav)
{
//return;
}
var navigationTermSet = NavigationTermSet.GetAsResolvedByWeb(termSetForNav,
thisSite.OpenWeb(), StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
this.CTermSet = new CurrentTermSet
{
TermSet = termSetForNav,
NavigationTermSet = navigationTermSet
};
// Begin nav output
CssClass = "nav navbar-nav";
//writer.AddAttribute("role", "navigation");
writer.AddAttribute(HtmlTextWriterAttribute.Class, CssClass);
writer.RenderBeginTag(HtmlTextWriterTag.Ul);
// check nTermSet somehow
//buildItems(writer, navTermSet.Terms);
//this.buildItems(writer, cTermSet.getTerms());
this.BuildItems(writer, navigationTermSet);
writer.RenderEndTag();
}
// Return the result.
GlobalMenuContainer.Text = "";
GlobalMenuContainer.Text = stringWriter.ToString();
}
});
}
}
}
private static void ManagedRePin()
{
using (SPSite site = new SPSite("http://win-f33ohjutmmi/sites/cms"))
{
using (SPWeb web = site.OpenWeb())
{
TaxonomySession _TaxonomySession = new TaxonomySession(site);
//Get instance of the Term Store
TermStore _TermStore = _TaxonomySession.TermStores["Managed Metadata Service"];
Group _Group = _TermStore.GetSiteCollectionGroup(site);
////Create a new Term Set in the new Group
TermSet _TermSet = null;
try
{
_TermSet = _Group.TermSets["CMSNavigationTermSet"];
}
catch { }
if (_TermSet != null)
{
//_TermSet.Delete();
//_TermStore.CommitAll();
_TermSet.Terms["Department"].Delete();
_TermStore.CommitAll();
}
else
{
_TermSet = _Group.CreateTermSet("CMSNavigationTermSet");
NavigationTermSet navigationTermSet = NavigationTermSet.GetAsResolvedByWeb(_TermSet, site.RootWeb,
StandardNavigationProviderNames.CurrentNavigationTaxonomyProvider);
navigationTermSet.IsNavigationTermSet = true;
}
//locate the term in source farm
var srcgroup = from g in _TermStore.Groups where g.Name == "NavigationGroup" select g;
var srctermSet = srcgroup.FirstOrDefault().TermSets["GlobalNav"];
var srcterm = srctermSet.Terms["Department"];
var newterm = _TermSet.ReuseTermWithPinning(srcterm);
newterm.CustomSortOrder = srcterm.CustomSortOrder;
//commit changes
_TermStore.CommitAll();
var webNavigationSettings = new WebNavigationSettings(web);
webNavigationSettings.GlobalNavigation.Source = StandardNavigationSource.TaxonomyProvider;
webNavigationSettings.GlobalNavigation.TermStoreId = _TermStore.Id;
webNavigationSettings.GlobalNavigation.TermSetId = _TermSet.Id;
webNavigationSettings.Update();
var pubWeb = PublishingWeb.GetPublishingWeb(web);
pubWeb.Update();
web.Update();
}
}
}
private void SetTermDrivenPageSettingsOnTerm(SPWeb currentWeb, TermDrivenPageSettingInfo termDrivenPageInfo, TaxonomySession currentSession)
{
SPWeb webWithNavSettings = null;
var webNavigationSettings = FindTaxonomyWebNavigationSettingsInWebOrInParents(currentWeb, out webWithNavSettings);
if (webNavigationSettings != null &&
webNavigationSettings.GlobalNavigation.Source == StandardNavigationSource.TaxonomyProvider)
{
var termStore = termDrivenPageInfo.Term.TermSet.ResolveParentTermStore(currentSession);
if (termStore.Id != webNavigationSettings.GlobalNavigation.TermStoreId)
{
string termStoreMismatchErrorMsg = string.Format(
CultureInfo.InvariantCulture,
"NavigationHelper.SetTermDrivenPageSettingsOnTerm: The parent term store for the specified TermInfo (TermStoreId={0}) does not match the current webNavigationSettings.GlobalNavigation.TermStoreId ({1}).",
termStore.Id,
webNavigationSettings.GlobalNavigation.TermStoreId);
throw new NotSupportedException(termStoreMismatchErrorMsg);
}
var previousThreadCulture = CultureInfo.CurrentCulture;
var previousThreadUiCulture = CultureInfo.CurrentUICulture;
var previousWorkingLanguage = termStore.WorkingLanguage;
try
{
CultureInfo currentWebCulture = webWithNavSettings.Locale;
CultureInfo currentWebUiCulture = new CultureInfo((int)webWithNavSettings.Language);
// Force thread culture/uiculture and term store working language
Thread.CurrentThread.CurrentCulture = currentWebCulture;
Thread.CurrentThread.CurrentUICulture = currentWebUiCulture;
termStore.WorkingLanguage = currentWebCulture.LCID; // force the working language to fit with the current web language
var termSet = termStore.GetTermSet(webNavigationSettings.GlobalNavigation.TermSetId);
// Get the taxonomy term
var term = termSet.GetTerm(termDrivenPageInfo.Term.Id);
if (term != null)
{
string isNavigationTermSet;
// Check if the term term set is flagged as navigation term set
// By default a TermSet doesn't have the custom property "_Sys_Nav_IsNavigationTermSet" so we can't acces it directly in the collection
term.TermSet.CustomProperties.TryGetValue(SystemIsNavigationTermSet, out isNavigationTermSet);
// If the term set allow navigation
if (!string.IsNullOrEmpty(isNavigationTermSet))
{
// Get the associated navigation term set
var navigationTermSet = NavigationTermSet.GetAsResolvedByWeb(
term.TermSet,
webWithNavSettings,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navigationTermSet = navigationTermSet.GetAsEditable(currentSession);
// Get the navigation term
var navigationTerm = FindTermInNavigationTermsCollection(navigationTermSet.Terms, term.Id);
if (navigationTerm != null)
{
// Gotta re-fetch the navigation term as an "editable" instance in order to avoid UnauthorizedAccessExceptions
navigationTerm = navigationTerm.GetAsEditable(currentSession);
navigationTerm.ExcludeFromCurrentNavigation = termDrivenPageInfo.ExcludeFromCurrentNavigation;
navigationTerm.ExcludeFromGlobalNavigation = termDrivenPageInfo.ExcludeFromGlobalNavigation;
if (termDrivenPageInfo.IsSimpleLinkOrHeader)
{
if (!string.IsNullOrEmpty(termDrivenPageInfo.SimpleLinkOrHeader))
{
if (navigationTerm.LinkType == NavigationLinkType.FriendlyUrl)
{
// clear any existing target URL on the term
navigationTerm.TargetUrl.Value = string.Empty;
navigationTerm.TargetUrlForChildTerms.Value = string.Empty;
navigationTerm.CatalogTargetUrl.Value = string.Empty;
navigationTerm.CatalogTargetUrlForChildTerms.Value = string.Empty;
}
if (navigationTerm.LinkType != NavigationLinkType.SimpleLink)
{
navigationTerm.LinkType = NavigationLinkType.SimpleLink;
}
navigationTerm.SimpleLinkUrl = termDrivenPageInfo.SimpleLinkOrHeader;
}
}
else
{
// Set URLs properties
if (navigationTerm.LinkType != NavigationLinkType.FriendlyUrl)
{
navigationTerm.LinkType = NavigationLinkType.FriendlyUrl;
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.TargetUrl))
{
navigationTerm.TargetUrl.Value = termDrivenPageInfo.TargetUrl;
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.TargetUrlForChildTerms))
{
navigationTerm.TargetUrlForChildTerms.Value = termDrivenPageInfo.TargetUrlForChildTerms;
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.CatalogTargetUrl))
{
navigationTerm.CatalogTargetUrl.Value = termDrivenPageInfo.CatalogTargetUrl;
}
if (!string.IsNullOrEmpty(termDrivenPageInfo.CatalogTargetUrlForChildTerms))
{
navigationTerm.CatalogTargetUrlForChildTerms.Value = termDrivenPageInfo.CatalogTargetUrlForChildTerms;
}
}
// Commit all updates
termStore.CommitAll();
}
else
{
this.logger.Warn(
"TaxonomyHelper.SetTermDrivenPageSettingsOnTerm: Failed to find corresponding NavigationTerm for term ID={0} in term set ID={1} Name={2}",
term.Id,
navigationTermSet.Id,
navigationTermSet.TaxonomyName);
}
}
}
}
finally
{
// Restore previous thread cultures and term store working language
Thread.CurrentThread.CurrentCulture = previousThreadCulture;
Thread.CurrentThread.CurrentUICulture = previousThreadUiCulture;
termStore.WorkingLanguage = previousWorkingLanguage;
}
}
else
{
this.logger.Warn(
"TaxonomyHelper.SetTermDrivenPageSettingsOnTerm: Failed to find taxonomy-type WebNavigationSettings in web ID={0} Url={1} or in any of its parent webs. At least one SPWeb in the hierarchy should have a GlobalNavigation setting of source type Taxonomy.",
currentWeb.ID,
currentWeb.Url);
}
}
private NavigationTerm CreateRootTerm(NavigationTermSet navTermSet, string termTitle, string termURL)
{
NavigationTerm navTerm = navTermSet.CreateTerm(termTitle, NavigationLinkType.SimpleLink);
navTerm.SimpleLinkUrl = termURL;
return navTerm;
}
private void BuildNavTerms(NavigationTermSet navTermSet, string termMap, string siteRelativeURL)
{
XmlReader rdr = XmlReader.Create(new StringReader(termMap));
XmlDocument termDoc = new XmlDocument();
termDoc.Load(rdr);
XmlElement root = termDoc.DocumentElement;
foreach (XmlNode termNode in root.ChildNodes)
{
string combinedURL = CombineRelativeURLs(siteRelativeURL, termNode.Attributes["URL"].Value );
NavigationTerm rootTerm = CreateRootTerm(navTermSet, termNode.Attributes["Title"].Value, combinedURL);
foreach (XmlNode childTermNode in termNode.ChildNodes)
{
combinedURL = CombineRelativeURLs(siteRelativeURL, childTermNode.Attributes["URL"].Value);
CreateSubTerm(rootTerm, childTermNode.Attributes["Title"].Value,
combinedURL);
}
}
}
/// Creates a TermSet object for demonstration purposes. If it already exists, it will be deleted
/// and then recreated.
public static NavigationTermSet RecreateSampleNavTermSet(
ClientContext clientContext, TaxonomySession taxonomySession, Web web)
{
clientContext.Load(taxonomySession, ts => ts.TermStores);
clientContext.ExecuteQuery();
// Use the first TermStore object in the list.
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("The Taxonomy Service is offline or missing.");
}
TermStore termStore = taxonomySession.TermStores[0];
clientContext.Load(termStore,
ts => ts.Name,
ts => ts.WorkingLanguage);
// Does the TermSet object already exist?
TermSet existingTermSet;
clientContext.ExecuteQuery();
if (!existingTermSet.ServerObjectIsNull.Value)
{
existingTermSet.DeleteObject();
termStore.CommitAll();
clientContext.ExecuteQuery();
}
// Create a new TermSet object.
TermGroup siteCollectionGroup = termStore.GetSiteCollectionGroup(clientContext.Site,
createIfMissing: true);
TermSet termSet = siteCollectionGroup.CreateTermSet("Navigation Demo", TestConfig.NavTermSetId,
termStore.WorkingLanguage);
termStore.CommitAll();
clientContext.ExecuteQuery();
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(clientContext,
termSet, clientContext.Web, "GlobalNavigationTaxonomyProvider");
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "~site/Pages/Topics/Topic.aspx";
termStore.CommitAll();
clientContext.ExecuteQuery();
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink, Guid.NewGuid());
term1.SimpleLinkUrl = "http://www.bing.com/";
NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
NavigationTerm term2a = term2.CreateTerm("Term 2 A", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
NavigationTerm term2b = term2.CreateTerm("Term 2 B", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
NavigationTerm term3 = navTermSet.CreateTerm("Term 3", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
termStore.CommitAll();
clientContext.ExecuteQuery();
return(navTermSet);
}
public void ConfigureTaxonomyNavigation()
{
ClientContext clientContext = new ClientContext(TestConfig.ServerUrl);
TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext);
taxonomySession.UpdateCache();
NavigationTermSet termSet = DemoUtilities.RecreateSampleNavTermSet(
this.TestContext, clientContext, taxonomySession, clientContext.Web);
// Clear out any old settings
WebNavigationSettings webNavigationSettings = new WebNavigationSettings(clientContext, clientContext.Web);
webNavigationSettings.ResetToDefaults();
webNavigationSettings.Update(taxonomySession);
TaxonomyNavigation.FlushSiteFromCache(clientContext, clientContext.Site);
clientContext.ExecuteQuery();
this.WaitForSync();
// Verify the TermSet is not running
NavigationTermSet actualTermSet;
ExceptionHandlingScope scope = new ExceptionHandlingScope(clientContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
actualTermSet = TaxonomyNavigation.GetTermSetForWeb(clientContext, clientContext.Web,
"GlobalNavigationTaxonomyProvider", includeInheritedSettings: true);
}
using (scope.StartCatch())
{
}
}
clientContext.ExecuteQuery();
Assert.IsTrue(actualTermSet.ServerObjectIsNull.Value);
// Assign the new settings
webNavigationSettings = new WebNavigationSettings(clientContext, clientContext.Web);
clientContext.Load(webNavigationSettings,
w => w.GlobalNavigation,
w => w.CurrentNavigation
);
clientContext.Load(termSet,
ts => ts.TermStoreId,
ts => ts.Id
);
clientContext.ExecuteQuery();
// GlobalNavigation = top menu (aka "top nav")
// CurrentNavigation = left menu (aka "quick launch")
webNavigationSettings.GlobalNavigation.Source = StandardNavigationSource.TaxonomyProvider;
webNavigationSettings.GlobalNavigation.TermStoreId = termSet.TermStoreId;
webNavigationSettings.GlobalNavigation.TermSetId = termSet.Id;
webNavigationSettings.Update(taxonomySession);
TaxonomyNavigation.FlushSiteFromCache(clientContext, clientContext.Site);
clientContext.ExecuteQuery();
this.WaitForSync();
actualTermSet = TaxonomyNavigation.GetTermSetForWeb(clientContext, clientContext.Web,
"GlobalNavigationTaxonomyProvider", includeInheritedSettings: true);
clientContext.Load(actualTermSet, ts => ts.Id);
clientContext.ExecuteQuery();
Assert.AreEqual(termSet.Id, actualTermSet.Id);
}
