/// <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)));
}
