/// <summary> /// </summary> private void btnCreateTerm_Click(object sender, EventArgs e) { if (MessageBox.Show("Are you sure?", "Confirm", MessageBoxButtons.YesNo) != DialogResult.Yes) { return; } StartWait(); this.Invoke((MethodInvoker) delegate { while (true) { TreeNode curNode = tvMMD.SelectedNode; if (curNode == null) { break; } if (txtTermName.Text.Trim().Length == 0) { cout("Cannot create term, name is required."); break; } Term newTerm = null; try { if (curNode.Level == 2) { // add term to termset TermSet tSet = MMDHelper.GetObj(txtSiteUrl.Text, curNode.Level, curNode) as TermSet; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } if (GenUtil.IsNull(txtNewTermGuid.Text) || txtNewTermGuid.Text.Trim().ToLower() == NewTermGuidLabel.Trim().ToLower() || !GenUtil.IsGuid(txtNewTermGuid.Text)) { newTerm = tSet.CreateTerm(GenUtil.MmdNormalize(txtTermName.Text), CultureInfo.CurrentCulture.LCID); } else { if (!GenUtil.IsGuid(txtNewTermGuid.Text)) { MessageBox.Show("Cannot create term, invalid new term Guid."); break; } else { newTerm = tSet.CreateTerm(GenUtil.MmdNormalize(txtTermName.Text), CultureInfo.CurrentCulture.LCID, new Guid(txtNewTermGuid.Text)); } } } else if (curNode.Level >= 3) { // add term to term Term term = MMDHelper.GetObj(txtSiteUrl.Text, curNode.Level, curNode) as Term; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } if (GenUtil.IsNull(txtNewTermGuid.Text) || txtNewTermGuid.Text.Trim().ToLower() == NewTermGuidLabel.Trim().ToLower() || !GenUtil.IsGuid(txtNewTermGuid.Text)) { newTerm = term.CreateTerm(GenUtil.MmdNormalize(txtTermName.Text), CultureInfo.CurrentCulture.LCID); } else { if (!GenUtil.IsGuid(txtNewTermGuid.Text)) { MessageBox.Show("Cannot create term, invalid new term Guid."); break; } else { newTerm = term.CreateTerm(GenUtil.MmdNormalize(txtTermName.Text), CultureInfo.CurrentCulture.LCID, new Guid(txtNewTermGuid.Text)); } } } else { MessageBox.Show("Cannot create term in current location, select a termset or term."); break; } if (newTerm != null) { newTerm.IsAvailableForTagging = chkTermIsAvailableForTagging.Checked; // labels if (!GenUtil.IsNull(txtTermLabels.Text)) { foreach (string lbl in GenUtil.MmdNormalize(txtTermLabels.Text).Split(new char[] { ';' })) { if (!GenUtil.IsNull(lbl) && lbl.ToLower() != GenUtil.MmdNormalize(newTerm.Name).ToLower()) { newTerm.CreateLabel(lbl, CultureInfo.CurrentCulture.LCID, false); } } } newTerm.TermStore.CommitAll(); // add term to tree TreeNode newNode = new TreeNode(); newNode.Text = string.Format("{0} [0]", GenUtil.MmdDenormalize(newTerm.Name)); newNode.Name = newTerm.Id.ToString(); curNode.Nodes.Add(newNode); curNode.Expand(); cout("New Term Created"); txtNewTermGuid.Text = NewTermGuidLabel; } } catch (Exception ex) { cout("ERROR creating term", ex.Message); } break; } }); StopWait(); }
/// <summary> /// </summary> private void btnUpdateTermSet_Click(object sender, EventArgs e) { StartWait(); this.Invoke((MethodInvoker) delegate { while (true) { TreeNode curNode = tvMMD.SelectedNode; if (curNode == null) { break; } if (txtTermSetName.Text.Trim().Length == 0) { cout("Cannot update termset, name is required."); break; } if (curNode.Level == 2) { TermSet tSet = MMDHelper.GetObj(txtSiteUrl.Text, curNode.Level, curNode) as TermSet; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } try { tSet.Name = GenUtil.MmdNormalize(txtTermSetName.Text.Trim()); tSet.IsAvailableForTagging = chkTermSetIsAvailableForTagging.Checked; tSet.Description = txtTermSetDescription.Text.Trim(); tSet.TermStore.CommitAll(); cout("TermSet Updated"); curNode.Text = string.Format("{1} [{0}]", tSet.Terms.Count, GenUtil.MmdNormalize(txtTermSetName.Text.Trim())); } catch (Exception exc) { cout("ERROR updating termset", exc.Message); } } break; } }); StopWait(); }
/// <summary> /// </summary> private void btnCreateTermSet_Click(object sender, EventArgs e) { if (MessageBox.Show("Are you sure?", "Confirm", MessageBoxButtons.YesNo) != DialogResult.Yes) { return; } StartWait(); this.Invoke((MethodInvoker) delegate { while (true) { TreeNode curNode = tvMMD.SelectedNode; if (curNode == null) { break; } if (txtTermSetName.Text.Trim().Length == 0) { cout("Cannot create termset, name is required."); break; } Group tGroup = null; if (curNode.Level == 1) { // create new termset in group tGroup = MMDHelper.GetObj(txtSiteUrl.Text, curNode.Level, curNode) as Group; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } } else { MessageBox.Show("Cannot create termset in current location, select a group."); break; } if (tGroup != null) { if (tGroup.TermSets.Any(x => GenUtil.MmdNormalize(x.Name).ToLower() == GenUtil.MmdNormalize(txtTermSetName.Text).ToLower())) { cout("Cannot create termset, name not unique."); break; } try { // create new termset TermSet tSet = tGroup.CreateTermSet(GenUtil.MmdNormalize(txtTermSetName.Text.Trim())); tSet.IsAvailableForTagging = chkTermSetIsAvailableForTagging.Checked; tSet.Description = txtTermSetDescription.Text.Trim(); tSet.TermStore.CommitAll(); // add termset to tree TreeNode newNode = new TreeNode(); newNode.Text = string.Format("{0} [0]", GenUtil.MmdDenormalize(tSet.Name)); newNode.Name = tSet.Id.ToString(); curNode.Nodes.Add(newNode); curNode.Expand(); cout("New TermSet Created"); } catch (Exception exc) { cout("ERROR creating termset", exc.Message); } } break; } }); StopWait(); }
/// <summary> /// Load Node details (termstore, group, termset, term) /// </summary> void tvMMD_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) { StartWait(); this.Invoke((MethodInvoker) delegate { while (true) { if (e.Node.Level == 0) { // termstore, load current node detail TermStore tStore = MMDHelper.GetObj(txtSiteUrl.Text, e.Node.Level, e.Node) as TermStore; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } txtTermStoreId.Text = tStore.Id.ToString(); txtTermStoreName.Text = tStore.Name ?? ""; txtCurSelNode.Text = tStore.Name; // select tab tabControl1.SelectTab(tabTermStore); } else if (e.Node.Level == 1) { // termgroup, load current node detail Group tGroup = MMDHelper.GetObj(txtSiteUrl.Text, e.Node.Level, e.Node) as Group; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } txtTermGroupId.Text = tGroup.Id.ToString(); txtTermGroupName.Text = tGroup.Name ?? ""; txtTermGroupDescr.Text = tGroup.Description ?? ""; txtCurSelNode.Text = tGroup.Name; // select tab tabControl1.SelectTab(tabGroup); } else if (e.Node.Level == 2) { // termset TermSet tSet = MMDHelper.GetObj(txtSiteUrl.Text, e.Node.Level, e.Node) as TermSet; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } txtTermSetCustomSortOrder.Text = tSet.CustomSortOrder; txtTermSetDescription.Text = tSet.Description; txtTermSetId.Text = tSet.Id.ToString(); chkTermSetIsAvailableForTagging.Checked = tSet.IsAvailableForTagging; txtTermSetIsOpenForTermCreation.Text = tSet.IsOpenForTermCreation.ToString(); txtTermSetLastModifiedDate.Text = tSet.LastModifiedDate.ToString(); txtTermSetName.Text = GenUtil.MmdDenormalize(tSet.Name); txtCurSelNode.Text = tSet.Name; // select tab tabControl1.SelectTab(tabTermSet); } else if (e.Node.Level >= 3) { // term Term term = MMDHelper.GetObj(txtSiteUrl.Text, e.Node.Level, e.Node) as Term; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } txtTermCreatedDate.Text = term.CreatedDate.ToString(); txtTermCustomSortOrder.Text = term.CustomSortOrder; txtTermId.Text = term.Id.ToString(); chkTermIsAvailableForTagging.Checked = term.IsAvailableForTagging; chkTermIsKeyword.Checked = term.IsKeyword; chkTermIsReused.Checked = term.IsReused; chkTermIsRoot.Checked = term.IsRoot; chkTermIsSourceTerm.Checked = term.IsSourceTerm; txtTermLabels.Text = GenUtil.MmdDenormalize(GenUtil.LabelsToString(term.Labels, term.Name)); txtTermLastModifiedDate.Text = term.LastModifiedDate.ToString(); txtTermName.Text = GenUtil.MmdDenormalize(term.Name); txtTermTermsCount.Text = term.TermsCount.ToString(); txtCurSelNode.Text = term.Name; // select tab tabControl1.SelectTab(tabTerm); txtNewTermGuid.Text = NewTermGuidLabel; } break; } }); StopWait(); }
/// <summary> /// </summary> private void btnUpdateTerm_Click(object sender, EventArgs e) { StartWait(); this.Invoke((MethodInvoker) delegate { while (true) { TreeNode curNode = tvMMD.SelectedNode; if (curNode == null) { break; } if (txtTermName.Text.Trim().Length == 0) { cout("Cannot update term, name is required."); break; } if (curNode.Level >= 3) { Term term = MMDHelper.GetObj(txtSiteUrl.Text, curNode.Level, curNode) as Term; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } try { // term labels string ignoreTermName = GenUtil.MmdNormalize(txtTermName.Text); List <string> lstNewLabels = GenUtil.MmdNormalize(txtTermLabels.Text).Split(new char[] { ';' }).ToList(); // delete existing labels (if label in collection not found in textbox) int i = 0; while (i < term.Labels.Select(x => x.Value).ToList().Count()) { var curLbl = term.Labels[i]; var curLblVal = GenUtil.MmdNormalize(curLbl.Value); if (curLblVal.ToLower() != ignoreTermName.ToLower() && !lstNewLabels.Any(x => x.Trim().ToLower() == curLblVal.ToLower()) && !curLbl.IsDefaultForLanguage) { curLbl.Delete(); } else { i++; } } // add new labels (if label in textbox not found in collection) foreach (var lblNew in lstNewLabels) { if (!GenUtil.IsNull(lblNew) && lblNew.Trim().ToLower() != ignoreTermName.ToLower() && !term.Labels.Any(x => GenUtil.MmdNormalize(x.Value).ToLower() == lblNew.ToLower())) { term.CreateLabel(lblNew.Trim(), CultureInfo.CurrentCulture.LCID, false); } } term.IsAvailableForTagging = chkTermIsAvailableForTagging.Checked; term.Name = GenUtil.MmdNormalize(txtTermName.Text); term.TermStore.CommitAll(); curNode.Text = string.Format("{1} [{0}]", term.TermsCount, GenUtil.MmdNormalize(txtTermName.Text)); cout("Term Updated"); } catch (Exception exc) { cout("ERROR updating term", exc.Message); } } break; } }); StopWait(); }
/// <summary> /// Recursive writer of terms /// </summary> private static void WriteTerm(string termStoreName, string groupName, string termSetName, Term term, int level, bool splitLevels) { string id = GenUtil.CSVer(term.Id.ToString()); string name = GenUtil.CSVer(term.Name); // get labels //List<string> lstLabels = term.Labels.Where(x => x.Value != term.Name).Select(x => GenUtil.CSVer(x.Value)).ToList<string>(); //string labels = string.Join(",", lstLabels.ToArray<string>()); //if (term.Labels.Count <= 0) // labels = ""; // get parent Term termParent = term.Parent; string termParentId = "null"; string termParentName = "null"; if (termParent != null) { termParentId = GenUtil.CSVer(termParent.Id.ToString()); termParentName = GenUtil.CSVer(termParent.Name); } if (splitLevels) { foreach (Microsoft.SharePoint.Taxonomy.Label lbl in term.Labels) { sbOutput.Append(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}" + Environment.NewLine, termStoreName, groupName, GenUtil.MmdDenormalize(termSetName), level.ToString(), termParentId, GenUtil.MmdDenormalize(termParentName), id, GenUtil.MmdDenormalize(GenUtil.CSVer(term.Name)), GenUtil.MmdDenormalize(GenUtil.CSVer(lbl.Value)), lbl.IsDefaultForLanguage.ToString() )); } } else { // get labels, not including termname (default label) //var lstLabels = term.Labels.Where(x => x.Value != term.Name).Select(x => GenUtil.CSVer(x.Value)).ToList<string>(); var lstLabels = term.Labels.Where(x => !x.IsDefaultForLanguage).Select(x => GenUtil.CSVer(x.Value)).ToList <string>(); string labels = string.Join(",", lstLabels.ToArray <string>()); if (term.Labels.Count <= 0) { labels = ""; } sbOutput.Append(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8}" + Environment.NewLine, termStoreName, groupName, GenUtil.MmdDenormalize(termSetName), level.ToString(), termParentId, GenUtil.MmdDenormalize(termParentName), id, GenUtil.MmdDenormalize(name), GenUtil.MmdDenormalize(labels))); } if (term.Terms.Count > 0) { level++; foreach (Term childTerm in term.Terms) { WriteTerm(termStoreName, groupName, termSetName, childTerm, level, splitLevels); } } }
/// <summary> /// </summary> private void btnBulkMergeTerms_Click(object sender, EventArgs e) { StartWait(); if (tbBulkMergeTerms.Text.IsNull()) { return; } this.Invoke((MethodInvoker) delegate { while (true) { TreeNode curNode = tvMMD.SelectedNode; if (curNode == null) { break; } if (curNode.Level != 2) { cout("Choose a termset."); break; } try { var termSet = MMDHelper.GetObj(txtSiteUrl.Text, curNode.Level, curNode) as TermSet; if (!string.IsNullOrEmpty(MMDHelper.errMsg)) { cout("ERROR", MMDHelper.errMsg); break; } if (termSet == null) { cout("ERROR", "Termset not found."); break; } var newTerms = GenUtil.NormalizeEol(tbBulkMergeTerms.Text.Trim()) .Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries) .Where(x => x.Trim().Length > 0) .Distinct() .ToList <string>(); bool termsAdded = false; foreach (var newTerm in newTerms) { var termSearchResults = termSet.GetTerms(newTerm.Trim(), false, StringMatchOption.ExactMatch, 1, false); if (termSearchResults.Any()) { cout(string.Format("Term found, skipping: {0}", newTerm.Trim())); } else { cout(string.Format("Term not found, creating new term: {0}", newTerm.Trim())); try { var termCreated = termSet.CreateTerm(newTerm.Trim(), CultureInfo.CurrentCulture.LCID); termsAdded = true; } catch (Exception ex) { cout("ERROR creating new term: " + ex.Message); } } } if (termsAdded) { termSet.TermStore.CommitAll(); } } catch (Exception exc) { cout("ERROR Bulk Merging Terms", exc.Message); } break; // #important } }); StopWait(); }
/// <summary> /// Currently ignores any selected terms or subterms to base export on. /// </summary> private static void ExportToCsv( string fileName, string siteUrl, Guid?termStoreId, Guid?groupId, Guid?termSetId, SortedList <int, Guid> slTerms, bool splitLevels = false ) { sbOutput = new StringBuilder(""); if (splitLevels) { sbOutput.Append(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}" + Environment.NewLine, GenUtil.CSVer("termStoreName"), GenUtil.CSVer("groupName"), GenUtil.CSVer("termSetName"), GenUtil.CSVer("level"), GenUtil.CSVer("parentId"), GenUtil.CSVer("parentName"), GenUtil.CSVer("termId"), GenUtil.CSVer("termName"), GenUtil.CSVer("termLabel"), GenUtil.CSVer("isDefaultLabel") )); } else { sbOutput.Append(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8}" + Environment.NewLine, GenUtil.CSVer("termStoreName"), GenUtil.CSVer("groupName"), GenUtil.CSVer("termSetName"), GenUtil.CSVer("level"), GenUtil.CSVer("parentId"), GenUtil.CSVer("parentName"), GenUtil.CSVer("termId"), GenUtil.CSVer("termName"), GenUtil.CSVer("termLabels"))); } using (SPSite site = new SPSite(siteUrl)) { TaxonomySession txsn = new TaxonomySession(site, true); foreach (TermStore _curTermStore in txsn.TermStores) { if (termStoreId != null && _curTermStore.Id != termStoreId) { continue; } foreach (Group _curGroup in _curTermStore.Groups) { if (groupId != null && _curGroup.Id != groupId) { continue; } foreach (TermSet _curTermSet in _curGroup.TermSets) { if (termSetId != null && _curTermSet.Id != termSetId) { continue; } foreach (Term _curTerm in _curTermSet.Terms) { WriteTerm(_curTermStore.Name, _curGroup.Name, _curTermSet.Name, _curTerm, 1, splitLevels); } } } } } FileStream fs = new FileStream(fileName, FileMode.Create); StreamWriter writer = new StreamWriter(fs); writer.Write(sbOutput.ToString()); writer.Close(); fs.Close(); }
/// <summary> /// </summary> public static string ProcessXml(string xml, Group tGroup, TreeNode curNode) { var retMsg = ""; XElement xTree = null; try { // load xml xTree = XElement.Load(new StringReader(xml)); } catch (Exception ex) { return(ex.Message); } foreach (var termSetElement in xTree.XPathSelectElements("/termset")) { string newTermSetName = GenUtil.MmdNormalize(GenUtil.SafeXmlAttributeToString(termSetElement, "name")); Guid newTermSetId = GenUtil.SafeXmlAttributeToGuid(termSetElement, "id"); bool newTermSetIsAvailForTagging = GenUtil.SafeXmlAttributeToBool(termSetElement, "isavailfortagging"); string newTermDescr = GenUtil.SafeXmlAttributeToString(termSetElement, "description"); bool newTermSetIsOpenForTermCreation = GenUtil.SafeXmlAttributeToBool(termSetElement, "isopenfortermcreation"); if (GenUtil.IsNull(newTermSetName)) { return("TermSet name is missing."); } // create termset (or update if found) TermSet tSet = null; try { tSet = tGroup.TermStore.GetTermSet(newTermSetId); if (tSet != null) { // termset found using guid tSet.Name = newTermSetName; tSet.Description = newTermDescr; tSet.IsAvailableForTagging = newTermSetIsAvailForTagging; tSet.IsOpenForTermCreation = newTermSetIsOpenForTermCreation; tSet.TermStore.CommitAll(); } else { tSet = tGroup.TermStore.GetTermSets(newTermSetName, CultureInfo.CurrentCulture.LCID).FirstOrDefault(); if (tSet != null) { // termset found using name tSet.Description = newTermDescr; tSet.IsAvailableForTagging = newTermSetIsAvailForTagging; tSet.IsOpenForTermCreation = newTermSetIsOpenForTermCreation; tSet.TermStore.CommitAll(); } else { tSet = tGroup.CreateTermSet(newTermSetName, newTermSetId, CultureInfo.CurrentCulture.LCID); tSet.Description = newTermDescr; tSet.IsAvailableForTagging = newTermSetIsAvailForTagging; tSet.IsOpenForTermCreation = newTermSetIsOpenForTermCreation; tSet.TermStore.CommitAll(); } } } catch (Exception ex) { return(ex.Message); } // create terms within (recursive) try { foreach (var termElement in termSetElement.XPathSelectElements("term")) { ProcessTerm(termElement, tSet, null); } } catch (Exception ex) { return(ex.Message); } } return(retMsg); }
/// <summary> /// </summary> private static void ProcessTerm(XElement termElement, TermSet tSet, Term term) { string newTermName = GenUtil.MmdNormalize(GenUtil.SafeXmlAttributeToString(termElement, "name")); Guid? newTermId = GenUtil.SafeXmlAttributeToGuidOrNull(termElement, "id"); bool newTermIsAvailForTagging = GenUtil.SafeXmlAttributeToBool(termElement, "isavailfortagging"); string newTermDescr = GenUtil.SafeXmlAttributeToString(termElement, "description"); bool newTermReuse = GenUtil.SafeXmlAttributeToBool(termElement, "reuse"); bool newTermReuseBranch = GenUtil.SafeXmlAttributeToBool(termElement, "reusebranch"); if (GenUtil.IsNull(newTermName)) { throw new Exception("Term name is empty."); } // create term (or get existing term to update, or reuse term) Term newTerm = null; bool termExists = true; bool termIsReused = false; if (tSet != null) { // termset passed to function, the term being worked on is a level 0 term in a termset if (newTermReuse && newTermId != null) { // try to reuse term using termguid newTerm = tSet.TermStore.GetTerm((Guid)newTermId); if (newTerm != null) { // resuse term newTerm = tSet.ReuseTerm(newTerm, newTermReuseBranch); termIsReused = true; newTerm.TermStore.CommitAll(); } } if (!termIsReused) { if (newTermId != null) { // try to get term based on guid newTerm = tSet.TermStore.GetTerm((Guid)newTermId); } if (newTermId == null) { // try to get term based on name try { newTerm = tSet.Terms[newTermName]; } catch { newTerm = null; } } if (newTerm == null) { // create new term newTerm = tSet.CreateTerm(newTermName, CultureInfo.CurrentCulture.LCID, (newTermId == null ? Guid.NewGuid() : (Guid)newTermId)); termExists = false; } } } else { // termset not passed to function, term being worked on is a level n term in a termset (term within term) if (newTermReuse && newTermId != null) { // try to reuse term using termguid newTerm = term.TermStore.GetTerm((Guid)newTermId); if (newTerm != null) { // resuse term newTerm = term.ReuseTerm(newTerm, newTermReuseBranch); termIsReused = true; newTerm.TermStore.CommitAll(); } } if (!termIsReused) { if (newTermId != null) { // try to get term based on guid newTerm = term.TermSet.GetTerm((Guid)newTermId); } if (newTermId == null) { try { newTerm = term.Terms[newTermName]; } catch { newTerm = null; } // try to get term based on name //foreach (var termFound in term.TermSet.GetTerms(newTermName, false)) //{ // if (termFound.Parent.Name.Trim().ToLower() == termElement.Parent.Attribute("name").Value.Trim().ToLower()) // { // newTerm = termFound; // } //} //newTerm = term.TermSet.GetTerms(newTermName, false).FirstOrDefault(); //newTerm = term.GetTerms(newTermName, CultureInfo.CurrentCulture.LCID, true, StringMatchOption.ExactMatch, 1, false).FirstOrDefault(); } if (newTerm == null) { // create new term newTerm = term.CreateTerm(newTermName, CultureInfo.CurrentCulture.LCID, (newTermId == null ? Guid.NewGuid() : (Guid)newTermId)); termExists = false; } } } // update term properties (not if being reused) if (!termIsReused) { // term not reused if (newTerm == null) { throw new Exception("Term not found."); } newTerm.IsAvailableForTagging = newTermIsAvailForTagging; if (!GenUtil.IsNull(newTermDescr)) { newTerm.SetDescription(newTermDescr, CultureInfo.CurrentCulture.LCID); } // reset labels/synonyms if (termExists) { int i = 0; while (i < newTerm.Labels.Count) { if (!newTerm.Labels[i].IsDefaultForLanguage) { newTerm.Labels[i].Delete(); } else { i++; } } } // recreate term labels foreach (var termLabel in termElement.XPathSelectElements("label")) { var lbl = GenUtil.MmdNormalize(GenUtil.SafeXmlAttributeToString(termLabel, "name")); if (!GenUtil.IsNull(lbl) && lbl != newTermName) { newTerm.CreateLabel(lbl, CultureInfo.CurrentCulture.LCID, false); } } newTerm.TermStore.CommitAll(); } if (termIsReused && newTermReuseBranch) { // quit if term is reused and using existing term branch return; } // continue processing subterms foreach (var subTermElement in termElement.XPathSelectElements("term")) { ProcessTerm(subTermElement, null, newTerm); } }
/// <summary> /// </summary> public static string MmdDenormalize(object o) { return(GenUtil.SafeTrim(o) .Replace(Convert.ToChar(char.ConvertFromUtf32(65286)), '&') .Replace(Convert.ToChar(char.ConvertFromUtf32(65282)), '"')); }
/// <summary> /// </summary> public static string MmdNormalize(object o) { return(TermSetItem.NormalizeName(GenUtil.SafeTrim(o))); }