private static void SetTermLocalCustomProperties(Model.Term modelTerm, TokenParser parser, Term term)
{
foreach (var property in modelTerm.LocalProperties)
{
term.SetLocalCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
}
}
private TokenParser CheckChildTerms(Web web, Model.Term modelTerm, Term parentTerm, TermStore termStore, TokenParser parser, PnPMonitoredScope scope)
{
if (modelTerm.Terms.Any())
{
parentTerm.Context.Load(parentTerm, s => s.Terms.Include(t => t.Id, t => t.Name));
parentTerm.Context.ExecuteQueryRetry();
var terms = parentTerm.Terms;
foreach (var childTerm in modelTerm.Terms)
{
if (terms.Any())
{
var term = terms.FirstOrDefault(t => t.Id == childTerm.Id);
if (term == null)
{
var normalizedTermName = TaxonomyItem.NormalizeName(web.Context, childTerm.Name);
web.Context.ExecuteQueryRetry();
term = terms.FirstOrDefault(t => t.Name == normalizedTermName.Value);
if (term == null)
{
var returnTuple = CreateTerm <TermSet>(web, childTerm, parentTerm, termStore, parser, scope);
if (returnTuple != null)
{
childTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
else
{
childTerm.Id = term.Id;
}
}
else
{
childTerm.Id = term.Id;
}
if (term != null)
{
parser = CheckChildTerms(web, childTerm, term, termStore, parser, scope);
}
}
else
{
var returnTuple = CreateTerm <TermSet>(web, childTerm, parentTerm, termStore, parser, scope);
if (returnTuple != null)
{
childTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
}
}
return(parser);
}
/// <summary>
/// Creates child terms for the current model term if any exist
/// </summary>
/// <param name="web"></param>
/// <param name="modelTerm"></param>
/// <param name="term"></param>
/// <param name="termStore"></param>
/// <param name="parser"></param>
/// <param name="scope"></param>
/// <returns>Updated parser object</returns>
private TokenParser CreateChildTerms(Web web, Model.Term modelTerm, Term term, TermStore termStore, TokenParser parser, PnPMonitoredScope scope)
{
if (modelTerm.Terms.Any())
{
foreach (var modelTermTerm in modelTerm.Terms)
{
web.Context.Load(term.Terms);
web.Context.ExecuteQueryRetry();
var termTerms = term.Terms;
if (termTerms.Any())
{
var termTerm = termTerms.FirstOrDefault(t => t.Id == modelTermTerm.Id);
if (termTerm == null)
{
termTerm = termTerms.FirstOrDefault(t => t.Name == modelTermTerm.Name);
if (termTerm == null)
{
var returnTuple = CreateTerm <Term>(web, modelTermTerm, term, termStore, parser, scope);
if (returnTuple != null)
{
modelTermTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
else
{
modelTermTerm.Id = termTerm.Id;
}
}
else
{
modelTermTerm.Id = termTerm.Id;
}
}
else
{
var returnTuple = CreateTerm <Term>(web, modelTermTerm, term, termStore, parser, scope);
if (returnTuple != null)
{
modelTermTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
}
if (modelTerm.Terms.Any(t => t.CustomSortOrder > -1))
{
var sortedTerms = modelTerm.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty, (a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
term.CustomSortOrder = customSortString;
termStore.CommitAll();
}
}
return(parser);
}
private static void CreateTermLabels(Model.Term modelTerm, TermStore termStore, TokenParser parser, PnPMonitoredScope scope, Term term)
{
foreach (var label in modelTerm.Labels)
{
if (((label.IsDefaultForLanguage && label.Language != termStore.DefaultLanguage) || label.IsDefaultForLanguage == false) && termStore.Languages.Contains(label.Language))
{
term.CreateLabel(parser.ParseString(label.Value), label.Language, label.IsDefaultForLanguage);
}
else
{
scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language);
}
}
}
private List <Model.Term> GetTerms <T>(ClientRuntimeContext context, TaxonomyItem parent, int defaultLanguage, Boolean isSiteCollectionTermGroup = false)
{
List <Model.Term> termsToReturn = new List <Model.Term>();
TermCollection terms;
var customSortOrder = string.Empty;
if (parent is TermSet)
{
terms = ((TermSet)parent).Terms;
customSortOrder = ((TermSet)parent).CustomSortOrder;
}
else
{
terms = ((Term)parent).Terms;
customSortOrder = ((Term)parent).CustomSortOrder;
}
context.Load(terms, tms => tms.IncludeWithDefaultProperties(t => t.Labels, t => t.CustomSortOrder,
t => t.IsReused, t => t.IsSourceTerm, t => t.SourceTerm, t => t.IsDeprecated, t => t.Description, t => t.Owner));
context.ExecuteQueryRetry();
foreach (var term in terms)
{
var modelTerm = new Model.Term();
if (!isSiteCollectionTermGroup || term.IsReused)
{
modelTerm.Id = term.Id;
}
modelTerm.Name = term.Name;
modelTerm.IsAvailableForTagging = term.IsAvailableForTagging;
modelTerm.IsReused = term.IsReused;
modelTerm.IsSourceTerm = term.IsSourceTerm;
modelTerm.SourceTermId = (term.SourceTerm != null) ? term.SourceTerm.Id : Guid.Empty;
modelTerm.IsDeprecated = term.IsDeprecated;
modelTerm.Description = term.Description;
modelTerm.Owner = term.Owner;
if ((!term.IsReused || term.IsSourceTerm) && term.Labels.Any())
{
foreach (var label in term.Labels)
{
if ((label.Language == defaultLanguage && label.Value != term.Name) || label.Language != defaultLanguage)
{
var modelLabel = new Model.TermLabel();
modelLabel.IsDefaultForLanguage = label.IsDefaultForLanguage;
modelLabel.Value = label.Value;
modelLabel.Language = label.Language;
modelTerm.Labels.Add(modelLabel);
}
}
}
//else
//{
// foreach (var label in term.Labels)
// {
// var modelLabel = new Model.TermLabel();
// modelLabel.IsDefaultForLanguage = label.IsDefaultForLanguage;
// modelLabel.Value = label.Value;
// modelLabel.Language = label.Language;
// modelTerm.Labels.Add(modelLabel);
// }
//}
foreach (var localProperty in term.LocalCustomProperties)
{
modelTerm.LocalProperties.Add(localProperty.Key, localProperty.Value);
}
// Shared Properties have to be extracted just for source terms or not reused terms
if (!term.IsReused || term.IsSourceTerm)
{
foreach (var customProperty in term.CustomProperties)
{
modelTerm.Properties.Add(customProperty.Key, customProperty.Value);
}
}
if (term.TermsCount > 0)
{
modelTerm.Terms.AddRange(GetTerms <Term>(context, term, defaultLanguage, isSiteCollectionTermGroup));
}
termsToReturn.Add(modelTerm);
}
if (!string.IsNullOrEmpty(customSortOrder))
{
int count = 1;
foreach (var id in customSortOrder.Split(new[] { ':' }))
{
var term = termsToReturn.FirstOrDefault(t => t.Id == Guid.Parse(id));
if (term != null)
{
term.CustomSortOrder = count;
count++;
}
}
termsToReturn = termsToReturn.OrderBy(t => t.CustomSortOrder).ToList();
}
return(termsToReturn);
}
/// <summary>
/// Attempts to reuse the model term. If the term does not yet exists it will return
/// false for the first part of the the return tuple. this will notify the system
/// that the term should be created instead of re-used.
/// </summary>
/// <param name="web"></param>
/// <param name="modelTerm"></param>
/// <param name="parent"></param>
/// <param name="termStore"></param>
/// <param name="parser"></param>
/// <param name="scope"></param>
/// <returns></returns>
private TryReuseTermResult TryReuseTerm(Web web, Model.Term modelTerm, TaxonomyItem parent, TermStore termStore, TokenParser parser, PnPMonitoredScope scope)
{
if (!modelTerm.IsReused)
{
return new TryReuseTermResult()
{
Success = false, UpdatedParser = parser
}
}
;
if (modelTerm.Id == Guid.Empty)
{
return new TryReuseTermResult()
{
Success = false, UpdatedParser = parser
}
}
;
// Since we're reusing terms ensure the previous terms are committed
termStore.CommitAll();
web.Context.ExecuteQueryRetry();
// Try to retrieve a matching term from the website also marked from re-use.
var taxonomySession = TaxonomySession.GetTaxonomySession(web.Context);
web.Context.Load(taxonomySession);
web.Context.ExecuteQueryRetry();
if (taxonomySession.ServerObjectIsNull())
{
return(new TryReuseTermResult()
{
Success = false, UpdatedParser = parser
});
}
var freshTermStore = taxonomySession.GetDefaultKeywordsTermStore();
Term preExistingTerm = freshTermStore.GetTerm(modelTerm.Id);
try
{
web.Context.Load(preExistingTerm);
web.Context.ExecuteQueryRetry();
if (preExistingTerm.ServerObjectIsNull())
{
preExistingTerm = null;
}
}
catch (Exception)
{
preExistingTerm = null;
}
// If the matching term is not found, return false... we can't re-use just yet
if (preExistingTerm == null)
{
return(new TryReuseTermResult()
{
Success = false, UpdatedParser = parser
});
}
// if the matching term is found re-use, create child terms, and return true
else
{
// Reuse term
Term createdTerm = null;
if (parent is TermSet)
{
createdTerm = ((TermSet)parent).ReuseTerm(preExistingTerm, false);
}
else if (parent is Term)
{
createdTerm = ((Term)parent).ReuseTerm(preExistingTerm, false);
}
if (modelTerm.IsSourceTerm)
{
preExistingTerm.ReassignSourceTerm(createdTerm);
}
// Set labels and shared properties just in case we're on the source term
if (modelTerm.IsSourceTerm)
{
if (modelTerm.Labels.Any())
{
CreateTermLabels(modelTerm, termStore, parser, scope, createdTerm);
}
if (modelTerm.Properties.Any())
{
SetTermCustomProperties(modelTerm, parser, createdTerm);
}
}
if (modelTerm.LocalProperties.Any())
{
SetTermLocalCustomProperties(modelTerm, parser, createdTerm);
}
termStore.CommitAll();
web.Context.Load(createdTerm);
web.Context.ExecuteQueryRetry();
// Create any child terms
parser = this.CreateChildTerms(web, modelTerm, createdTerm, termStore, parser, scope);
// Return true, because our TryReuseTerm attempt succeeded!
return(new TryReuseTermResult()
{
Success = true, UpdatedParser = parser
});
}
}
private Tuple <Guid, TokenParser> CreateTerm <T>(Web web, Model.Term modelTerm, TaxonomyItem parent,
TermStore termStore, TokenParser parser, PnPMonitoredScope scope) where T : TaxonomyItem
{
// If the term is a re-used term and the term is not a source term, skip for now and create later
if (modelTerm.IsReused && !modelTerm.IsSourceTerm)
{
this.reusedTerms.Add(new ReusedTerm()
{
ModelTerm = modelTerm,
Parent = parent,
TermStore = termStore
});
return(null);
}
// Create new term
Term term;
if (modelTerm.Id == Guid.Empty)
{
modelTerm.Id = Guid.NewGuid();
}
if (parent is Term)
{
term = ((Term)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language != null && modelTerm.Language != 0 ? modelTerm.Language.Value : termStore.DefaultLanguage, modelTerm.Id);
}
else
{
term = ((TermSet)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language != null && modelTerm.Language != 0 ? modelTerm.Language.Value : termStore.DefaultLanguage, modelTerm.Id);
}
if (!string.IsNullOrEmpty(modelTerm.Description))
{
term.SetDescription(parser.ParseString(modelTerm.Description), modelTerm.Language != null && modelTerm.Language != 0 ? modelTerm.Language.Value : termStore.DefaultLanguage);
}
if (!string.IsNullOrEmpty(modelTerm.Owner))
{
term.Owner = modelTerm.Owner;
}
term.IsAvailableForTagging = modelTerm.IsAvailableForTagging;
if (modelTerm.Properties.Any() || modelTerm.Labels.Any() || modelTerm.LocalProperties.Any())
{
if (modelTerm.Labels.Any())
{
CreateTermLabels(modelTerm, termStore, parser, scope, term);
//foreach (var label in modelTerm.Labels)
//{
// if ((label.IsDefaultForLanguage && label.Language != termStore.DefaultLanguage) || label.IsDefaultForLanguage == false)
// {
// term.CreateLabel(parser.ParseString(label.Value), label.Language, label.IsDefaultForLanguage);
// }
// else
// {
// scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language);
// WriteWarning(string.Format(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language), ProvisioningMessageType.Warning);
// }
//}
}
if (modelTerm.Properties.Any())
{
SetTermCustomProperties(modelTerm, parser, term);
//foreach (var property in modelTerm.Properties)
//{
// term.SetCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
//}
}
if (modelTerm.LocalProperties.Any())
{
SetTermLocalCustomProperties(modelTerm, parser, term);
//foreach (var property in modelTerm.LocalProperties)
//{
// term.SetLocalCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
//}
}
}
termStore.CommitAll();
web.Context.Load(term);
web.Context.ExecuteQueryRetry();
// Deprecate term if needed
if (modelTerm.IsDeprecated != term.IsDeprecated)
{
term.Deprecate(modelTerm.IsDeprecated);
web.Context.ExecuteQueryRetry();
}
parser = this.CreateChildTerms(web, modelTerm, term, termStore, parser, scope);
return(Tuple.Create(modelTerm.Id, parser));
}
internal static Tuple <Guid, TokenParser, List <ReusedTerm> > CreateTerm(ClientContext context, Model.Term modelTerm, TaxonomyItem parent,
TermStore termStore, TokenParser parser, PnPMonitoredScope scope)
{
var reusedTerms = new List <ReusedTerm>();
// If the term is a re-used term and the term is not a source term, skip for now and create later
if (modelTerm.IsReused && !modelTerm.IsSourceTerm)
{
reusedTerms.Add(new ReusedTerm()
{
ModelTerm = modelTerm,
Parent = parent,
TermStore = termStore
});
return(Tuple.Create(modelTerm.Id, parser, reusedTerms));
}
// Create new term
Term term;
if (modelTerm.Id == Guid.Empty)
{
modelTerm.Id = Guid.NewGuid();
}
else
{
if (CheckIfTermIdIsUnique(termStore, modelTerm.Id) == false)
{
throw new Exception($"Term ID {modelTerm.Id} is already present in termstore");
}
}
if (parent is Term)
{
term = ((Term)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language != null && modelTerm.Language != 0 ? modelTerm.Language.Value : termStore.DefaultLanguage, modelTerm.Id);
}
else
{
term = ((TermSet)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language != null && modelTerm.Language != 0 ? modelTerm.Language.Value : termStore.DefaultLanguage, modelTerm.Id);
}
if (!string.IsNullOrEmpty(modelTerm.Description))
{
term.SetDescription(parser.ParseString(modelTerm.Description), modelTerm.Language != null && modelTerm.Language != 0 ? modelTerm.Language.Value : termStore.DefaultLanguage);
}
if (!string.IsNullOrEmpty(modelTerm.Owner))
{
term.Owner = modelTerm.Owner;
}
term.IsAvailableForTagging = modelTerm.IsAvailableForTagging;
if (modelTerm.Properties.Any() || modelTerm.Labels.Any() || modelTerm.LocalProperties.Any())
{
if (modelTerm.Labels.Any())
{
CreateTermLabels(modelTerm, termStore, parser, scope, term);
}
if (modelTerm.Properties.Any())
{
SetTermCustomProperties(modelTerm, parser, term);
}
if (modelTerm.LocalProperties.Any())
{
SetTermLocalCustomProperties(modelTerm, parser, term);
}
}
termStore.CommitAll();
context.Load(term);
context.ExecuteQueryRetry();
// Deprecate term if needed
if (modelTerm.IsDeprecated != term.IsDeprecated)
{
term.Deprecate(modelTerm.IsDeprecated);
context.ExecuteQueryRetry();
}
parser = CreateChildTerms(context, modelTerm, term, termStore, parser, scope);
return(Tuple.Create(modelTerm.Id, parser, reusedTerms));
}
private Tuple <Guid, TokenParser> CreateTerm <T>(Web web, Model.Term modelTerm, TaxonomyItem parent, TermStore termStore, TokenParser parser, PnPMonitoredScope scope) where T : TaxonomyItem
{
// If the term is a re-used term try to re-use before trying to create.
if (modelTerm.IsReused)
{
var result = TryReuseTerm(web, modelTerm, parent, termStore, parser, scope);
if (result.Success)
{
return(Tuple.Create(modelTerm.Id, result.UpdatedParser));
}
}
// Create new term
Term term;
if (modelTerm.Id == Guid.Empty)
{
modelTerm.Id = Guid.NewGuid();
}
if (parent is Term)
{
var languages = termStore.DefaultLanguage;
term = ((Term)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language ?? termStore.DefaultLanguage, modelTerm.Id);
}
else
{
term = ((TermSet)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language ?? termStore.DefaultLanguage, modelTerm.Id);
}
if (!String.IsNullOrEmpty(modelTerm.Description))
{
term.SetDescription(modelTerm.Description, modelTerm.Language ?? termStore.DefaultLanguage);
}
if (!String.IsNullOrEmpty(modelTerm.Owner))
{
term.Owner = modelTerm.Owner;
}
term.IsAvailableForTagging = modelTerm.IsAvailableForTagging;
if (modelTerm.Properties.Any() || modelTerm.Labels.Any() || modelTerm.LocalProperties.Any())
{
if (modelTerm.Labels.Any())
{
foreach (var label in modelTerm.Labels)
{
if ((label.IsDefaultForLanguage && label.Language != termStore.DefaultLanguage) || label.IsDefaultForLanguage == false)
{
var l = term.CreateLabel(parser.ParseString(label.Value), label.Language, label.IsDefaultForLanguage);
}
else
{
scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language);
WriteWarning(string.Format(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language), ProvisioningMessageType.Warning);
}
}
}
if (modelTerm.Properties.Any())
{
foreach (var property in modelTerm.Properties)
{
term.SetCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
}
}
if (modelTerm.LocalProperties.Any())
{
foreach (var property in modelTerm.LocalProperties)
{
term.SetLocalCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
}
}
}
termStore.CommitAll();
web.Context.Load(term);
web.Context.ExecuteQueryRetry();
// Deprecate term if needed
if (modelTerm.IsDeprecated != term.IsDeprecated)
{
term.Deprecate(modelTerm.IsDeprecated);
web.Context.ExecuteQueryRetry();
}
parser = this.CreateChildTerms(web, modelTerm, term, termStore, parser, scope);
return(Tuple.Create(modelTerm.Id, parser));
}
private List <Model.Term> GetTerms <T>(ClientRuntimeContext context, TaxonomyItem parent, int defaultLanguage)
{
List <Model.Term> termsToReturn = new List <Model.Term>();
TermCollection terms = null;
var customSortOrder = string.Empty;
if (parent is TermSet)
{
terms = ((TermSet)parent).Terms;
customSortOrder = ((TermSet)parent).CustomSortOrder;
}
else
{
terms = ((Term)parent).Terms;
customSortOrder = ((Term)parent).CustomSortOrder;
}
context.Load(terms, tms => tms.IncludeWithDefaultProperties(t => t.Labels, t => t.CustomSortOrder));
context.ExecuteQueryRetry();
foreach (var term in terms)
{
var modelTerm = new Model.Term();
modelTerm.Id = term.Id;
modelTerm.Name = term.Name;
modelTerm.IsAvailableForTagging = term.IsAvailableForTagging;
if (term.Labels.Any())
{
foreach (var label in term.Labels)
{
if ((label.Language == defaultLanguage && label.Value != term.Name) || label.Language != defaultLanguage)
{
var modelLabel = new Model.TermLabel();
modelLabel.IsDefaultForLanguage = label.IsDefaultForLanguage;
modelLabel.Value = label.Value;
modelLabel.Language = label.Language;
modelTerm.Labels.Add(modelLabel);
}
}
}
//else
//{
// foreach (var label in term.Labels)
// {
// var modelLabel = new Model.TermLabel();
// modelLabel.IsDefaultForLanguage = label.IsDefaultForLanguage;
// modelLabel.Value = label.Value;
// modelLabel.Language = label.Language;
// modelTerm.Labels.Add(modelLabel);
// }
//}
foreach (var localProperty in term.LocalCustomProperties)
{
modelTerm.LocalProperties.Add(localProperty.Key, localProperty.Value);
}
foreach (var customProperty in term.CustomProperties)
{
modelTerm.Properties.Add(customProperty.Key, customProperty.Value);
}
if (term.TermsCount > 0)
{
modelTerm.Terms.AddRange(GetTerms <Term>(context, term, defaultLanguage));
}
termsToReturn.Add(modelTerm);
}
if (!string.IsNullOrEmpty(customSortOrder))
{
int count = 1;
foreach (var id in customSortOrder.Split(new[] { ':' }))
{
var term = termsToReturn.FirstOrDefault(t => t.Id == Guid.Parse(id));
if (term != null)
{
term.CustomSortOrder = count;
count++;
}
}
termsToReturn = termsToReturn.OrderBy(t => t.CustomSortOrder).ToList();
}
return(termsToReturn);
}
private Guid CreateTerm <T>(Web web, Model.Term modelTerm, TaxonomyItem parent, TermStore termStore) where T : TaxonomyItem
{
Term term;
if (modelTerm.Id == Guid.Empty)
{
modelTerm.Id = Guid.NewGuid();
}
if (parent is Term)
{
var languages = termStore.DefaultLanguage;
term = ((Term)parent).CreateTerm(modelTerm.Name.ToParsedString(), modelTerm.Language ?? termStore.DefaultLanguage, modelTerm.Id);
}
else
{
term = ((TermSet)parent).CreateTerm(modelTerm.Name.ToParsedString(), modelTerm.Language ?? termStore.DefaultLanguage, modelTerm.Id);
}
if (!String.IsNullOrEmpty(modelTerm.Description))
{
term.SetDescription(modelTerm.Description, modelTerm.Language ?? termStore.DefaultLanguage);
}
if (!String.IsNullOrEmpty(modelTerm.Owner))
{
term.Owner = modelTerm.Owner;
}
term.IsAvailableForTagging = modelTerm.IsAvailableForTagging;
if (modelTerm.Properties.Any() || modelTerm.Labels.Any() || modelTerm.LocalProperties.Any())
{
if (modelTerm.Labels.Any())
{
foreach (var label in modelTerm.Labels)
{
if ((label.IsDefaultForLanguage && label.Language != termStore.DefaultLanguage) || label.IsDefaultForLanguage == false)
{
var l = term.CreateLabel(label.Value.ToParsedString(), label.Language, label.IsDefaultForLanguage);
}
else
{
WriteWarning(string.Format("Skipping label {0}, label is to set to default for language {1} while the default termstore language is also {1}", label.Value, label.Language), ProvisioningMessageType.Warning);
}
}
}
if (modelTerm.Properties.Any())
{
foreach (var property in modelTerm.Properties)
{
term.SetCustomProperty(property.Key.ToParsedString(), property.Value.ToParsedString());
}
}
if (modelTerm.LocalProperties.Any())
{
foreach (var property in modelTerm.LocalProperties)
{
term.SetLocalCustomProperty(property.Key.ToParsedString(), property.Value.ToParsedString());
}
}
}
termStore.CommitAll();
web.Context.Load(term);
web.Context.ExecuteQueryRetry();
if (modelTerm.Terms.Any())
{
foreach (var modelTermTerm in modelTerm.Terms)
{
web.Context.Load(term.Terms);
web.Context.ExecuteQueryRetry();
var termTerms = term.Terms;
if (termTerms.Any())
{
var termTerm = termTerms.FirstOrDefault(t => t.Id == modelTermTerm.Id);
if (termTerm == null)
{
termTerm = termTerms.FirstOrDefault(t => t.Name == modelTermTerm.Name);
if (termTerm == null)
{
modelTermTerm.Id = CreateTerm <Term>(web, modelTermTerm, term, termStore);
}
else
{
modelTermTerm.Id = termTerm.Id;
}
}
else
{
modelTermTerm.Id = termTerm.Id;
}
}
else
{
modelTermTerm.Id = CreateTerm <Term>(web, modelTermTerm, term, termStore);
}
}
if (modelTerm.Terms.Any(t => t.CustomSortOrder > -1))
{
var sortedTerms = modelTerm.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty, (a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
term.CustomSortOrder = customSortString;
termStore.CommitAll();
}
}
return(modelTerm.Id);
}
private Tuple <Guid, TokenParser> CreateTerm <T>(Web web, Model.Term modelTerm, TaxonomyItem parent, TermStore termStore, TokenParser parser, PnPMonitoredScope scope) where T : TaxonomyItem
{
Term term;
if (modelTerm.Id == Guid.Empty)
{
modelTerm.Id = Guid.NewGuid();
}
if (parent is Term)
{
var languages = termStore.DefaultLanguage;
term = ((Term)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language ?? termStore.DefaultLanguage, modelTerm.Id);
}
else
{
term = ((TermSet)parent).CreateTerm(parser.ParseString(modelTerm.Name), modelTerm.Language ?? termStore.DefaultLanguage, modelTerm.Id);
}
if (!String.IsNullOrEmpty(modelTerm.Description))
{
term.SetDescription(modelTerm.Description, modelTerm.Language ?? termStore.DefaultLanguage);
}
if (!String.IsNullOrEmpty(modelTerm.Owner))
{
term.Owner = modelTerm.Owner;
}
term.IsAvailableForTagging = modelTerm.IsAvailableForTagging;
if (modelTerm.Properties.Any() || modelTerm.Labels.Any() || modelTerm.LocalProperties.Any())
{
if (modelTerm.Labels.Any())
{
foreach (var label in modelTerm.Labels)
{
if ((label.IsDefaultForLanguage && label.Language != termStore.DefaultLanguage) || label.IsDefaultForLanguage == false)
{
var l = term.CreateLabel(parser.ParseString(label.Value), label.Language, label.IsDefaultForLanguage);
}
else
{
scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language);
WriteWarning(string.Format(CoreResources.Provisioning_ObjectHandlers_TermGroups_Skipping_label__0___label_is_to_set_to_default_for_language__1__while_the_default_termstore_language_is_also__1_, label.Value, label.Language), ProvisioningMessageType.Warning);
}
}
}
if (modelTerm.Properties.Any())
{
foreach (var property in modelTerm.Properties)
{
term.SetCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
}
}
if (modelTerm.LocalProperties.Any())
{
foreach (var property in modelTerm.LocalProperties)
{
term.SetLocalCustomProperty(parser.ParseString(property.Key), parser.ParseString(property.Value));
}
}
}
termStore.CommitAll();
web.Context.Load(term);
web.Context.ExecuteQueryRetry();
if (modelTerm.Terms.Any())
{
foreach (var modelTermTerm in modelTerm.Terms)
{
web.Context.Load(term.Terms);
web.Context.ExecuteQueryRetry();
var termTerms = term.Terms;
if (termTerms.Any())
{
var termTerm = termTerms.FirstOrDefault(t => t.Id == modelTermTerm.Id);
if (termTerm == null)
{
termTerm = termTerms.FirstOrDefault(t => t.Name == modelTermTerm.Name);
if (termTerm == null)
{
var returnTuple = CreateTerm <Term>(web, modelTermTerm, term, termStore, parser, scope);
modelTermTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
else
{
modelTermTerm.Id = termTerm.Id;
}
}
else
{
modelTermTerm.Id = termTerm.Id;
}
}
else
{
var returnTuple = CreateTerm <Term>(web, modelTermTerm, term, termStore, parser, scope);
modelTermTerm.Id = returnTuple.Item1;
parser = returnTuple.Item2;
}
}
if (modelTerm.Terms.Any(t => t.CustomSortOrder > -1))
{
var sortedTerms = modelTerm.Terms.OrderBy(t => t.CustomSortOrder);
var customSortString = sortedTerms.Aggregate(string.Empty, (a, i) => a + i.Id.ToString() + ":");
customSortString = customSortString.TrimEnd(new[] { ':' });
term.CustomSortOrder = customSortString;
termStore.CommitAll();
}
}
return(Tuple.Create(modelTerm.Id, parser));
}
