public static string GetTermIdForTerm(string term, Guid termSetId, ClientContext clientContext) { string termId = string.Empty; //Get term set from ID TaxonomySession tSession = TaxonomySession.GetTaxonomySession(clientContext); TermStore ts = tSession.GetDefaultSiteCollectionTermStore(); TermSet tset = ts.GetTermSet(termSetId); LabelMatchInformation lmi = new LabelMatchInformation(clientContext); lmi.Lcid = 1033; lmi.TrimUnavailable = true; lmi.TermLabel = term; //Search for matching terms in the term set based on label TermCollection termMatches = tset.GetTerms(lmi); clientContext.Load(tSession); clientContext.Load(ts); clientContext.Load(tset); clientContext.Load(termMatches); clientContext.ExecuteQuery(); //Set term ID to first match if (termMatches != null && termMatches.Count() > 0) { termId = termMatches.First().Id.ToString(); } return(termId); }
public string WriteTerms(TermCollection terms) { var tabInt = 0; if (terms.Count > 0) { html += "\n<ul class=\"CustomSP2013GlobalNav\">\n"; foreach (Term subTerm in terms) { try { html += "<li class=\"\"><a class=\"dynamic\" tabindex=\"" + tabInt + "\" href=\"" + subTerm.LocalCustomProperties["_Sys_Nav_SimpleLinkUrl"] + "\">" + subTerm.Name + "</a>"; WriteTerms(subTerm.Terms); html += "</li>\n"; } catch { html += "<li class=\"\"><a class=\"dynamic\" tabindex=\"" + tabInt + "\" href=\"#\">" + subTerm.Name + "</a>"; WriteTerms(subTerm.Terms); html += "</li>\n"; } } html += "</ul>\n"; } return(html); }
public string writeTerms(TermCollection terms) { var tabInt = 0; if (terms.Count > 0) { //html += "\n<ul class=\"CustomSP2013GlobalNav\">\n"; html += "\n<ul class=\"\">\n"; foreach (Term subTerm in terms) { try { html += "<li class=\"\"><a tabindex=\"" + tabInt + "\" onclick=\"window.opener.location.href = this.href; return false;\" href=\"" + subTerm.LocalCustomProperties["_Sys_Nav_SimpleLinkUrl"] + "\">" + subTerm.Name + "</a>"; writeTerms(subTerm.Terms); html += "</li>\n"; } catch { html += "<li class=\"\"><a tabindex=\"" + tabInt + "\" onclick=\"window.opener.location.href = this.href; return false;\" href=\"#\">" + subTerm.Name + "</a>"; writeTerms(subTerm.Terms); html += "</li>\n"; } //tabInt++; } html += "</ul>\n"; } return(html); }
//GetItems //GetTaxanomy public List <SelectListItem> GetTaxanomy(ClientContext context) { List <SelectListItem> items = new List <SelectListItem>(); TermCollection terms = null; TaxonomySession taxonomy = TaxonomySession.GetTaxonomySession(context); if (taxonomy != null) { TermStore termStore = taxonomy.GetDefaultKeywordsTermStore(); if (termStore != null) { TermGroup termGroup = termStore.Groups.GetByName(TERMGROUPNAME); TermSet termSet = termGroup.TermSets.GetByName(TERMSETNAME); terms = termSet.GetAllTerms(); context.Load(terms); context.ExecuteQuery(); foreach (var term in terms) { items.Add(new SelectListItem { Text = term.Name, Value = term.Id.ToString() }); } } } return(items); }
private string addWorkBoxesForRecordsClasses(WBTaxonomy recordsTypes, TermCollection recordsClassesTerms) { if (recordsClassesTerms.Count == 0) { return(""); } // string finalHtml = "<ul class=\"wbf-my-work-boxes-list wbf-records-classes\">\n"; string finalHtml = ""; foreach (Term recordsClassTerm in recordsClassesTerms) { string html = addWorkBoxesForRecordsClass(recordsTypes, recordsClassTerm.Terms); if (html != "" || ShowAllRecordsTypes) { // html = "<li class=\"wbf-records-class\">\n" + recordsClassTerm.Name + "\n" + html + "</li>\n"; html = "<tr><td colspan=\"5\" class=\"wbf-records-class\">\n" + recordsClassTerm.Name + "</td></tr>\n" + html; finalHtml += html; } } // finalHtml += "</ul>\n"; return(finalHtml); }
/// <summary> /// This extension method will give all the terms for a give path mentioned /// </summary> /// <param name="termSet">From which term set, we need to find a given term path</param> /// <param name="path">The path name to search</param> /// <param name="clientContext">The sharepoint client context object</param> /// <returns></returns> public static TermCollection GetTermsByPath(this TermSet termSet, String path, ClientContext clientContext) { TermCollection termCollection = termSet.GetAllTerms(); TermCollection termCollectionToReturn = null; clientContext.Load(termCollection, tc => tc.Include( t => t.Name, t => t.PathOfTerm, t => t.TermsCount )); clientContext.ExecuteQuery(); foreach (Term term in termCollection) { if (term.PathOfTerm == path) { //Get all the terms under that path if (term.TermsCount > 0) { termCollectionToReturn = term.LoadTerms(clientContext); } } } return(termCollectionToReturn); }
private static void RecursiveTermManagement(XElement elt, TermCollection collectionTerm) { foreach (Term term in collectionTerm) { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Exporting XML Term [" + term.Name + "]"); XElement __childEl = new XElement("Term", string.Empty); __childEl.Add(new XAttribute("name", term.Name)); __childEl.Add(new XAttribute("id", term.Id)); __childEl.Add(new XAttribute("language", term.TermSet.Group.TermStore.Languages[0])); foreach (Label lbl in term.Labels) { XElement __labelEl = new XElement("Label", string.Empty); __labelEl.Add(new XAttribute("name", lbl.Value)); __labelEl.Add(new XAttribute("language", lbl.Language)); __labelEl.Add(new XAttribute("isdefault", lbl.IsDefaultForLanguage)); __childEl.Add(__labelEl); } elt.Add(__childEl); if (term.TermsCount > 0) XmlExport.RecursiveTermManagement(__childEl, term.Terms); } }
public static void CreateNewOrder(ClientContext ctx, Order order) { List list = ctx.Web.GetListByTitle("Customer Orders"); ListItem item = list.AddItem(new ListItemCreationInformation()); item["SW_Customer"] = order.Customer; item["SW_AmountMoney"] = order.Amount; item.Update(); TermCollection termCollection = OrderListHelper.GetTaxonomyTermSet(ctx); List <KeyValuePair <Guid, String> > products_ordered = new List <KeyValuePair <Guid, string> >(); foreach (var termItem in termCollection) { foreach (var productItem in order.Products) { if (termItem.Name.ToString() == productItem) { products_ordered.Add(new KeyValuePair <Guid, string>(termItem.Id, termItem.Name.ToString())); } } } item.SetTaxonomyFieldValues("{854C4414-A6AB-46B2-A18B-D8BD4C46E960}".ToGuid(), products_ordered); ctx.ExecuteQuery(); }
private void ProcessTerms(ClientContext context, TermCollection terms, int indentLevel) { if (terms != null && terms.Count > 0) { WriteOutput("<Terms>"); foreach (var term in terms) { context.Load(term, t => t.Id, t => t.Name, t => t.TermSet.Id, t => t.TermSet.Name, t => t.TermSet.Group.Id, t => t.TermSet.Group.Name ); context.ExecuteQueryRetry(); WriteOutput(string.Format("<Term Name=\"{0}\" Id=\"{1}\"></Term>", term.Name, term.Id)); context.Load(term.Terms); context.ExecuteQueryRetry(); if (term.Terms != null && term.Terms.Count > 0) { ProcessTerms(context, term.Terms, (indentLevel + 1)); } } WriteOutput("</Terms>"); } }
public SpRulesDataSet Import() { try { var data = new SpRulesDataSet(); using (var spClientContext = CreateClientContext(_appSettings)) { _termColl = initTermCollection(spClientContext); LoadCategories(data, spClientContext); LoadPages(data, spClientContext); CullEmptyCategories(data); ScrapeHomePage(data).GetAwaiter().GetResult(); ScrapeCategoryPages(data).GetAwaiter().GetResult(); ScrapeCategoryPages(data, true).GetAwaiter().GetResult(); LoadUrlTerms(data, spClientContext); } return(data); } catch (Exception ex) { _log.LogError(ex, "error importing from sharepoint"); throw; } }
public AweCsomeTag Search(TaxonomyTypes taxonomyType, string termSetName, string groupName, string query) { GetTermSet(taxonomyType, termSetName, groupName, false, out TermStore termStore, out TermSet termSet); TermCollection allTerms = termSet.Terms; _clientContext.Load(termSet, q => q.Name); _clientContext.Load(allTerms); _clientContext.ExecuteQuery(); var rootTag = new AweCsomeTag { Children = new List <AweCsomeTag>(), Name = termSet.Name, Id = termSet.Id, TermStoreName = termStore.Name }; foreach (var term in allTerms) { rootTag.Children.Add(GetTermChildren(term, rootTag)); } if (query != null) { SearchInsideTaxonomy(rootTag, query); } return(rootTag); }
private void ProcessTerms(ClientContext context, TermCollection terms, int indentLevel) { if (terms != null && terms.Count > 0) { foreach (var term in terms) { context.Load(term, t => t.Id, t => t.Name, t => t.TermSet.Id, t => t.TermSet.Name, t => t.TermSet.Group.Id, t => t.TermSet.Group.Name ); context.ExecuteQueryRetry(); WriteOutput(string.Format("{0},{1},{2},{3},{4}{5},{6}", term.TermSet.Group.Name, term.TermSet.Group.Id, term.TermSet.Name, term.TermSet.Id, string.Format("{0}", new String(',', (indentLevel * 2))), term.Name, term.Id )); context.Load(term.Terms); context.ExecuteQueryRetry(); if (term.Terms != null && term.Terms.Count > 0) { ProcessTerms(context, term.Terms, (indentLevel + 1)); } } } }
public HtmlTextWriter buildItems(HtmlTextWriter writer, TermCollection terms) { //TermSet termSet = navTerms.GetTaxonomyTermSet(); //if (navTerms.IsNavigationTermSet) if (terms.Count > 0) { Level++; foreach (var term in terms) { try { var navTerm = NavigationTerm.GetAsResolvedByWeb(term, Site.OpenWeb(), StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider); if (navTerm.ExcludeFromGlobalNavigation) { continue; } buildItem(writer, navTerm); } catch (Exception) { } } Level--; } return(writer); }
private static IList <Term> GetTermsForLabelInternal(TermStore termStore, Group termStoreGroup, TermSet termSet, string termLabel) { if (termStore == null) { throw new ArgumentNullException("termStore"); } if (termStoreGroup == null) { throw new ArgumentNullException("termStoreGroup"); } if (termSet == null) { throw new ArgumentNullException("termSet"); } if (string.IsNullOrEmpty(termLabel)) { throw new ArgumentNullException("termLabel"); } TermCollection termCollection = termSet.GetAllTerms(); return(termCollection.Where((term) => { return term.Labels.Any(label => label.Value == termLabel); }).ToList()); }
/// <summary> /// Updates a single-value managed metatada column /// </summary> /// <param name="taxonomyTerm"></param> /// <param name="item"></param> /// <param name="fieldToUpdate"></param> public static void UpdateMMField(string taxonomyTerm, SPListItem item, string fieldToUpdate) { //Get the metadata taxonomy field, a taxonomy session, the term store, and a collection of term sets in the store TaxonomyField managedMetadataField = item.ParentList.Fields[fieldToUpdate] as TaxonomyField; Guid tsId = managedMetadataField.TermSetId; Guid termStoreId = managedMetadataField.SspId; TaxonomySession tSession = new TaxonomySession(item.ParentList.ParentWeb.Site); TermStore tStore = tSession.TermStores[termStoreId]; TermSet tSet = tStore.GetTermSet(tsId); TermCollection terms = tSet.GetTerms(taxonomyTerm, false); Term term = null; //If term doesn't exist, create it in the term store if (terms.Count == 0) { Console.WriteLine("Creating term in managed metadata, {0}", taxonomyTerm); term = tSet.CreateTerm(taxonomyTerm, tStore.Languages[0]); tStore.CommitAll(); } else { term = terms[0]; } //Set the managed metadata field to the term retrieved from the term store managedMetadataField.SetFieldValue(item, term); item.Update(); }
/// <summary> /// This method will check if the term exists and if it exists, it will return the reference to that term /// </summary> /// <param name="termSet">The term set underwhich, the term exists check will happen</param> /// <param name="clientContext">The sharepoint client context object</param> /// <param name="path">The term path under which we need to check for a term existence</param> /// <param name="termNameToRetrieve">The term that needs to be retrieved from a given term</param> /// <param name="term">The term reference that will be returned back to the caller</param> /// <returns></returns> public static bool TermExists(this TermSet termSet, ClientContext clientContext, string termNameToRetrieve, ref Term term) { TermCollection termCollection = termSet.GetAllTerms(); clientContext.Load(termCollection, tc => tc.Include( t => t.Name, t => t.PathOfTerm, t => t.TermsCount, t => t.Parent.Name )); clientContext.ExecuteQuery(); foreach (Term currentTerm in termCollection) { string pathOfTerm = currentTerm.PathOfTerm; //ClientResult<string> pathOfTerm = currentTerm.GetPath(1033); if (currentTerm.Name.ToLower() == termNameToRetrieve.ToLower()) { term = currentTerm; return(true); } } return(false); }
internal static List <SelectListItem> getTaxItems(ClientContext ctx) { List <SelectListItem> items = new List <SelectListItem>(); TermStore store = ctx.Site.GetDefaultKeywordsTermStore(); TermSet tset = store.GetTermSet("{3D4C7DE0-3867-44C3-871A-C36DEC4E1970}".ToGuid()); TermCollection terms = tset.Terms; ctx.Load(terms); ctx.Load(terms, tms => tms.Include(l => l.Labels)); ctx.ExecuteQuery(); foreach (Term t in terms) { SelectListItem item = new SelectListItem(); item.Value = t.Id.ToString(); item.Text = t.Labels.Where(l => l.Language == 1033).FirstOrDefault().Value; items.Add(item); } return(items); }
/// <summary> /// Initializing Client List By Loading TermGroup /// </summary> /// <param name="clientContext">Client Context</param> /// <param name="termGroup">Term Group</param> /// <param name="termSetName">Term Store</param> /// <returns>Client List</returns> public static List <Client> IntializeClientObject(ClientContext clientContext, TermGroup termGroup, string termSetName) { Client client; List <Client> clients = new List <Client>(); TermSet termSet = termGroup.TermSets.GetByName(termSetName); TermCollection termColl = termSet.Terms; clientContext.Load(termColl); // Execute the query to the server clientContext.ExecuteQuery(); foreach (Term term in termColl) { client = new Client(); client.Name = term.Name; foreach (KeyValuePair <string, string> termProperty in term.CustomProperties) { if (termProperty.Key.Equals(Constants.URLDictKey)) { client.Url = termProperty.Value; } } clients.Add(client); } return(clients); }
public static Term GetByName(this TermCollection termSets, string name) { if (String.IsNullOrEmpty(name)) { throw new ArgumentException("Term set name cannot be empty", "name"); } return(termSets.SingleOrDefault(termSet => string.Equals(termSet.Name, name))); }
protected void checkAllButton_OnClick(object sender, EventArgs e) { TermCollection terms = teams.TermSet.Terms; recursivelyUpdateTeams(terms); teams.CommitAll(); }
public string writeTerms(TermCollection terms) { if (terms.Count > 0) { html += "\n<ul class=\"GlobalNav\">\n"; foreach (Term subTerm in terms) { String hoverText = ""; String hyperLink = ""; String imgURL = ""; try { hoverText = (subTerm.LocalCustomProperties["_Sys_Nav_HoverText"] != null) ? subTerm.LocalCustomProperties["_Sys_Nav_HoverText"] : ""; } catch { hoverText = ""; } if (subTerm.CustomProperties.TryGetValue("imgURL", out imgURL)) { try { hyperLink = (subTerm.LocalCustomProperties["_Sys_Nav_SimpleLinkUrl"] != null) ? subTerm.LocalCustomProperties["_Sys_Nav_SimpleLinkUrl"] : "#"; html += "<li><a href=\"" + hyperLink + "\" " + "title=\"" + hoverText + "\">" + "<img src=\"" + imgURL + "\" alt=\"" + subTerm.Name + "\" height=\"150\" width=\"150\"></a>"; writeTerms(subTerm.Terms); html += "</li>\n"; } catch { html += "<li><a href=\"#\">" + subTerm.Name + "</a>"; writeTerms(subTerm.Terms); html += "</li>\n"; } } else { try { hyperLink = (subTerm.LocalCustomProperties["_Sys_Nav_SimpleLinkUrl"] != null) ? subTerm.LocalCustomProperties["_Sys_Nav_SimpleLinkUrl"] : "#"; html += "<li><a href=\"" + hyperLink + "\" " + "title=\"" + hoverText + "\">" + subTerm.Name + "</a>"; writeTerms(subTerm.Terms); html += "</li>\n"; } catch { html += "<li><a href=\"#\">" + subTerm.Name + "</a>"; writeTerms(subTerm.Terms); html += "</li>\n"; } } } html += "</ul>\n"; } return(html); }
public ActionResult BuyAuctions() { var model = new SearchAdvertisementViewModel(); model.FilterList.Add(new SelectListItem { Value = "PriceAsc", Text = "Pris (Stigande)" }); model.FilterList.Add(new SelectListItem { Value = "PriceDesc", Text = "Pris (Fallande)" }); model.FilterList.Add(new SelectListItem { Value = "DateAsc", Text = "Datum (Stigande)" }); model.FilterList.Add(new SelectListItem { Value = "DateDesc", Text = "Datum (Fallande)" }); SharePointContext spContext = Session["SpContext"] as SharePointContext; using (var clientContext = spContext.CreateUserClientContextForSPHost()) { TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext); if (taxonomySession != null) { TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); TermGroupCollection termGroupCol = termStore.Groups; clientContext.Load(termGroupCol, t => t.Where(y => y.Name == "Advertisements")); clientContext.ExecuteQuery(); TermGroup termGroup = termGroupCol.FirstOrDefault(); if (termGroup != null) { TermSet termSet = termGroup.TermSets.GetByName("Categories"); TermCollection terms = termSet.GetAllTerms(); clientContext.Load(termSet); clientContext.Load(terms); clientContext.ExecuteQuery(); foreach (Term term in terms) { SelectListItem newItem = new SelectListItem { Value = term.Name, Text = term.Name }; model.CategoryList.Add(newItem); } } } } model.CategoryList.OrderBy(x => x.Text); model.CategoryList.Insert(0, new SelectListItem { Value = "Alla", Text = "Alla" }); return(View(model)); }
// Update the objects in the Taxonomy TermSet to match the objects specified // in the TermSetGoal object that was read from the XML file. static void SyncTermSet(TermSet termSet, TermSetGoal termSetGoal) { // Load the tree of terms as a flat list. Log("Loading terms..."); TermCollection allTerms = termSet.GetAllTerms(); Program.clientContext.Load(allTerms, allTermsArg => allTermsArg.Include(Program.termRetrievals) ); Program.ExecuteQuery(); // WCF CALL #2 Program.itemsById = new Dictionary <Guid, Wrapper>(); Wrapper termSetWrapper = new Wrapper(termSet, termSet.Id, Guid.Empty, termSet.Name); Program.itemsById.Add(termSetWrapper.Id, termSetWrapper); foreach (Term term in allTerms) { Guid parentItemId = termSet.Id; if (!term.Parent.ServerObjectIsNull.Value) { parentItemId = term.Parent.Id; } Program.itemsById.Add(term.Id, new Wrapper(term, term.Id, parentItemId, term.Name)); } foreach (Wrapper wrapper in Program.itemsById.Values) { if (wrapper != termSetWrapper) { Program.itemsById[wrapper.ParentId].ChildTerms.Add(wrapper); } } Log("Step 1: Adds and Moves"); ProcessAddsAndMoves(termSetWrapper, termSetGoal); Log("Step 2: Deletes"); ProcessDeletes(termSetWrapper, termSetGoal); // Step 2 Log("Step 3: Property Updates"); Log("Querying auxiliary data"); foreach (Wrapper wrapper in Program.itemsById.Values) { if (wrapper != termSetWrapper) { wrapper.TermDescription = ((Term)wrapper.Item).GetDescription(Program.lcid); } } Program.ExecuteQuery(); // WCF CALL #3 ProcessPropertyUpdates(termSetWrapper, termSetGoal); // Step 3 Program.ExecuteQuery(); // WCF CALL #4 }
public TermCollectionInstance(ObjectInstance prototype, TermCollection termCollection) : this(prototype) { if (termCollection == null) { throw new ArgumentNullException("termCollection"); } m_termCollection = termCollection; }
private string GetTermIdForTaxonomyField(TaxonomyField field, string term, ListItem pendingItem, Microsoft.SharePoint.Client.File pendingFile) { if (_terms == null) { _terms = new Dictionary <string, IDictionary <string, string> >(); } if (!_terms.Keys.Contains(field.Title)) { _terms[field.Title] = new Dictionary <string, string>(); } if (_terms[field.Title].Keys.Contains(term)) { return(_terms[field.Title][term].ToString()); } var termId = string.Empty; //before we go forward,save pending item pendingItem.Update(); ctx.Load(pendingFile); ctx.ExecuteQuery(); TaxonomySession tSession = TaxonomySession.GetTaxonomySession(ctx); ctx.Load(tSession.TermStores); ctx.ExecuteQuery(); TermStore ts = tSession.TermStores.First(); TermSet tset = ts.GetTermSet(field.TermSetId); LabelMatchInformation lmi = new LabelMatchInformation(ctx); lmi.Lcid = 1033; lmi.TrimUnavailable = true; lmi.TermLabel = term; TermCollection termMatches = tset.GetTerms(lmi); ctx.Load(tSession); ctx.Load(ts); ctx.Load(tset); ctx.Load(termMatches); ctx.ExecuteQuery(); if (termMatches != null && termMatches.Count() > 0) { termId = termMatches.First().Id.ToString(); } _terms[field.Title][term] = termId; return(termId); }
private static List<Product> ParceProducts(TermCollection tc) { List<Product> ret = new List<Product>(); foreach(Term term in tc) { Product p = new Product() { Guid = term.Id.ToString(), Label = term.Name }; ret.Add(p); } return ret; }
private void PopulateListView(WBTaxonomy teams, TermCollection terms) { Literal literal = new Literal(); string html = ""; // tempStyling(); html += addChildTeamsFromTerms(teams, terms); literal.Text = html; this.Controls.Add(literal); }
private void recursivelyUpdateTeams(TermCollection terms) { foreach (Term term in terms) { WBTeam team = new WBTeam(teams, term); team.IndividualCommit = false; team.Update(); recursivelyUpdateTeams(term.Terms); } }
public static TermCollection GetTaxonomyTermSet(ClientContext ctx) { TermStore store = ctx.Site.GetDefaultSiteCollectionTermStore(); TermGroup group = store.GetTermGroupByName("Luis"); TermSet termSet = group.TermSets.GetByName("Products"); TermCollection TermCollection = termSet.Terms; ctx.Load(TermCollection); ctx.ExecuteQuery(); return(TermCollection); }
private TermCollection initTermCollection(ClientContext ctx) { TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(ctx); TermStore termStore = taxonomySession.TermStores.GetByName("Managed Metadata Service"); TermGroup termGroup = termStore.Groups.GetByName("Site Collection - rules.ssw.com.au"); TermSet termSet = termGroup.TermSets.GetByName("Home Navigation"); TermCollection termColl = termSet.Terms; ctx.Load(termColl); ctx.ExecuteQuery(); return(termColl); }
public TermSetLookup(TaxonomyField taxonomyField, TermSet termSet) { this.taxonomyField = taxonomyField; this.terms = termSet.GetAllTerms(); Program.clientContext.Load(this.terms, termsArg => termsArg.Include( termArg => termArg.Id, termArg => termArg.Name ) ); }
internal void PopulateWithFunctionalAreas(WBLocationTreeState treeState, TreeNodeCollection treeNodeCollection, String viewMode, WBTermCollection <WBTerm> teamFunctionalAreas) { bool expandNodes = true; if (teamFunctionalAreas.Count > 2) { expandNodes = false; } List <WBTerm> sortedTerms = new List <WBTerm>(); foreach (WBTerm term in teamFunctionalAreas) { sortedTerms.Add(term); } sortedTerms = sortedTerms.OrderBy(o => o.Name).ToList(); foreach (WBTerm functionalArea in sortedTerms) { SPFolder folder = null; if (viewMode != VIEW_MODE__NEW) { folder = this.Libraries.GetMasterFolderByPath(functionalArea.Name); if (folder == null) { WBLogging.Debug("Couldn't find folder for functional area: " + functionalArea.Name); continue; } } else { WBLogging.Debug("View mode = " + viewMode); } WBFunctionalAreaTreeNode functionalAreaTreeNode = new WBFunctionalAreaTreeNode(functionalArea, folder); TreeNode node = functionalAreaTreeNode.AsTreeNode(); node.Expanded = expandNodes; node.PopulateOnDemand = false; node.SelectAction = TreeNodeSelectAction.Expand; treeNodeCollection.Add(node); WBTaxonomy recordsTypes = this.RecordsTypesTaxonomy; TermCollection terms = recordsTypes.TermSet.Terms; PopulateWithRecordsTypes(treeState, node.ChildNodes, viewMode, folder, functionalArea, recordsTypes, terms); } }
private void AddTerms(TermCollection _termCollection,bool isroot) { LogHelper.Log("Isroot:" + isroot); if (_termCollection.Count() > 0) { foreach (var t in _termCollection) { if (t.CustomProperties.ContainsKey(Constants.AutoTaggable))//redundant in case the whole termset is loaded but no other way { AddLabels(t); // in case of termset. if(!isroot && t.Terms.Count > 0) // in case of subterm { foreach(var tt in t.Terms) { if(tt.CustomProperties.ContainsKey(Constants.AutoTaggable)) { AddLabels(tt); } } } } else { if (!isroot && t.Terms.Count > 0) { foreach (var tt in t.Terms) { if (tt.CustomProperties.ContainsKey(Constants.AutoTaggable)) { AddLabels(tt); } } } } } } }
public TaxonomyTerms(ClientContext ctx, string TermSetId,Guid AnchorId) { bool IsRootTerm = false; LogHelper.Log("Inside TaxonomyTerms termsetid:" + TermSetId); CurrentContext = ctx; _TermsDictionary = new Dictionary<TermKey, string>(); var _taxSession = TaxonomySession.GetTaxonomySession(CurrentContext); var _termStore = _taxSession.GetDefaultSiteCollectionTermStore(); var _termSet = _termStore.GetTermSet(new Guid(TermSetId)); TermCollection _termCollection=null; if(AnchorId == Guid.Empty) { CustomPropertyMatchInformation match = new CustomPropertyMatchInformation(ctx); match.CustomPropertyName = Constants.AutoTaggable; match.CustomPropertyValue = "1"; match.TrimUnavailable = true; match.StringMatchOption = StringMatchOption.ExactMatch; _termCollection = _termSet.GetTermsWithCustomProperty(match); CurrentContext.Load(_termCollection, terms => terms.Include( tt => tt.Id, tt => tt.Labels), terms => terms.Include(tt => tt.CustomProperties)); IsRootTerm = true; } else { //No way to match a property when taking terms of a term. The CustomPropertyMatch...only works when //getting terms from a _termSet. Tried to deal with LoadQuery but no way to query terms based on their properties var _targetTerm = _termSet.GetTerm(AnchorId); _termCollection = _targetTerm.Terms; CurrentContext.Load(_termCollection, terms => terms.Include( tt => tt.Id, tt => tt.Labels, tt => tt.CustomProperties, tt=>tt.Terms,tt=>tt.Terms.Include(ttt=>ttt.Labels))); } if (keywords == null || (DateTime.Now - LastRefreshedKeywords).Minutes > Constants.KeywordIntervalRefresh) { lock (locker) { if (keywords == null || (DateTime.Now - LastRefreshedKeywords).Minutes > Constants.KeywordIntervalRefresh) { keywords = _taxSession.GetDefaultKeywordsTermStore().KeywordsTermSet.GetAllTerms(); ctx.Load(keywords); CurrentContext.ExecuteQuery(); LastRefreshedKeywords = DateTime.Now; LogHelper.Log("Refreshed the keyword list",LogSeverity.Error); } } } else { CurrentContext.ExecuteQuery(); } LogHelper.Log("Inside TaxonomyTerms " + _termCollection.Count); AddTerms(_termCollection, IsRootTerm); }
private void CreateStackOTerms(Stack<Tuple<string, Guid>> rowStack, TermCollection allTerms, TermSet termSet) { var arrayStack = rowStack.ToArray(); for(int x = 0; x < arrayStack.Length; ++x) { var currentItem = arrayStack[x]; if(currentItem.Item2 == Guid.Empty) { var newGuid = Guid.NewGuid(); if (x != 0) { var previousTermId = arrayStack[x - 1].Item2; var previousTerm = allTerms.FirstOrDefault(o=>o.Id == previousTermId); //termSet.Context.Load(previousTerm); if (previousTerm.IsReused && previousTerm.IsSourceTerm == false) { // get term var sourceTerm = previousTerm.SourceTerm; termSet.Context.Load(sourceTerm, sc=>sc.Id, sc => sc.Terms, sc => sc.Terms.Include(t => t.Name, t => t.Id)); termSet.Context.ExecuteQuery(); var sourceNewTerm = sourceTerm.Terms.FirstOrDefault(trm => trm.Name == currentItem.Item1); // not in the original either if (sourceNewTerm == null) { // add new term var newTerm = sourceTerm.CreateTerm(currentItem.Item1, 1033, newGuid); // reuse it in the term-set we are iterating previousTerm.ReuseTerm(newTerm, false); } else{ previousTerm.ReuseTerm(sourceNewTerm, false); newGuid = sourceNewTerm.Id; } } else { previousTerm.CreateTerm(currentItem.Item1, 1033, newGuid); } } else { // Create a new term at the root of the termset termSet.CreateTerm(currentItem.Item1, 1033, newGuid); } arrayStack[x] = Tuple.Create(currentItem.Item1, newGuid); allTerms = termSet.GetAllTerms(); termSet.Context.Load(allTerms, ax => ax.Include(t => t.Terms, t => t.PathOfTerm, t => t.IsReused, t => t.SourceTerm, t => t.IsSourceTerm, t => t.IsPinned, t => t.Name, t => t.Id, t => t.Parent, t => t.PathOfTerm, t => t.Parent.Name, t => t.Parent.Id)); termSet.Context.ExecuteQuery(); } } }
/// <summary> /// This method will get all client term properties such as ID and URL /// </summary> /// <param name="termColl">The taxonomy client terms</param> /// <param name="termStoreDetails">The term store details which the UI has sent to the clients</param> /// <param name="clientTermSet">The ClientTermSets object to which all the client terms are added</param> /// <returns></returns> private ClientTermSets GetClientTermProperties(TermCollection termColl, TermStoreDetails termStoreDetails, ClientTermSets clientTermSet) { try { foreach (Term term in termColl) { Client tempTermPG = new Client(); tempTermPG.Name = term.Name; if (term.CustomProperties.Count > 0) { tempTermPG.Url = string.Empty; tempTermPG.Id = string.Empty; foreach (KeyValuePair<string, string> customProperty in term.CustomProperties) { if (customProperty.Key.Equals(termStoreDetails.CustomPropertyName, StringComparison.Ordinal)) { tempTermPG.Url = customProperty.Value; } if (customProperty.Key.Equals(taxonomySettings.ClientCustomPropertiesId, StringComparison.Ordinal)) { tempTermPG.Id = customProperty.Value; } } } if(!string.IsNullOrWhiteSpace(tempTermPG.Id) && !string.IsNullOrWhiteSpace(tempTermPG.Url)) { clientTermSet.ClientTerms.Add(tempTermPG); } } return clientTermSet; } catch (Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// Method to get client terms /// </summary> /// <param name="clientDetails">client term sets</param> /// <param name="clientIdProperty">client id property</param> /// <param name="clientUrlProperty">client url property</param> /// <param name="fillteredTerms">term collection</param> private static void GetClientTerms(ClientTermSets clientDetails, string clientIdProperty, string clientUrlProperty, TermCollection fillteredTerms) { Client client; foreach (Term term in fillteredTerms) { if (term.CustomProperties.ContainsKey(clientIdProperty) && term.CustomProperties.ContainsKey(clientUrlProperty)) { client = new Client(); client.ClientName = term.Name; client.ClientId = term.CustomProperties[clientIdProperty]; client.ClientUrl = term.CustomProperties[clientUrlProperty]; clientDetails.ClientTerms.Add(client); } } }
/// <summary> /// Method to get client term sets /// </summary> /// <param name="fillteredTerms">term collection</param> /// <param name="clientIdProperty">client id property</param> /// <param name="clientPropertyName">client property name</param> /// <returns>returns client term sets</returns> private static ClientTermSets GetClientTermSets(TermCollection fillteredTerms, string clientIdProperty, string clientPropertyName) { ClientTermSets clientDetails = new ClientTermSets(); clientDetails.ClientTerms = new List<Client>(); foreach (Term term in fillteredTerms) { if (term.CustomProperties.ContainsKey(clientIdProperty) && term.CustomProperties.ContainsKey(clientPropertyName)) { Client client = new Client(); client.ClientName = term.Name; client.ClientId = term.CustomProperties[clientIdProperty]; client.ClientUrl = term.CustomProperties[clientPropertyName]; clientDetails.ClientTerms.Add(client); } } return clientDetails; }
private static void RecursiveRowManagement(int level, Worksheet sheet, TermCollection collectionTerm) { foreach (Term term in collectionTerm) { WorksheetRow row = sheet.Table.Rows.Add(); for (int i = 0; i < level; i++) { row.Cells.Add(""); } Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Exporting XLS Term [" + term.Name + "]"); foreach (Label lbl in term.Labels) { row.Cells.Add(lbl.Value); row.Cells.Add(new WorksheetCell(lbl.Language.ToString(), DataType.Number)); } if (term.TermsCount > 0) ExcelExport.RecursiveRowManagement(level + 1, sheet, term.Terms); } }
public TaxonomyTerms(ClientContext ctx) { if (keywords == null || (DateTime.Now - LastRefreshedKeywords).Minutes > Constants.KeywordIntervalRefresh) { lock (locker) { if (keywords == null || (DateTime.Now - LastRefreshedKeywords).Minutes > Constants.KeywordIntervalRefresh) { var _taxSession = TaxonomySession.GetTaxonomySession(ctx); keywords = _taxSession.GetDefaultKeywordsTermStore().KeywordsTermSet.GetAllTerms(); ctx.Load(keywords); ctx.ExecuteQuery(); LastRefreshedKeywords = DateTime.Now; LogHelper.Log("Refreshed the keyword list", LogSeverity.Error); } } } }
/// <summary> /// This method will update the taxonomy hierarchy object with custom properties that needs to be send to client. This is a recursive function /// and it will loop until a term does not have any child terms /// </summary> /// <param name="termCollection">The Term Collection object to which terms will be added</param> /// <param name="termStoreDetails">The term store details which the client has sent</param> /// <param name="parentTerm">The parent term from where the custom properties are read and assign to its child terms</param> /// <returns></returns> private void GetChildTermsWithCustomProperties(TermCollection termCollection, TermStoreDetails termStoreDetails, Term parentTerm, JsonWriter jw, string siteColumnName, int termLevelHierarchyPosition) { try { //var subAreaTerms = new List<SubareaTerm>(); foreach (Term term in termCollection) { if (term.Name != taxonomySettings.ClientTermSetName) { jw.WriteStartObject(); jw.WritePropertyName("termName"); jw.WriteValue(term.Name); jw.WritePropertyName("id"); jw.WriteValue(Convert.ToString(term.Id, CultureInfo.InvariantCulture)); jw.WritePropertyName("parentTermName"); jw.WriteValue(parentTerm.Name); jw.WritePropertyName("siteColumnName"); jw.WriteValue(siteColumnName); IDictionary<string, string> childCustomProperties = term.CustomProperties; IDictionary<string, string> parentCustomProperties = parentTerm.CustomProperties; foreach (KeyValuePair<string, string> parentProperty in parentTerm.CustomProperties) { //if the key is present in the parent and not in the child, add that key value to the child custom properties if (!childCustomProperties.Keys.Contains(parentProperty.Key)) { if (parentProperty.Key.Equals(termStoreDetails.CustomPropertyName, StringComparison.Ordinal)) { childCustomProperties.Add(parentProperty.Key, parentProperty.Value); } else if (parentProperty.Key.Equals(taxonomySettings.SubAreaOfLawDocumentTemplates, StringComparison.Ordinal)) { childCustomProperties.Add(parentProperty.Key, parentProperty.Value); } else { childCustomProperties.Add(parentProperty.Key, parentProperty.Value); } } //If the key is present in both and parent and child and if child value is empty and the parent value is not empty, //update the child value with the parent value for the same key if (childCustomProperties.Keys.Contains(parentProperty.Key) && childCustomProperties[parentProperty.Key] == string.Empty) { childCustomProperties[parentProperty.Key] = parentProperty.Value; } } //Add the custom properties to the subAreaTerms list collection foreach (KeyValuePair<string, string> customProperty in childCustomProperties) { if (customProperty.Key.Equals(termStoreDetails.CustomPropertyName, StringComparison.Ordinal)) { jw.WritePropertyName("documentTemplates"); jw.WriteValue(customProperty.Value); } else if (customProperty.Key.Equals(taxonomySettings.SubAreaCustomPropertyFolderNames, StringComparison.Ordinal)) { jw.WritePropertyName("folderNames"); jw.WriteValue(customProperty.Value); } else if (customProperty.Key.Equals(taxonomySettings.SubAreaCustomPropertyisNoFolderStructurePresent, StringComparison.Ordinal)) { jw.WritePropertyName("isNoFolderStructurePresent"); if (generalSettings.IsBackwardCompatible) { if(customProperty.Value.ToLower()==ServiceConstants.IS_FOLDER_STRUCTURE_PRESENT_FALSE.ToLower()) { jw.WriteValue(ServiceConstants.IS_FOLDER_STRUCTURE_PRESENT_TRUE); } else if (customProperty.Value.ToLower() == ServiceConstants.IS_FOLDER_STRUCTURE_PRESENT_TRUE.ToLower()) { jw.WriteValue(ServiceConstants.IS_FOLDER_STRUCTURE_PRESENT_FALSE); } } else { jw.WriteValue(customProperty.Value); } } else if (customProperty.Key.Equals(taxonomySettings.SubAreaOfLawDocumentTemplates, StringComparison.Ordinal)) { jw.WritePropertyName("documentTemplateNames"); jw.WriteValue(customProperty.Value); } } //Increment the level level = level + 1; //Check if we need to get more terms. if (level <= taxonomySettings.Levels) { if (term.TermsCount > 0) { if(level==4) { jw.WritePropertyName(taxonomySettings.Level4Name); } //The app will support upto five level of hierarchy if (level == 5) { jw.WritePropertyName(taxonomySettings.Level5Name); } jw.WriteStartArray(); TermCollection termCollLevel4 = term.LoadTerms(clientContext); siteColumnName = configuration.GetSection("ContentTypes").GetSection("ManagedColumns")["ColumnName"+ level]; //Recursive function which will call it self until a given term does not have any child terms GetChildTermsWithCustomProperties(termCollLevel4, termStoreDetails, term, jw, siteColumnName, termLevelHierarchyPosition); jw.WriteEndArray(); } } jw.WriteEndObject(); } } } catch (Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// To load and execute the Term collection /// </summary> /// <param name="clientContext">Client Context</param> /// <param name="termColl">Term Collection</param> private static void LoadExecute(ClientContext clientContext, TermCollection termColl) { clientContext.Load(termColl, practicegroup => practicegroup.Include( item => item.Name, item => item.Id, item => item.Terms.Include( areaOfLaw => areaOfLaw.Name, areaOfLaw => areaOfLaw.Id, areaOfLaw => areaOfLaw.Terms.Include( subAreaOfLaw => subAreaOfLaw.Name, subAreaOfLaw => subAreaOfLaw.Id, subAreaOfLaw => subAreaOfLaw.CustomProperties ) ) )); // Execute the query to the server clientContext.ExecuteQuery(); }