static void CreateNavigationTermSet(Group group, string name)
{
TermSet termSet = null;
try
{
termSet = group.TermSets[name];
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
if (termSet == null)
{
//creamos el termSet
termSet = group.CreateTermSet(name);
termSet.Description = name;
termSet.IsAvailableForTagging = true;
termSet.IsOpenForTermCreation = true;
// set properties
termSet.SetCustomProperty("_Sys_Nav_IsNavigationTermSet", "True");
termSet.TermStore.CommitAll();
}
}
private static void MapTermSet(TermSet currentTermSet, TaxonomyTermSetDefinition termSetModel)
{
if (!string.IsNullOrEmpty(termSetModel.Description))
{
currentTermSet.Description = termSetModel.Description;
}
if (!string.IsNullOrEmpty(termSetModel.Contact))
{
currentTermSet.Contact = termSetModel.Contact;
}
if (!string.IsNullOrEmpty(termSetModel.CustomSortOrder))
{
currentTermSet.CustomSortOrder = termSetModel.CustomSortOrder;
}
if (termSetModel.IsOpenForTermCreation.HasValue)
{
currentTermSet.IsOpenForTermCreation = termSetModel.IsOpenForTermCreation.Value;
}
if (termSetModel.IsAvailableForTagging.HasValue)
{
currentTermSet.IsAvailableForTagging = termSetModel.IsAvailableForTagging.Value;
}
#if !NET35
foreach (var customProp in termSetModel.CustomProperties.Where(p => p.Override))
{
currentTermSet.SetCustomProperty(customProp.Name, customProp.Value);
}
#endif
}
private static void CreateTermSetAndTerms(ClientContext clientContext, XElement termSetElement, TermGroup termGroup)
{
clientContext.Load(termGroup.TermSets); clientContext.ExecuteQuery();
string termSetElementName = termSetElement.Attribute("Name").Value;
string termSetElementGuid = termSetElement.Attribute("ID").Value;
TermSet termSet = termGroup.TermSets.FirstOrDefault(e => e.Name.Equals(termSetElementName) == true);
if (termSet == null)
{
termSet = termGroup.CreateTermSet(termSetElementName, new Guid(termSetElementGuid), 1033);
}
bool isNavTermSet = Convert.ToBoolean(termSetElement.Attribute("IsForSiteNav").Value);
if (isNavTermSet)
{
//set term set to work for site navigation
termSet.SetCustomProperty("_Sys_Nav_IsNavigationTermSet", "True");
}
clientContext.Load(termSet); clientContext.Load(termSet.Terms); clientContext.ExecuteQuery();
foreach (XElement termElement in termSetElement.Elements())
{
#region set properties for each Term
string termElementName = termElement.Attribute("Name").Value;
Term term = termSet.Terms.FirstOrDefault(e => e.Name.Equals(termElementName) == true);
if (term == null)
{
term = termSet.CreateTerm(termElementName, 1033, Guid.NewGuid());
}
//clientContext.Load(term); clientContext.ExecuteQuery();
if (termElement.Attribute("NavNodeTitle").Value.Length > 0)
{
term.SetLocalCustomProperty("_Sys_Nav_Title", termElement.Attribute("NavNodeTitle").Value);
}
bool showinGlobal = Convert.ToBoolean(termElement.Attribute("ShowinGlobal").Value);
bool showinLocal = Convert.ToBoolean(termElement.Attribute("ShowinLocal").Value);
if (!showinGlobal || !showinLocal)
{
if (!showinGlobal && !showinLocal)
{
term.SetLocalCustomProperty("_Sys_Nav_ExcludedProviders", String.Concat("GlobalNavigationTaxonomyProvider", ",", "CurrentNavigationTaxonomyProvider"));
}
if (!showinGlobal)
{
term.SetLocalCustomProperty("_Sys_Nav_ExcludedProviders", "\"GlobalNavigationTaxonomyProvider\"");
}
else
{
term.SetLocalCustomProperty("_Sys_Nav_ExcludedProviders", "\"CurrentNavigationTaxonomyProvider\"");
}
}
if (termElement.Attribute("NavNodeSimpleLink").Value.Length > 0)
{
term.SetLocalCustomProperty("_Sys_Nav_SimpleLinkUrl", termElement.Attribute("NavNodeSimpleLink").Value);
}
if (termElement.Attribute("termFriendlyURLLink").Value.Length > 0)
{
term.SetLocalCustomProperty("_Sys_Nav_FriendlyUrlSegment", termElement.Attribute("termFriendlyURLLink").Value);
}
if (termElement.Attribute("NavTargetURL").Value.Length > 0)
{
term.SetLocalCustomProperty("_Sys_Nav_TargetUrl", termElement.Attribute("NavTargetURL").Value);
}
clientContext.Load(term); clientContext.ExecuteQuery();
#endregion
}
}
public override TokenParser ProvisionObjects(Web web, Model.ProvisioningTemplate template, TokenParser parser,
ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
this.reusedTerms = new List <ReusedTerm>();
TaxonomySession taxSession = TaxonomySession.GetTaxonomySession(web.Context);
TermStore termStore = null;
TermGroup siteCollectionTermGroup = null;
try
{
termStore = taxSession.GetDefaultKeywordsTermStore();
web.Context.Load(termStore,
ts => ts.Languages,
ts => ts.DefaultLanguage,
ts => ts.Groups.Include(
tg => tg.Name,
tg => tg.Id,
tg => tg.TermSets.Include(
tset => tset.Name,
tset => tset.Id)));
siteCollectionTermGroup = termStore.GetSiteCollectionGroup((web.Context as ClientContext).Site, false);
web.Context.Load(siteCollectionTermGroup);
web.Context.ExecuteQueryRetry();
}
catch (ServerException)
{
// If the GetDefaultSiteCollectionTermStore method call fails ... raise a specific Warning
WriteMessage(CoreResources.Provisioning_ObjectHandlers_TermGroups_Wrong_Configuration, ProvisioningMessageType.Warning);
// and exit skipping the current handler
return(parser);
}
SiteCollectionTermGroupNameToken siteCollectionTermGroupNameToken =
new SiteCollectionTermGroupNameToken(web);
foreach (var modelTermGroup in template.TermGroups)
{
#region Group
var newGroup = false;
var normalizedGroupName = TaxonomyItem.NormalizeName(web.Context, modelTermGroup.Name);
web.Context.ExecuteQueryRetry();
TermGroup group = termStore.Groups.FirstOrDefault(
g => g.Id == modelTermGroup.Id || g.Name == normalizedGroupName.Value);
if (group == null)
{
var parsedGroupName = parser.ParseString(modelTermGroup.Name);
var parsedDescription = parser.ParseString(modelTermGroup.Description);
if (modelTermGroup.Name == "Site Collection" ||
parsedGroupName == siteCollectionTermGroupNameToken.GetReplaceValue() ||
modelTermGroup.SiteCollectionTermGroup)
{
var site = (web.Context as ClientContext).Site;
group = termStore.GetSiteCollectionGroup(site, true);
web.Context.Load(group, g => g.Name, g => g.Id, g => g.TermSets.Include(
tset => tset.Name,
tset => tset.Id));
web.Context.ExecuteQueryRetry();
}
else
{
var parsedNormalizedGroupName = TaxonomyItem.NormalizeName(web.Context, parsedGroupName);
web.Context.ExecuteQueryRetry();
group = termStore.Groups.FirstOrDefault(g => g.Name == parsedNormalizedGroupName.Value);
if (group == null)
{
if (modelTermGroup.Id == Guid.Empty)
{
modelTermGroup.Id = Guid.NewGuid();
}
group = termStore.CreateGroup(parsedGroupName, modelTermGroup.Id);
group.Description = parsedDescription;
#if !ONPREMISES
// Handle TermGroup Contributors, if any
if (modelTermGroup.Contributors != null && modelTermGroup.Contributors.Count > 0)
{
foreach (var c in modelTermGroup.Contributors)
{
group.AddContributor(c.Name);
}
}
// Handle TermGroup Managers, if any
if (modelTermGroup.Managers != null && modelTermGroup.Managers.Count > 0)
{
foreach (var m in modelTermGroup.Managers)
{
group.AddGroupManager(m.Name);
}
}
#endif
termStore.CommitAll();
web.Context.Load(group);
web.Context.ExecuteQueryRetry();
newGroup = true;
}
}
}
#endregion
#region TermSets
foreach (var modelTermSet in modelTermGroup.TermSets)
{
TermSet set = null;
var newTermSet = false;
var normalizedTermSetName = TaxonomyItem.NormalizeName(web.Context, modelTermSet.Name);
web.Context.ExecuteQueryRetry();
if (!newGroup)
{
set =
group.TermSets.FirstOrDefault(
ts => ts.Id == modelTermSet.Id || ts.Name == normalizedTermSetName.Value);
}
if (set == null)
{
if (modelTermSet.Id == Guid.Empty)
{
modelTermSet.Id = Guid.NewGuid();
}
set = group.CreateTermSet(parser.ParseString(modelTermSet.Name), modelTermSet.Id,
modelTermSet.Language ?? termStore.DefaultLanguage);
parser.AddToken(new TermSetIdToken(web, group.Name, modelTermSet.Name, modelTermSet.Id));
if (!siteCollectionTermGroup.ServerObjectIsNull.Value)
{
if (group.Name == siteCollectionTermGroup.Name)
{
parser.AddToken((new SiteCollectionTermSetIdToken(web, modelTermSet.Name, modelTermSet.Id)));
}
}
newTermSet = true;
set.Description = parser.ParseString(modelTermSet.Description);
set.IsOpenForTermCreation = modelTermSet.IsOpenForTermCreation;
set.IsAvailableForTagging = modelTermSet.IsAvailableForTagging;
foreach (var property in modelTermSet.Properties)
{
set.SetCustomProperty(property.Key, parser.ParseString(property.Value));
}
if (modelTermSet.Owner != null)
{
set.Owner = modelTermSet.Owner;
}
termStore.CommitAll();
web.Context.Load(set);
web.Context.ExecuteQueryRetry();
}
web.Context.Load(set, s => s.Terms.Include(t => t.Id, t => t.Name));
web.Context.ExecuteQueryRetry();
var terms = set.Terms;
foreach (var modelTerm in modelTermSet.Terms)
{
if (!newTermSet)
{
if (terms.Any())
{
var term = terms.FirstOrDefault(t => t.Id == modelTerm.Id);
if (term == null)
{
var normalizedTermName = TaxonomyItem.NormalizeName(web.Context, modelTerm.Name);
web.Context.ExecuteQueryRetry();
term = terms.FirstOrDefault(t => t.Name == normalizedTermName.Value);
if (term == null)
{
var returnTuple = CreateTerm <TermSet>(web, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
else
{
modelTerm.Id = term.Id;
}
}
else
{
modelTerm.Id = term.Id;
}
if (term != null)
{
CheckChildTerms(web, modelTerm, term, termStore, parser, scope);
}
}
else
{
var returnTuple = CreateTerm <TermSet>(web, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
}
else
{
var returnTuple = CreateTerm <TermSet>(web, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
}
// do we need custom sorting?
if (modelTermSet.Terms.Any(t => t.CustomSortOrder > -1))
{
var sortedTerms = modelTermSet.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty,
(a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
set.CustomSortOrder = customSortString;
termStore.CommitAll();
web.Context.ExecuteQueryRetry();
}
}
#endregion
}
foreach (var reusedTerm in this.reusedTerms)
{
TryReuseTerm(web, reusedTerm.ModelTerm, reusedTerm.Parent, reusedTerm.TermStore, parser, scope);
}
}
return(parser);
}
internal static List <ReusedTerm> ProcessGroup(ClientContext context, TaxonomySession session, TermStore termStore, Model.TermGroup modelTermGroup, TermGroup siteCollectionTermGroup, TokenParser parser, PnPMonitoredScope scope)
{
List <ReusedTerm> reusedTerms = new List <ReusedTerm>();
SiteCollectionTermGroupNameToken siteCollectionTermGroupNameToken =
new SiteCollectionTermGroupNameToken(context.Web);
#region Group
var newGroup = false;
var modelGroupName = parser.ParseString(modelTermGroup.Name);
var normalizedGroupName = TaxonomyItem.NormalizeName(context, modelGroupName);
context.ExecuteQueryRetry();
TermGroup group = termStore.Groups.FirstOrDefault(
g => g.Id == modelTermGroup.Id || g.Name == normalizedGroupName.Value);
if (group == null)
{
var parsedDescription = parser.ParseString(modelTermGroup.Description);
if (modelTermGroup.Name == "Site Collection" ||
modelGroupName == siteCollectionTermGroupNameToken.GetReplaceValue() ||
modelTermGroup.SiteCollectionTermGroup)
{
var site = (context as ClientContext).Site;
group = termStore.GetSiteCollectionGroup(site, true);
context.Load(group, g => g.Name, g => g.Id, g => g.TermSets.Include(
tset => tset.Name,
tset => tset.Id));
context.ExecuteQueryRetry();
}
else
{
group = termStore.Groups.FirstOrDefault(g => g.Name == normalizedGroupName.Value);
if (group == null)
{
if (modelTermGroup.Id == Guid.Empty)
{
modelTermGroup.Id = Guid.NewGuid();
}
group = termStore.CreateGroup(modelGroupName, modelTermGroup.Id);
group.Description = parsedDescription;
// Handle TermGroup Contributors, if any
if (modelTermGroup.Contributors != null && modelTermGroup.Contributors.Count > 0)
{
foreach (var c in modelTermGroup.Contributors)
{
group.AddContributor(c.Name);
}
}
// Handle TermGroup Managers, if any
if (modelTermGroup.Managers != null && modelTermGroup.Managers.Count > 0)
{
foreach (var m in modelTermGroup.Managers)
{
group.AddGroupManager(m.Name);
}
}
termStore.CommitAll();
context.Load(group);
context.Load(termStore);
context.ExecuteQueryRetry();
newGroup = true;
}
}
}
#endregion
session.UpdateCache();
session.Context.ExecuteQueryRetry();
#region TermSets
foreach (var modelTermSet in modelTermGroup.TermSets)
{
TermSet set = null;
var newTermSet = false;
var normalizedTermSetName = TaxonomyItem.NormalizeName(context, parser.ParseString(modelTermSet.Name));
context.ExecuteQueryRetry();
if (!newGroup)
{
set =
group.TermSets.FirstOrDefault(
ts => ts.Id == modelTermSet.Id || ts.Name == normalizedTermSetName.Value);
}
if (set == null)
{
if (modelTermSet.Id == Guid.Empty)
{
modelTermSet.Id = Guid.NewGuid();
}
else
{
if (CheckIfTermSetIdIsUnique(termStore, modelTermSet.Id) == false)
{
throw new Exception($"Termset ID {modelTermSet.Id} is already present in termstore");
}
}
var termSetLanguage = modelTermSet.Language.HasValue ? modelTermSet.Language.Value : termStore.DefaultLanguage;
set = group.CreateTermSet(normalizedTermSetName.Value, modelTermSet.Id, termSetLanguage);
parser.AddToken(new TermSetIdToken(context.Web, group.Name, normalizedTermSetName.Value, modelTermSet.Id));
if (siteCollectionTermGroup != null && !siteCollectionTermGroup.ServerObjectIsNull.Value)
{
if (group.Name == siteCollectionTermGroup.Name)
{
parser.AddToken((new SiteCollectionTermSetIdToken(context.Web, normalizedTermSetName.Value, modelTermSet.Id)));
}
}
newTermSet = true;
if (!string.IsNullOrEmpty(modelTermSet.Description))
{
set.Description = parser.ParseString(modelTermSet.Description);
}
set.IsOpenForTermCreation = modelTermSet.IsOpenForTermCreation;
set.IsAvailableForTagging = modelTermSet.IsAvailableForTagging;
foreach (var property in modelTermSet.Properties)
{
set.SetCustomProperty(property.Key, parser.ParseString(property.Value));
}
if (modelTermSet.Owner != null)
{
set.Owner = parser.ParseString(modelTermSet.Owner);
}
termStore.CommitAll();
context.Load(set);
context.ExecuteQueryRetry();
}
context.Load(set, s => s.Terms.Include(t => t.Id, t => t.Name));
context.ExecuteQueryRetry();
var terms = set.Terms;
foreach (var modelTerm in modelTermSet.Terms)
{
if (!newTermSet)
{
if (terms.Any())
{
var term = terms.FirstOrDefault(t => t.Id == modelTerm.Id);
if (term == null)
{
var normalizedTermName = TaxonomyItem.NormalizeName(context, parser.ParseString(modelTerm.Name));
context.ExecuteQueryRetry();
term = terms.FirstOrDefault(t => t.Name == normalizedTermName.Value);
if (term == null)
{
var returnTuple = CreateTerm(context, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
reusedTerms.AddRange(returnTuple.Item3);
}
else
{
// todo: add handling for reused term?
modelTerm.Id = term.Id;
}
}
else
{
// todo: add handling for reused term?
modelTerm.Id = term.Id;
}
if (term != null)
{
CheckChildTerms(context, modelTerm, term, termStore, parser, scope);
}
}
else
{
var returnTuple = CreateTerm(context, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
reusedTerms.AddRange(returnTuple.Item3);
}
}
else
{
var returnTuple = CreateTerm(context, modelTerm, set, termStore, parser, scope);
if (returnTuple != null)
{
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
reusedTerms.AddRange(returnTuple.Item3);
}
}
// do we need custom sorting?
if (modelTermSet.Terms.Any(t => t.CustomSortOrder > 0))
{
var sortedTerms = modelTermSet.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty,
(a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
set.CustomSortOrder = customSortString;
termStore.CommitAll();
context.ExecuteQueryRetry();
}
}
#endregion
return(reusedTerms);
}
public override TokenParser ProvisionObjects(Web web, Model.ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
TaxonomySession taxSession = TaxonomySession.GetTaxonomySession(web.Context);
var termStore = taxSession.GetDefaultKeywordsTermStore();
web.Context.Load(termStore,
ts => ts.DefaultLanguage,
ts => ts.Groups.Include(
tg => tg.Name,
tg => tg.Id,
tg => tg.TermSets.Include(
tset => tset.Name,
tset => tset.Id)));
web.Context.ExecuteQueryRetry();
SiteCollectionTermGroupNameToken siteCollectionTermGroupNameToken = new SiteCollectionTermGroupNameToken(web);
foreach (var modelTermGroup in template.TermGroups)
{
#region Group
var newGroup = false;
TermGroup group = termStore.Groups.FirstOrDefault(
g => g.Id == modelTermGroup.Id || g.Name == modelTermGroup.Name);
if (group == null)
{
if (modelTermGroup.Name == "Site Collection" ||
parser.ParseString(modelTermGroup.Name) == siteCollectionTermGroupNameToken.GetReplaceValue() ||
modelTermGroup.SiteCollectionTermGroup)
{
var site = (web.Context as ClientContext).Site;
group = termStore.GetSiteCollectionGroup(site, true);
web.Context.Load(group, g => g.Name, g => g.Id, g => g.TermSets.Include(
tset => tset.Name,
tset => tset.Id));
web.Context.ExecuteQueryRetry();
}
else
{
var parsedGroupName = parser.ParseString(modelTermGroup.Name);
group = termStore.Groups.FirstOrDefault(g => g.Name == parsedGroupName);
if (group == null)
{
if (modelTermGroup.Id == Guid.Empty)
{
modelTermGroup.Id = Guid.NewGuid();
}
group = termStore.CreateGroup(parsedGroupName, modelTermGroup.Id);
group.Description = modelTermGroup.Description;
#if !ONPREMISES
// Handle TermGroup Contributors, if any
if (modelTermGroup.Contributors != null && modelTermGroup.Contributors.Count > 0)
{
foreach (var c in modelTermGroup.Contributors)
{
group.AddContributor(c.Name);
}
}
// Handle TermGroup Managers, if any
if (modelTermGroup.Managers != null && modelTermGroup.Managers.Count > 0)
{
foreach (var m in modelTermGroup.Managers)
{
group.AddGroupManager(m.Name);
}
}
#endif
termStore.CommitAll();
web.Context.Load(group);
web.Context.ExecuteQueryRetry();
newGroup = true;
}
}
}
#endregion
#region TermSets
foreach (var modelTermSet in modelTermGroup.TermSets)
{
TermSet set = null;
var newTermSet = false;
if (!newGroup)
{
set = group.TermSets.FirstOrDefault(ts => ts.Id == modelTermSet.Id || ts.Name == modelTermSet.Name);
}
if (set == null)
{
if (modelTermSet.Id == Guid.Empty)
{
modelTermSet.Id = Guid.NewGuid();
}
set = group.CreateTermSet(parser.ParseString(modelTermSet.Name), modelTermSet.Id, modelTermSet.Language ?? termStore.DefaultLanguage);
parser.AddToken(new TermSetIdToken(web, group.Name, modelTermSet.Name, modelTermSet.Id));
newTermSet = true;
set.Description = modelTermSet.Description;
set.IsOpenForTermCreation = modelTermSet.IsOpenForTermCreation;
set.IsAvailableForTagging = modelTermSet.IsAvailableForTagging;
foreach (var property in modelTermSet.Properties)
{
set.SetCustomProperty(property.Key, parser.ParseString(property.Value));
}
if (modelTermSet.Owner != null)
{
set.Owner = modelTermSet.Owner;
}
termStore.CommitAll();
web.Context.Load(set);
web.Context.ExecuteQueryRetry();
}
web.Context.Load(set, s => s.Terms.Include(t => t.Id, t => t.Name));
web.Context.ExecuteQueryRetry();
var terms = set.Terms;
foreach (var modelTerm in modelTermSet.Terms)
{
if (!newTermSet)
{
if (terms.Any())
{
var term = terms.FirstOrDefault(t => t.Id == modelTerm.Id);
if (term == null)
{
term = terms.FirstOrDefault(t => t.Name == modelTerm.Name);
if (term == null)
{
var returnTuple = CreateTerm <TermSet>(web, modelTerm, set, termStore, parser, scope);
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
else
{
modelTerm.Id = term.Id;
}
}
else
{
modelTerm.Id = term.Id;
}
}
else
{
var returnTuple = CreateTerm <TermSet>(web, modelTerm, set, termStore, parser, scope);
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
else
{
var returnTuple = CreateTerm <TermSet>(web, modelTerm, set, termStore, parser, scope);
modelTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
// do we need custom sorting?
if (modelTermSet.Terms.Any(t => t.CustomSortOrder > -1))
{
var sortedTerms = modelTermSet.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty, (a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
set.CustomSortOrder = customSortString;
termStore.CommitAll();
web.Context.ExecuteQueryRetry();
}
}
#endregion
}
}
return(parser);
}
private void UpdateTermSet(ClientContext sourceClientContext, ClientContext targetClientContext, TermSet sourceTermset, TermSet targetTermSet)
{
targetTermSet.Description = sourceTermset.Description;
targetTermSet.IsAvailableForTagging = sourceTermset.IsAvailableForTagging;
targetTermSet.Contact = sourceTermset.Contact;
// We're not allowing term creation as the target termset should stay in sync with the source
targetTermSet.IsOpenForTermCreation = false;
// Copy termset properties
if (sourceTermset.CustomProperties.Count > 0)
{
// add properties from source
foreach (KeyValuePair<string, string> property in sourceTermset.CustomProperties)
{
targetTermSet.SetCustomProperty(property.Key, property.Value);
}
}
if (targetTermSet.CustomProperties.Count > 0)
{
//remove properties which are not needed anymore
foreach (KeyValuePair<string, string> property in targetTermSet.CustomProperties)
{
if (!sourceTermset.CustomProperties.Keys.Contains(property.Key, StringComparer.InvariantCultureIgnoreCase))
{
targetTermSet.DeleteCustomProperty(property.Key);
}
}
}
targetClientContext.ExecuteQuery();
}
public override void ProvisionObjects(Microsoft.SharePoint.Client.Web web, Model.ProvisioningTemplate template, ProvisioningTemplateApplyingInformation applyingInformation)
{
Log.Info(Constants.LOGGING_SOURCE_FRAMEWORK_PROVISIONING, CoreResources.Provisioning_ObjectHandlers_TermGroups);
TaxonomySession taxSession = TaxonomySession.GetTaxonomySession(web.Context);
var termStore = taxSession.GetDefaultKeywordsTermStore();
web.Context.Load(termStore,
ts => ts.DefaultLanguage,
ts => ts.Groups.Include(
tg => tg.Name,
tg => tg.Id,
tg => tg.TermSets.Include(
tset => tset.Name,
tset => tset.Id)));
web.Context.ExecuteQueryRetry();
foreach (var modelTermGroup in template.TermGroups)
{
#region Group
var newGroup = false;
TermGroup group = termStore.Groups.FirstOrDefault(g => g.Id == modelTermGroup.Id);
if (group == null)
{
group = termStore.Groups.FirstOrDefault(g => g.Name == modelTermGroup.Name);
if (group == null)
{
if (modelTermGroup.Id == Guid.Empty)
{
modelTermGroup.Id = Guid.NewGuid();
}
group = termStore.CreateGroup(modelTermGroup.Name.ToParsedString(), modelTermGroup.Id);
group.Description = modelTermGroup.Description;
termStore.CommitAll();
web.Context.Load(group);
web.Context.ExecuteQueryRetry();
newGroup = true;
}
}
#endregion
#region TermSets
foreach (var modelTermSet in modelTermGroup.TermSets)
{
TermSet set = null;
var newTermSet = false;
if (!newGroup)
{
set = group.TermSets.FirstOrDefault(ts => ts.Id == modelTermSet.Id);
if (set == null)
{
set = group.TermSets.FirstOrDefault(ts => ts.Name == modelTermSet.Name);
}
}
if (set == null)
{
if (modelTermSet.Id == Guid.Empty)
{
modelTermSet.Id = Guid.NewGuid();
}
set = group.CreateTermSet(modelTermSet.Name.ToParsedString(), modelTermSet.Id, modelTermSet.Language ?? termStore.DefaultLanguage);
TokenParser.AddToken(new TermSetIdToken(web, modelTermGroup.Name, modelTermSet.Name, modelTermSet.Id));
newTermSet = true;
set.IsOpenForTermCreation = modelTermSet.IsOpenForTermCreation;
set.IsAvailableForTagging = modelTermSet.IsAvailableForTagging;
foreach (var property in modelTermSet.Properties)
{
set.SetCustomProperty(property.Key, property.Value);
}
if (modelTermSet.Owner != null)
{
set.Owner = modelTermSet.Owner;
}
termStore.CommitAll();
web.Context.Load(set);
web.Context.ExecuteQueryRetry();
}
web.Context.Load(set, s => s.Terms.Include(t => t.Id, t => t.Name));
web.Context.ExecuteQueryRetry();
var terms = set.Terms;
foreach (var modelTerm in modelTermSet.Terms)
{
if (!newTermSet)
{
if (terms.Any())
{
var term = terms.FirstOrDefault(t => t.Id == modelTerm.Id);
if (term == null)
{
term = terms.FirstOrDefault(t => t.Name == modelTerm.Name);
if (term == null)
{
modelTerm.Id = CreateTerm <TermSet>(web, modelTerm, set, termStore);
}
else
{
modelTerm.Id = term.Id;
}
}
else
{
modelTerm.Id = term.Id;
}
}
else
{
modelTerm.Id = CreateTerm <TermSet>(web, modelTerm, set, termStore);
}
}
else
{
modelTerm.Id = CreateTerm <TermSet>(web, modelTerm, set, termStore);
}
}
// do we need custom sorting?
if (modelTermSet.Terms.Any(t => t.CustomSortOrder > -1))
{
var sortedTerms = modelTermSet.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty, (a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
set.CustomSortOrder = customSortString;
termStore.CommitAll();
web.Context.ExecuteQueryRetry();
}
}
#endregion
}
}
private static void MapTermSet(TermSet currentTermSet, TaxonomyTermSetDefinition termSetModel)
{
if (!string.IsNullOrEmpty(termSetModel.Description))
currentTermSet.Description = termSetModel.Description;
if (!string.IsNullOrEmpty(termSetModel.Contact))
currentTermSet.Contact = termSetModel.Contact;
if (!string.IsNullOrEmpty(termSetModel.CustomSortOrder))
currentTermSet.CustomSortOrder = termSetModel.CustomSortOrder;
if (termSetModel.IsOpenForTermCreation.HasValue)
currentTermSet.IsOpenForTermCreation = termSetModel.IsOpenForTermCreation.Value;
if (termSetModel.IsAvailableForTagging.HasValue)
currentTermSet.IsAvailableForTagging = termSetModel.IsAvailableForTagging.Value;
#if !NET35
foreach (var customProp in termSetModel.CustomProperties.Where(p => p.Override))
{
currentTermSet.SetCustomProperty(customProp.Name, customProp.Value);
}
#endif
}
private void Import(XmlElement termSetElement, Group parentGroup)
{
string termSetName = termSetElement.GetAttribute("Name");
TermSet termSet = null;
try
{
termSet = parentGroup.TermSets[termSetName];
}
catch (ArgumentException) {}
if (termSet == null)
{
Logger.Write("Creating Term Set: {0}", termSetName);
int lcid = parentGroup.TermStore.WorkingLanguage;
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("Id")))
{
Guid id = new Guid(termSetElement.GetAttribute("Id"));
termSet = parentGroup.CreateTermSet(termSetName, id, lcid);
}
else
{
termSet = parentGroup.CreateTermSet(termSetName, lcid);
}
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("Contact")))
{
termSet.Contact = termSetElement.GetAttribute("Contact");
}
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("Description")))
{
termSet.Description = termSetElement.GetAttribute("Description");
}
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("CustomSortOrder")))
{
termSet.CustomSortOrder = termSetElement.GetAttribute("CustomSortOrder");
}
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("IsAvailableForTagging")))
{
termSet.IsAvailableForTagging = bool.Parse(termSetElement.GetAttribute("IsAvailableForTagging"));
}
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("Owner")))
{
termSet.Owner = termSetElement.GetAttribute("Owner");
}
termSet.IsOpenForTermCreation = true;
}
#if !SP2010
// Updated provided by John Calvert
XmlNodeList propertyNodes = termSetElement.SelectNodes("./CustomProperties/CustomProperty");
if (propertyNodes != null && propertyNodes.Count > 0)
{
foreach (XmlElement propertyElement in propertyNodes)
{
termSet.SetCustomProperty(propertyElement.GetAttribute("Name"),
propertyElement.GetAttribute("Value"));
}
}
// End update
#endif
parentGroup.TermStore.CommitAll();//TEST
XmlNodeList termsNodes = termSetElement.SelectNodes("./Terms/Term");
if (termsNodes != null && termsNodes.Count > 0)
{
foreach (XmlElement termElement in termsNodes)
{
Import(termElement, termSet);
}
}
if (!string.IsNullOrEmpty(termSetElement.GetAttribute("IsOpenForTermCreation")) && termSet.TermStore.OrphanedTermsTermSet != termSet)
{
termSet.IsOpenForTermCreation = bool.Parse(termSetElement.GetAttribute("IsOpenForTermCreation"));
}
}
