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