[Test] public void IFRS_ElementTaxonomyLinks()
{
//Trace.Listeners.Add( new TextWriterTraceListener(Console.Out) );
TestTaxonomy_IFRS_2004_06_15 s = new TestTaxonomy_IFRS_2004_06_15();
int errors = 0;
if (s.Load(IFRS_FILE, out errors) != true)
{
Assert.Fail((string)s.ErrorList[0]);
}
errors = 0;
s.Parse(out errors);
s.currentLanguage = "en";
s.currentLabelRole = "label";
ArrayList nodes = s.GetNodesByElement();
Assert.AreEqual(0, ((Node)nodes[0]).TaxonomyInfoId, "Taxonomy id not correct");
TaxonomyItem ti = s.GetTaxonomyInfo((Node)nodes[0]);
Assert.AreEqual("http://xbrl.iasb.org/int/fr/ifrs/gp/2004-06-15", ti.WebLocation, "target namespace wrong");
Assert.AreEqual(IFRS_FILE, ti.Location, "targetLocation wrong");
}
/// <summary>
/// Writes a taxonomy field value to a SPListItem.
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var termInfo = fieldValueInfo.Value as TaxonomyValue;
TaxonomyFieldValue newTaxonomyFieldValue = null;
TaxonomyField taxonomyField = (TaxonomyField)item.Fields.GetField(fieldValueInfo.FieldInfo.InternalName);
newTaxonomyFieldValue = new TaxonomyFieldValue(taxonomyField);
var noteField = item.Fields[taxonomyField.TextField];
if (termInfo != null && termInfo.Term != null)
{
string labelGuidPair = TaxonomyItem.NormalizeName(termInfo.Term.Label) + TaxonomyField.TaxonomyGuidLabelDelimiter + termInfo.Term.Id.ToString().ToUpperInvariant();
// PopulateFromLabelGuidPair takes care of looking up the WssId value and creating a new item in the TaxonomyHiddenList if needed.
// Main taxonomy field value format: WssID;#Label
// TODO - Make sure we support sub-level terms with format: WssID;#Label|RootTermGuid|...|ParentTermGuid|TermGuid
// Reference: http://msdn.microsoft.com/en-us/library/ee567833.aspx
newTaxonomyFieldValue.PopulateFromLabelGuidPair(labelGuidPair);
// Must write associated note field as well as the main taxonomy field.
// Note field value format: Label|Guid
// Reference: http://nickhobbs.wordpress.com/2012/02/21/sharepoint-2010-how-to-set-taxonomy-field-values-programmatically/
item[noteField.InternalName] = labelGuidPair;
}
else
{
// No taxonomy value, make sure to empty the note field as well
item[noteField.InternalName] = null;
}
item[fieldValueInfo.FieldInfo.InternalName] = newTaxonomyFieldValue;
}
private static TaxonomyFieldValueCollection CreateSharePointTaxonomyFieldValue(
TaxonomyField sharepointTaxonomyField,
TaxonomyValueCollection dynamiteCollection,
List <string> labelGuidPairsListOutParam)
{
if (labelGuidPairsListOutParam == null)
{
labelGuidPairsListOutParam = new List <string>();
}
TaxonomyFieldValueCollection sharePointValueCollection = null;
foreach (var TaxonomyValue in dynamiteCollection)
{
string labelGuidPair = TaxonomyItem.NormalizeName(TaxonomyValue.Term.Label) + TaxonomyField.TaxonomyGuidLabelDelimiter
+ TaxonomyValue.Term.Id.ToString().ToUpperInvariant();
labelGuidPairsListOutParam.Add(labelGuidPair);
}
if (labelGuidPairsListOutParam.Count >= 1)
{
sharePointValueCollection = new TaxonomyFieldValueCollection(sharepointTaxonomyField);
labelGuidPairsListOutParam.ForEach(labelGuidPair =>
{
TaxonomyFieldValue taxoFieldValue = new TaxonomyFieldValue(sharepointTaxonomyField);
taxoFieldValue.PopulateFromLabelGuidPair(labelGuidPair);
sharePointValueCollection.Add(taxoFieldValue);
});
}
return(sharePointValueCollection);
}
public SPOTaxonomyItem(TaxonomyItem item)
{
_item = item;
if (_item.IsPropertyAvailable("Name"))
SetProp("Name", _item.Name, false);
}
[Test] public void GAAP_ElementTaxonomyLinks()
{
//Trace.Listeners.Add( new TextWriterTraceListener(Console.Out) );
TestTaxonomy_2004_07_06 s = new TestTaxonomy_2004_07_06();
int errors = 0;
if (s.Load(US_GAAP_FILE, out errors) != true)
{
Assert.Fail((string)s.ErrorList[0]);
}
errors = 0;
s.Parse(out errors);
s.currentLanguage = "en";
s.currentLabelRole = "terseLabel";
ArrayList nodes = s.GetNodesByElement();
Assert.AreEqual(1, ((Node)nodes[0]).TaxonomyInfoId, "Taxonomy id not correct");
TaxonomyItem ti = s.GetTaxonomyInfo((Node)nodes[0]);
Assert.AreEqual("http://www.xbrl.org/taxonomy/us/fr/common/pt/usfr-pt-2004-07-06", ti.WebLocation, "target namespace wrong");
Assert.AreEqual(PT_GAAP_FILE, ti.Location, "targetLocation wrong");
}
public void GAAP_ElementTaxonomyLinks()
{
TestTaxonomy_2004_08_15 s = new TestTaxonomy_2004_08_15();
int errors = 0;
if (s.Load(US_GAAP_FILE, out errors) != true)
{
Assert.Fail((string)s.ErrorList[0]);
}
errors = 0;
s.Parse(out errors);
s.currentLanguage = "en";
s.currentLabelRole = "terseLabel";
ArrayList nodes = s.GetNodesByElement();
Assert.AreEqual(1, ((Node)nodes[0]).TaxonomyInfoId, "Taxonomy id not correct");
TaxonomyItem ti = s.GetTaxonomyInfo((Node)nodes[0]);
Assert.AreEqual("http://www.xbrl.org/us/fr/common/pt/2004-08-15", ti.WebLocation, "target namespace wrong");
Assert.AreEqual(@"S:\TestSchemas\XBRL 2.1 Updated\2004-08-15\usfr-pt-2004-08-15.xsd", ti.Location, "targetLocation wrong");
}
private static void UpdateTerm(TermSetItem termSet, ManagedMetadataEntity entity, IEnumerable <IEnumerable <ManagedMetadataEntity> > termLevels, int currLevel)
{
int lcid = entity.LCID.HasValue ? entity.LCID.Value : 1033;
string termName = TaxonomyItem.NormalizeName(entity.GetTermLevel(currLevel));
if (string.IsNullOrEmpty(termName))
{
return;
}
Term term = termSet is TermSet
? (termSet as TermSet).GetTerms(termName, lcid, true, StringMatchOption.ExactMatch, 1, false).
FirstOrDefault()
: termSet.Terms.FirstOrDefault(t => t.Name.Equals(termName, StringComparison.InvariantCulture));
if (term == null)
{
//try
//{
term = termSet.CreateTerm(termName, lcid, Guid.NewGuid());
term.IsAvailableForTagging = entity.AvailableForTagging;
//}
//catch (Exception ex)
//{
//}
}
LabelCollection allLabels = term.GetAllLabels(lcid);
if (allLabels.Count == 0 || !allLabels.Select(x => x.Value).Contains(termName))
{
//try
//{
term.CreateLabel(termName, lcid, true);
term.SetDescription(entity.TermDescription, lcid);
//}
//catch (Exception ex)
//{
//}
}
if (termLevels == null)
{
return;
}
if (currLevel >= termLevels.Count())
{
return;
}
IEnumerable <ManagedMetadataEntity> childList =
termLevels.ElementAt(currLevel).Where(
t => t.HasSameLevelTerm(currLevel, entity));
foreach (ManagedMetadataEntity childEntity in childList)
{
UpdateTerm(term, childEntity, termLevels, currLevel + 1);
}
}
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);
}
public SPOTaxonomyItem(TaxonomyItem item)
{
_item = item;
if (_item.IsPropertyAvailable("Name"))
{
SetProp("Name", _item.Name, false);
}
}
private static string FormatTaxonomyString(TaxonomyField sharePointField, TaxonomyValue valueToApply)
{
var sharePointTaxonomyFieldValue = new TaxonomyFieldValue(sharePointField);
string path = TaxonomyItem.NormalizeName(valueToApply.Term.Label) + TaxonomyField.TaxonomyGuidLabelDelimiter
+ valueToApply.Term.Id.ToString().ToUpperInvariant();
sharePointTaxonomyFieldValue.PopulateFromLabelGuidPair(path);
return(sharePointTaxonomyFieldValue.ValidatedString);
}
// STEP 3: Update the term properties, including correcting any
// temporary names that were introduced in step 1.
static void ProcessPropertyUpdates(TermSetItem parentItem, ItemGoal parentItemGoal)
{
foreach (Term term in parentItem.Terms)
{
TermGoal termGoal = parentItemGoal.TermGoals.FirstOrDefault(t => t.Id == term.Id);
if (termGoal == null)
{
continue; // This is a term that would have been deleted by the ProcessDeletes() method.
}
// -----------------
string goalName = TaxonomyItem.NormalizeName(termGoal.Name);
if (term.Name != goalName)
{
Log("* Renaming term from \"" + term.Name + "\" to \"" + termGoal.Name + "\"");
term.Name = goalName;
}
HashSet <string> labels = new HashSet <string>(
term.Labels.Where(l => !l.IsDefaultForLanguage).Select(l => l.Value));
HashSet <string> labelsGoal = new HashSet <string>(termGoal.OtherLabels);
// Delete any extra labels.
foreach (string label in labels.Except(labelsGoal))
{
Log("* Term \"" + term.Name + "\": Deleting label \"" + label + "\"");
term.Labels.First(l => l.Value == label).Delete();
}
// Add any missing labels.
foreach (string label in labelsGoal.Except(labels))
{
Log("* Term \"" + term.Name + "\": Adding label \"" + label + "\"");
term.CreateLabel(label, lcid, isDefault: false);
}
if (term.GetDescription() != termGoal.Description)
{
Log("* Term \"" + term.Name + "\": Updating description");
term.SetDescription(termGoal.Description, lcid);
}
if (term.IsDeprecated != termGoal.IsDeprecated)
{
Log("* Term \"" + term.Name + "\": Marking as "
+ (termGoal.IsDeprecated ? "Deprecated" : "Not deprecated"));
term.Deprecate(termGoal.IsDeprecated);
}
// -----------------
ProcessPropertyUpdates(term, termGoal); // Recurse.
}
}
/// <summary>
/// Sets a value in a taxonomy field
/// </summary>
/// <param name="item">The item to set the value to</param>
/// <param name="TermPath">The path of the term in the shape of "TermGroupName|TermSetName|TermName"</param>
/// <param name="fieldId">The id of the field</param>
/// <exception cref="KeyNotFoundException"/>
public static void SetTaxonomyFieldValueByTermPath(this ListItem item, string TermPath, Guid fieldId)
{
var clientContext = item.Context as ClientContext;
TaxonomyItem taxItem = clientContext.Site.GetTaxonomyItemByPath(TermPath);
if (taxItem != null)
{
item.SetTaxonomyFieldValue(fieldId, taxItem.Name, taxItem.Id);
}
else
{
throw new KeyNotFoundException("Taxonomy Term not found");
}
}
private IList <ITaxonomyItem> CreateTaxonomyItems(IList <TaxonomyItemDto> itemDtos)
{
var items = new List <ITaxonomyItem>();
foreach (var itemDto in itemDtos)
{
var taxonomyItem = new TaxonomyItem();
taxonomyItem.Id = itemDto.Id;
taxonomyItem.Title = itemDto.Title;
taxonomyItem.DisplayUrl = itemDto.DisplayUrl;
taxonomyItem.Terms = CreateTaxonomyItems(itemDto.Terms);
items.Add(taxonomyItem);
}
return(items);
}
public static TaxonomyFieldValue GetTaxonomyFieldValue(TermSet termSet, string value, bool addIfDoesNotExist, out bool newTermAdded)
{
string termVal = TaxonomyItem.NormalizeName((value ?? string.Empty).Trim()); //ReplaceIllegalCharacters((value ?? string.Empty).Trim());
Term term = null;
newTermAdded = false;
if (termSet != null)
{
if (!string.IsNullOrEmpty(termVal))
{
term = termSet.GetTerms(termVal, termSet.TermStore.DefaultLanguage, true,
StringMatchOption.ExactMatch, 1, false).FirstOrDefault();
}
if (term == null && termSet.IsOpenForTermCreation && addIfDoesNotExist)
{
if (!string.IsNullOrEmpty(termVal))
{
term = termSet.CreateTerm(termVal, termSet.TermStore.DefaultLanguage);
newTermAdded = true;
//termSet.TermStore.CommitAll();
}
}
if (term != null)
{
string termValue = string.Concat(term.GetDefaultLabel(termSet.TermStore.DefaultLanguage),
TaxonomyField.TaxonomyGuidLabelDelimiter,
term.Id.ToString());
return(TaxonomyFieldControl.GetTaxonomyValue(termValue));
}
}
return(null);
}
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);
}
private static Field CreateTaxonomyFieldInternal(this Web web, Guid id, string internalName, string displayName, string group, TaxonomyItem taxonomyItem, bool multiValue)
{
internalName.ValidateNotNullOrEmpty("internalName");
displayName.ValidateNotNullOrEmpty("displayName");
taxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");
try
{
List <KeyValuePair <string, string> > additionalAttributes = new List <KeyValuePair <string, string> >();
additionalAttributes.Add(new KeyValuePair <string, string>("ShowField", "Term1033"));
FieldCreationInformation fieldCI = new FieldCreationInformation(multiValue ? "TaxonomyFieldTypeMulti" : "TaxonomyFieldType")
{
Id = id,
InternalName = internalName,
AddToDefaultView = true,
DisplayName = displayName,
Group = group,
AdditionalAttributes = additionalAttributes
};
var _field = web.CreateField(fieldCI);
WireUpTaxonomyFieldInternal(_field, taxonomyItem, multiValue);
_field.Update();
web.Context.ExecuteQuery();
return(_field);
}
catch (Exception)
{
///If there is an exception the hidden field might be present
FieldCollection _fields = web.Fields;
web.Context.Load(_fields, fc => fc.Include(f => f.Id, f => f.InternalName));
web.Context.ExecuteQuery();
var _hiddenField = id.ToString().Replace("-", "");
var _field = _fields.FirstOrDefault(f => f.InternalName == _hiddenField);
if (_field != null)
{
_field.DeleteObject();
web.Context.ExecuteQuery();
}
throw;
}
}
public TaxonomyItemPipeBind()
{
_id = Guid.Empty;
_title = string.Empty;
_item = null;
}
public TaxonomyItemPipeBind(T item)
{
_item = item;
}
protected override void ExecuteCmdlet()
{
TaxonomyItem taxItem = null;
Field field;
if (ParameterSetName == "Path")
{
taxItem = ClientContext.Site.GetTaxonomyItemByPath(TermSetPath, TermPathDelimiter);
}
else
{
var taxSession = ClientContext.Site.GetTaxonomySession();
var termStore = taxSession.GetDefaultKeywordsTermStore();
try
{
taxItem = termStore.GetTermSet(TaxonomyItemId.Id);
}
catch
{
try
{
taxItem = termStore.GetTerm(TaxonomyItemId.Id);
}
catch
{
throw new Exception(string.Format("Taxonomy Item with Id {0} not found", TaxonomyItemId.Id));
}
}
taxItem.EnsureProperty(t => t.Id);
}
Guid id = Id.Id;
if (id == Guid.Empty)
{
id = Guid.NewGuid();
}
TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
{
Id = id,
InternalName = InternalName,
DisplayName = DisplayName,
Group = Group,
TaxonomyItem = taxItem,
MultiValue = MultiValue,
Required = Required,
AddToDefaultView = AddToDefaultView
};
if (List != null)
{
var list = List.GetList(SelectedWeb);
field = list.CreateTaxonomyField(fieldCI);
}
else
{
field = SelectedWeb.CreateTaxonomyField(fieldCI);
}
WriteObject(field);
}
/// <summary>
/// Sets the default value for a managed metadata field
/// </summary>
/// <param name="field">Field to be wired up</param>
/// <param name="taxonomyItem">Taxonomy TermSet or Term</param>
/// <param name="defaultValue">default value for the field</param>
public static void SetTaxonomyFieldDefaultValue(this Field field, TaxonomyItem taxonomyItem, string defaultValue)
{
if (string.IsNullOrEmpty(defaultValue))
{
throw new ArgumentException("defaultValue");
}
var clientContext = field.Context as ClientContext;
taxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");
var anchorTerm = taxonomyItem as Term;
if (anchorTerm != default(Term) && !anchorTerm.IsPropertyAvailable("TermSet"))
{
clientContext.Load(anchorTerm.TermSet);
clientContext.ExecuteQueryRetry();
}
var termSet = taxonomyItem is Term ? anchorTerm.TermSet : taxonomyItem as TermSet;
if (termSet == default(TermSet))
{
throw new ArgumentException("Bound TaxonomyItem must be either a TermSet or a Term");
}
// set the SSP ID and Term Set ID on the taxonomy field
var taxField = clientContext.CastTo<TaxonomyField>(field);
if (!termSet.IsPropertyAvailable("Terms"))
{
clientContext.Load(termSet.Terms);
clientContext.ExecuteQueryRetry();
}
Term defaultValTerm = termSet.Terms.GetByName(defaultValue);
if (defaultValTerm != null)
{
clientContext.Load(defaultValTerm);
clientContext.ExecuteQueryRetry();
taxField.DefaultValue = string.Format("-1;#{0}{1}{2}", defaultValTerm.Name, TaxonomyGuidLabelDelimiter, defaultValTerm.Id);
taxField.Update();
clientContext.ExecuteQueryRetry();
}
}
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));
}
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);
}
/// <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
});
}
}
/// <summary>
/// Sets the default value for a managed metadata field
/// </summary>
/// <param name="field">Field to be wired up</param>
/// <param name="taxonomyItem">Taxonomy TermSet or Term</param>
/// <param name="defaultValue">default value for the field</param>
public static void SetTaxonomyFieldDefaultValue(this Field field, TaxonomyItem taxonomyItem, string defaultValue)
{
if (string.IsNullOrEmpty(defaultValue))
{
throw new ArgumentException("defaultValue");
}
var clientContext = field.Context as ClientContext;
taxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");
var anchorTerm = taxonomyItem as Term;
if (anchorTerm != default(Term) && !anchorTerm.IsPropertyAvailable("TermSet"))
{
clientContext.Load(anchorTerm.TermSet);
clientContext.ExecuteQueryRetry();
}
var termSet = taxonomyItem is Term ? anchorTerm.TermSet : taxonomyItem as TermSet;
if (termSet == default(TermSet))
{
throw new ArgumentException("Bound TaxonomyItem must be either a TermSet or a Term");
}
// set the SSP ID and Term Set ID on the taxonomy field
var taxField = clientContext.CastTo<TaxonomyField>(field);
if (!termSet.IsPropertyAvailable("Terms"))
{
clientContext.Load(termSet.Terms);
clientContext.ExecuteQueryRetry();
}
Term defaultValTerm = termSet.Terms.GetByName(defaultValue);
if (defaultValTerm != null)
{
clientContext.Load(defaultValTerm);
clientContext.ExecuteQueryRetry();
TaxonomyFieldValue taxValue = new TaxonomyFieldValue();
taxValue.WssId = -1;
taxValue.TermGuid = defaultValTerm.Id.ToString();
taxValue.Label = defaultValTerm.Name;
//get validate string
var validateValue = taxField.GetValidatedString(taxValue);
field.Context.ExecuteQueryRetry();
taxField.DefaultValue = validateValue.Value;
taxField.Update();
clientContext.ExecuteQueryRetry();
}
}
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);
}
public static ListItem UpdateListItem(ListItem item, Hashtable valuesToSet, ListItemUpdateType updateType, Action <string> warningCallback, Action <string, string> terminatingError)
{
var itemValues = new List <FieldUpdateValue>();
var context = item.Context as ClientContext;
var list = item.ParentList;
context.Web.EnsureProperty(w => w.Url);
var clonedContext = context.Clone(context.Web.Url);
var web = clonedContext.Web;
var fields =
context.LoadQuery(list.Fields.Include(f => f.InternalName, f => f.Title,
f => f.TypeAsString));
context.ExecuteQueryRetry();
Hashtable values = valuesToSet ?? new Hashtable();
foreach (var key in values.Keys)
{
var field = fields.FirstOrDefault(f => f.InternalName == key as string || f.Title == key as string);
if (field != null)
{
switch (field.TypeAsString)
{
case "User":
case "UserMulti":
{
List <FieldUserValue> userValues = new List <FieldUserValue>();
var value = values[key];
if (value == null)
{
goto default;
}
if (value is string && string.IsNullOrWhiteSpace(value + ""))
{
goto default;
}
if (value.GetType().IsArray)
{
foreach (var arrayItem in (value as IEnumerable))
{
int userId;
if (!int.TryParse(arrayItem.ToString(), out userId))
{
var user = web.EnsureUser(arrayItem as string);
clonedContext.Load(user);
clonedContext.ExecuteQueryRetry();
userValues.Add(new FieldUserValue()
{
LookupId = user.Id
});
}
else
{
userValues.Add(new FieldUserValue()
{
LookupId = userId
});
}
}
itemValues.Add(new FieldUpdateValue(key as string, userValues.ToArray(), null));
}
else
{
int userId;
if (!int.TryParse(value as string, out userId))
{
var user = web.EnsureUser(value as string);
clonedContext.Load(user);
clonedContext.ExecuteQueryRetry();
itemValues.Add(new FieldUpdateValue(key as string, new FieldUserValue()
{
LookupId = user.Id
}));
}
else
{
itemValues.Add(new FieldUpdateValue(key as string, new FieldUserValue()
{
LookupId = userId
}));
}
}
break;
}
case "TaxonomyFieldType":
case "TaxonomyFieldTypeMulti":
{
var value = values[key];
if (value != null && value.GetType().IsArray)
{
var taxSession = clonedContext.Site.GetTaxonomySession();
var terms = new List <KeyValuePair <Guid, string> >();
foreach (var arrayItem in value as object[])
{
TaxonomyItem taxonomyItem;
Guid termGuid;
if (!Guid.TryParse(arrayItem as string, out termGuid))
{
// Assume it's a TermPath
taxonomyItem = clonedContext.Site.GetTaxonomyItemByPath(arrayItem as string);
}
else
{
taxonomyItem = taxSession.GetTerm(termGuid);
clonedContext.Load(taxonomyItem);
clonedContext.ExecuteQueryRetry();
}
terms.Add(new KeyValuePair <Guid, string>(taxonomyItem.Id, taxonomyItem.Name));
}
TaxonomyField taxField = context.CastTo <TaxonomyField>(field);
taxField.EnsureProperty(tf => tf.AllowMultipleValues);
if (taxField.AllowMultipleValues)
{
var termValuesString = String.Empty;
foreach (var term in terms)
{
termValuesString += "-1;#" + term.Value + "|" + term.Key.ToString("D") + ";#";
}
termValuesString = termValuesString.Substring(0, termValuesString.Length - 2);
var newTaxFieldValue = new TaxonomyFieldValueCollection(context, termValuesString, taxField);
itemValues.Add(new FieldUpdateValue(key as string, newTaxFieldValue, field.TypeAsString));
}
else
{
warningCallback?.Invoke($@"You are trying to set multiple values in a single value field. Skipping values for field ""{field.InternalName}""");
}
}
else
{
Guid termGuid = Guid.Empty;
var taxSession = clonedContext.Site.GetTaxonomySession();
TaxonomyItem taxonomyItem = null;
if (value != null && !Guid.TryParse(value as string, out termGuid))
{
// Assume it's a TermPath
taxonomyItem = clonedContext.Site.GetTaxonomyItemByPath(value as string);
}
else
{
if (value != null)
{
taxonomyItem = taxSession.GetTerm(termGuid);
clonedContext.Load(taxonomyItem);
clonedContext.ExecuteQueryRetry();
}
}
TaxonomyField taxField = context.CastTo <TaxonomyField>(field);
TaxonomyFieldValue taxValue = new TaxonomyFieldValue();
if (taxonomyItem != null)
{
taxValue.TermGuid = taxonomyItem.Id.ToString();
taxValue.Label = taxonomyItem.Name;
itemValues.Add(new FieldUpdateValue(key as string, taxValue, field.TypeAsString));
}
else
{
taxField.ValidateSetValue(item, null);
}
}
break;
}
case "Lookup":
case "LookupMulti":
{
var value = values[key];
if (value == null)
{
goto default;
}
int[] multiValue;
if (value is Array)
{
var arr = (object[])values[key];
multiValue = new int[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
multiValue[i] = int.Parse(arr[i].ToString());
}
}
else
{
string valStr = values[key].ToString();
multiValue = valStr.Split(',', ';').Select(int.Parse).ToArray();
}
var newVals = multiValue.Select(id => new FieldLookupValue {
LookupId = id
}).ToArray();
FieldLookup lookupField = context.CastTo <FieldLookup>(field);
lookupField.EnsureProperty(lf => lf.AllowMultipleValues);
if (!lookupField.AllowMultipleValues && newVals.Length > 1)
{
throw new Exception("Field " + field.InternalName + " does not support multiple values");
}
itemValues.Add(new FieldUpdateValue(key as string, newVals));
break;
}
default:
{
itemValues.Add(new FieldUpdateValue(key as string, values[key]));
break;
}
}
}
else
{
terminatingError?.Invoke($"Field {key} not present in list.", "FIELDNOTINLIST");
}
}
foreach (var itemValue in itemValues)
{
if (string.IsNullOrEmpty(itemValue.FieldTypeString))
{
item[itemValue.Key] = itemValue.Value;
}
else
{
switch (itemValue.FieldTypeString)
{
case "TaxonomyFieldTypeMulti":
{
var field = fields.FirstOrDefault(f => f.InternalName == itemValue.Key as string || f.Title == itemValue.Key as string);
var taxField = context.CastTo <TaxonomyField>(field);
taxField.SetFieldValueByValueCollection(item, itemValue.Value as TaxonomyFieldValueCollection);
break;
}
case "TaxonomyFieldType":
{
var field = fields.FirstOrDefault(f => f.InternalName == itemValue.Key as string || f.Title == itemValue.Key as string);
var taxField = context.CastTo <TaxonomyField>(field);
taxField.SetFieldValueByValue(item, itemValue.Value as TaxonomyFieldValue);
break;
}
}
}
}
#if !ONPREMISES
switch (updateType)
{
case ListItemUpdateType.Update:
{
item.Update();
break;
}
case ListItemUpdateType.SystemUpdate:
{
item.SystemUpdate();
break;
}
case ListItemUpdateType.UpdateOverwriteVersion:
{
item.UpdateOverwriteVersion();
break;
}
}
#else
item.Update();
#endif
context.Load(item);
context.ExecuteQueryRetry();
return(item);
}
public static void SetFieldValues(this ListItem item, Hashtable valuesToSet, Cmdlet cmdlet)
{
// xxx: return early if hashtable is empty to save getting fields?
var itemValues = new List <FieldUpdateValue>();
var context = item.Context as ClientContext;
var list = item.ParentList;
context.Web.EnsureProperty(w => w.Url);
var clonedContext = context.Clone(context.Web.Url);
var web = clonedContext.Web;
var fields =
context.LoadQuery(list.Fields.Include(f => f.InternalName, f => f.Title,
f => f.TypeAsString));
context.ExecuteQueryRetry();
Hashtable values = valuesToSet ?? new Hashtable();
foreach (var key in values.Keys)
{
var field = fields.FirstOrDefault(f => f.InternalName == key as string || f.Title == key as string);
if (field != null)
{
switch (field.TypeAsString)
{
case "User":
case "UserMulti":
{
List <FieldUserValue> userValues = new List <FieldUserValue>();
var value = values[key];
if (value == null)
{
goto default;
}
if (value is string && string.IsNullOrWhiteSpace(value + ""))
{
goto default;
}
if (value.GetType().IsArray)
{
foreach (var arrayItem in (value as IEnumerable))
{
int userId;
if (!int.TryParse(arrayItem.ToString(), out userId))
{
var user = web.EnsureUser(arrayItem as string);
clonedContext.Load(user);
clonedContext.ExecuteQueryRetry();
userValues.Add(new FieldUserValue()
{
LookupId = user.Id
});
}
else
{
userValues.Add(new FieldUserValue()
{
LookupId = userId
});
}
}
itemValues.Add(new FieldUpdateValue(key as string, userValues.ToArray(), null));
}
else
{
int userId;
if (!int.TryParse(value as string, out userId))
{
var user = web.EnsureUser(value as string);
clonedContext.Load(user);
clonedContext.ExecuteQueryRetry();
itemValues.Add(new FieldUpdateValue(key as string, new FieldUserValue()
{
LookupId = user.Id
}));
}
else
{
itemValues.Add(new FieldUpdateValue(key as string, new FieldUserValue()
{
LookupId = userId
}));
}
}
break;
}
case "TaxonomyFieldType":
case "TaxonomyFieldTypeMulti":
{
var value = values[key];
if (value != null && value.GetType().IsArray)
{
var taxSession = clonedContext.Site.GetTaxonomySession();
var terms = new List <KeyValuePair <Guid, string> >();
foreach (var arrayItem in value as object[])
{
TaxonomyItem taxonomyItem;
Guid termGuid;
if (!Guid.TryParse(arrayItem as string, out termGuid))
{
// Assume it's a TermPath
taxonomyItem = clonedContext.Site.GetTaxonomyItemByPath(arrayItem as string);
}
else
{
taxonomyItem = taxSession.GetTerm(termGuid);
clonedContext.Load(taxonomyItem);
clonedContext.ExecuteQueryRetry();
}
terms.Add(new KeyValuePair <Guid, string>(taxonomyItem.Id, taxonomyItem.Name));
}
TaxonomyField taxField = context.CastTo <TaxonomyField>(field);
taxField.EnsureProperty(tf => tf.AllowMultipleValues);
if (taxField.AllowMultipleValues)
{
var termValuesString = String.Empty;
foreach (var term in terms)
{
termValuesString += "-1;#" + term.Value + "|" + term.Key.ToString("D") + ";#";
}
termValuesString = termValuesString.Substring(0, termValuesString.Length - 2);
var newTaxFieldValue = new TaxonomyFieldValueCollection(context, termValuesString, taxField);
itemValues.Add(new FieldUpdateValue(key as string, newTaxFieldValue, field.TypeAsString));
}
else
{
cmdlet.WriteWarning(@"You are trying to set multiple values in a single value field. Skipping values for field ""{field.InternalName}""");
}
}
else
{
Guid termGuid = Guid.Empty;
var taxSession = clonedContext.Site.GetTaxonomySession();
TaxonomyItem taxonomyItem = null;
if (value != null && !Guid.TryParse(value as string, out termGuid))
{
// Assume it's a TermPath
taxonomyItem = clonedContext.Site.GetTaxonomyItemByPath(value as string);
}
else
{
if (value != null)
{
taxonomyItem = taxSession.GetTerm(termGuid);
clonedContext.Load(taxonomyItem);
clonedContext.ExecuteQueryRetry();
}
}
TaxonomyField taxField = context.CastTo <TaxonomyField>(field);
TaxonomyFieldValue taxValue = new TaxonomyFieldValue();
if (taxonomyItem != null)
{
taxValue.TermGuid = taxonomyItem.Id.ToString();
taxValue.Label = taxonomyItem.Name;
itemValues.Add(new FieldUpdateValue(key as string, taxValue, field.TypeAsString));
}
else
{
taxField.ValidateSetValue(item, null);
}
}
break;
}
case "Lookup":
case "LookupMulti":
{
var value = values[key];
if (value == null)
{
goto default;
}
int[] multiValue;
if (value is Array)
{
var arr = (object[])values[key];
multiValue = new int[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
multiValue[i] = int.Parse(arr[i].ToString());
}
}
else
{
string valStr = values[key].ToString();
multiValue = valStr.Split(',', ';').Select(int.Parse).ToArray();
}
var newVals = multiValue.Select(id => new FieldLookupValue {
LookupId = id
}).ToArray();
FieldLookup lookupField = context.CastTo <FieldLookup>(field);
lookupField.EnsureProperty(lf => lf.AllowMultipleValues);
if (!lookupField.AllowMultipleValues && newVals.Length > 1)
{
throw new Exception("Field " + field.InternalName + " does not support multiple values");
}
itemValues.Add(new FieldUpdateValue(key as string, newVals));
break;
}
default:
{
itemValues.Add(new FieldUpdateValue(key as string, values[key]));
break;
}
}
}
else
{
throw new PSInvalidOperationException($"Field {key} not present in list.");
}
}
if (item != null && !item.ServerObjectIsNull.Value)
{
var specialFields = new[] { "Author", "Editor", "Created", "Modified" };
// check if we are setting editor or author fields
if (itemValues.Any(i => specialFields.Contains(i.Key)))
{
foreach (var field in specialFields)
{
if (itemValues.FirstOrDefault(i => i.Key == field) == null)
{
if (item.FieldValues.TryGetValue(field, out object fieldValue))
{
itemValues.Add(new FieldUpdateValue(field, fieldValue));
}
}
}
}
}
foreach (var itemValue in itemValues)
{
if (string.IsNullOrEmpty(itemValue.FieldTypeString))
{
item[itemValue.Key] = itemValue.Value;
}
else
{
switch (itemValue.FieldTypeString)
{
case "TaxonomyFieldTypeMulti":
{
var field = fields.FirstOrDefault(f => f.InternalName == itemValue.Key as string || f.Title == itemValue.Key as string);
var taxField = context.CastTo <TaxonomyField>(field);
if (itemValue.Value is TaxonomyFieldValueCollection)
{
taxField.SetFieldValueByValueCollection(item, itemValue.Value as TaxonomyFieldValueCollection);
}
else
{
taxField.SetFieldValueByValue(item, itemValue.Value as TaxonomyFieldValue);
}
break;
}
case "TaxonomyFieldType":
{
var field = fields.FirstOrDefault(f => f.InternalName == itemValue.Key as string || f.Title == itemValue.Key as string);
var taxField = context.CastTo <TaxonomyField>(field);
taxField.SetFieldValueByValue(item, itemValue.Value as TaxonomyFieldValue);
break;
}
}
}
}
}
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 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));
}
public override List <ServiceObject> DescribeServiceObjects()
{
List <ServiceObject> SOs = new List <ServiceObject>();
using (ClientContext context = InitializeContext(base.SiteURL))
{
Web spWeb = context.Web;
ListCollection lists = spWeb.Lists;
context.Load(lists);
context.ExecuteQuery();
//Making this dummy call to load the Micorsoft.Sharepoint.Client.Taxanomy assembly (https://blogs.msdn.microsoft.com/boodablog/2014/07/04/taxonomy-fields-return-as-dictionaries-using-the-client-objcet-model-in-sharepoint-2013/)
TaxonomyItem dummy = new TaxonomyItem(context, null);
foreach (List list in lists)
{
if (list.Hidden == false || (list.Hidden && base.IncludeHiddenLists))
{
if (list.BaseType == BaseType.DocumentLibrary)
{
context.Load(list.ContentTypes);
context.ExecuteQuery();
}
ServiceObject so = Helper.CreateServiceObject(list.Title, list.Title, list.Description);
so.MetaData.DisplayName = list.Title;
so.MetaData.Description = list.Description;
if (list.BaseType == BaseType.DocumentLibrary)
{
so.MetaData.AddServiceElement(Constants.InternalProperties.ServiceFolder, "Document Libraries");
}
else
{
so.MetaData.AddServiceElement(Constants.InternalProperties.ServiceFolder, "List Items");
}
so.MetaData.AddServiceElement(Constants.InternalProperties.ListTitle, list.Title);
so.MetaData.AddServiceElement(Constants.InternalProperties.IsFolderEnabled, list.EnableFolderCreation);
so.MetaData.AddServiceElement(Constants.InternalProperties.ListBaseType, list.BaseType);
if (list.BaseType == BaseType.DocumentLibrary && GetDocumentSetContentType(list.ContentTypes) != null)
{
so.MetaData.AddServiceElement(Constants.InternalProperties.IsListDocumentSet, true);
}
else
{
so.MetaData.AddServiceElement(Constants.InternalProperties.IsListDocumentSet, false);
}
FieldCollection fields = list.Fields;
context.Load(fields);
context.ExecuteQuery();
foreach (Field f in fields)
{
if (f.Hidden == false || (f.Hidden == true && base.IncludeHiddenFields))
{
// We'll use InternalName as the system name and Title as the display name.
// See http://blogs.perficient.com/microsoft/2009/04/static-name-vs-internal-name-vs-display-name-in-sharepoint/ for some background
// Some fields have no title, so then we just take the internalname.
string fieldTitle = f.Title;
if (string.IsNullOrEmpty(fieldTitle))
{
fieldTitle = f.InternalName;
}
// Because the field title can be duplicate, we see if it already exists.
// If it does, we change the displayname of both existing and newly found property to something unique.
// This behaviour can also be forced by the Show Internal Names option.
Property existingProp = GetExistingProperty(so, fieldTitle);
string displayName = fieldTitle;
if (ShowInternalNames)
{
displayName = string.Format("{0} ({1})", fieldTitle, f.InternalName);
}
if (existingProp != null)
{
existingProp.MetaData.DisplayName = string.Format("{0} ({1})",
existingProp.MetaData.GetServiceElement <string>(Constants.InternalProperties.Title),
existingProp.MetaData.GetServiceElement <string>(Constants.InternalProperties.InternalName));
displayName = string.Format("{0} ({1})", fieldTitle, f.InternalName);
}
AddFieldProperty(so, f);
FieldType _fieldtype; //We will find the Fieldtype from the MapHelper class (To get the correctoutput for field type Calculated)
SoType soType = MapHelper.SPTypeField(f, out _fieldtype);
Property prop = Helper.CreateSpecificProperty(f.InternalName, displayName, f.Description, soType);
prop.MetaData.AddServiceElement(Constants.InternalProperties.Hidden, f.Hidden);
prop.MetaData.AddServiceElement(Constants.InternalProperties.Title, fieldTitle);
prop.MetaData.AddServiceElement(Constants.InternalProperties.InternalName, f.InternalName);
prop.MetaData.AddServiceElement(Constants.InternalProperties.Id, f.Id);
prop.MetaData.AddServiceElement(Constants.InternalProperties.ReadOnly, AssignReadonly(f));
prop.MetaData.AddServiceElement(Constants.InternalProperties.Required, f.Required);
prop.MetaData.AddServiceElement(Constants.InternalProperties.FieldTypeKind, _fieldtype);
prop.MetaData.AddServiceElement(Constants.InternalProperties.SPFieldType, f.TypeAsString);
prop.MetaData.AddServiceElement(Constants.InternalProperties.Internal, false);
so.Properties.Add(prop);
}
}
AddInputServiceObjectPropertie(so);
AddServiceObjectMethods(so);
SOs.Add(so);
}
}
ServiceObject ctSo = Helper.CreateServiceObject("ContentTypes", "Content Types", "Manage the collection of content types, which enables consistent handling of content across sites.");
ctSo.MetaData.DisplayName = "Content Types";
ctSo.MetaData.Description = "Manage the collection of content types, which enables consistent handling of content across sites.";
ctSo.MetaData.AddServiceElement(Constants.InternalProperties.ServiceFolder, "Management");
ctSo.Properties.Add(Helper.CreateSpecificProperty(Constants.SOProperties.ContentTypeName, "Name", "Name", SoType.Text));
//so.Properties.Add(Helper.CreateSpecificProperty("SiteURL", "Site URL", "Site URL", SoType.Text));
ctSo.Properties.Add(Helper.CreateSpecificProperty(Constants.SOProperties.ContentTypeGroup, "Group", "Group", SoType.Text));
ctSo.Properties.Add(Helper.CreateSpecificProperty(Constants.SOProperties.ContentTypeReadOnly, "ReadOnly", "ReadOnly", SoType.YesNo));
ctSo.Properties.Add(Helper.CreateSpecificProperty(Constants.SOProperties.ContentTypeHidden, "Hidden", "Hidden", SoType.Text));
ctSo.Properties.Add(Helper.CreateSpecificProperty(Constants.SOProperties.ContentTypeCount, "Count", "Count", SoType.Number));
ctSo.Properties.Add(Helper.CreateSpecificProperty(Constants.SOProperties.ContentTypeID, "Content Type ID", "Content Type ID", SoType.Text));
AddContentTypeServiceObjectMethods(ctSo);
SOs.Add(ctSo);
return(SOs);
}
}
/// <summary>
/// Wires up MMS field to the specified term set or term.
/// </summary>
/// <param name="field">Field to be wired up</param>
/// <param name="taxonomyItem">Taxonomy TermSet or Term</param>
/// <param name="multiValue">Allow multiple selection</param>
private static void WireUpTaxonomyFieldInternal(Field field, TaxonomyItem taxonomyItem, bool multiValue)
{
var clientContext = field.Context as ClientContext;
taxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");
var anchorTerm = taxonomyItem as Term;
if (anchorTerm != default(Term) && !anchorTerm.IsPropertyAvailable("TermSet"))
{
clientContext.Load(anchorTerm.TermSet);
clientContext.ExecuteQueryRetry();
}
var termSet = taxonomyItem is Term ? anchorTerm.TermSet : taxonomyItem as TermSet;
if (termSet == default(TermSet))
throw new ArgumentException("Bound TaxonomyItem must be either a TermSet or a Term");
if (!termSet.IsPropertyAvailable("TermStore"))
{
clientContext.Load(termSet.TermStore);
clientContext.ExecuteQueryRetry();
}
// set the SSP ID and Term Set ID on the taxonomy field
var taxField = clientContext.CastTo<TaxonomyField>(field);
taxField.SspId = termSet.TermStore.Id;
taxField.TermSetId = termSet.Id;
if (anchorTerm != default(Term))
{
taxField.AnchorId = anchorTerm.Id;
}
taxField.AllowMultipleValues = multiValue;
taxField.Update();
clientContext.ExecuteQueryRetry();
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info($"Webhook was triggered!");
try
{
var jsonContent = await req.Content.ReadAsStringAsync();
log.Info(jsonContent);
dynamic data = JsonConvert.DeserializeObject(jsonContent);
// TODO: Rather than using web application settings, we should be using the Azure Key Vault for
// credentials
var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["SharePointUrl"].ConnectionString;
var fileId = -1;
using (ClientContext clientContext = new ClientContext(connectionString))
{
var dummy = new TaxonomyItem(clientContext, null);
var username = System.Configuration.ConfigurationManager.ConnectionStrings["UserName"].ConnectionString;
var password = System.Configuration.ConfigurationManager.ConnectionStrings["Password"].ConnectionString;
var securePassword = new SecureString();
foreach (char p in password)
{
securePassword.AppendChar(p);
}
var credentials = new SharePointOnlineCredentials(username, securePassword);
clientContext.Credentials = credentials;
File file = GetSharePointFile(clientContext, (string)data.RecordURL, log);
var listItem = file.ListItemAllFields;
clientContext.Load(file, c => c.ListItemAllFields.Id);
clientContext.ExecuteQuery();
fileId = listItem.Id;
foreach (dynamic metadataItem in data.Metadata.Fields)
{
log.Info($"Update field: " + metadataItem.Name);
if (metadataItem.Value == null)
{
listItem[(string)metadataItem.Name] = null;
}
else if ((bool)metadataItem.ManagedMetadataType)
{
//updateMetaDataField(clientContext, (string)data.Metadata.ListName, file, listItem, (string)metadataItem.Name, (string)metadataItem.Value, log);
}
else
{
listItem[(string)metadataItem.Name] = (string)metadataItem.Value;
}
listItem.Update();
}
clientContext.Load(listItem);
clientContext.ExecuteQuery();
}
return(req.CreateResponse(HttpStatusCode.OK, "{ \"SharePointId\" : \"" + fileId + "\" }"));
}
catch (Exception ex)
{
return(req.CreateResponse(HttpStatusCode.InternalServerError, "Critial error updating SharePoint metadata: " + ex.Message));
}
}
protected override void ExecuteCmdlet()
{
List list = null;
if (List != null)
{
list = List.GetList(SelectedWeb);
}
if (list != null)
{
var item = Identity.GetListItem(list);
if (ContentType != null)
{
ContentType ct = null;
if (ContentType.ContentType == null)
{
if (ContentType.Id != null)
{
ct = SelectedWeb.GetContentTypeById(ContentType.Id, true);
}
else if (ContentType.Name != null)
{
ct = SelectedWeb.GetContentTypeByName(ContentType.Name, true);
}
}
else
{
ct = ContentType.ContentType;
}
if (ct != null)
{
ct.EnsureProperty(w => w.StringId);
item["ContentTypeId"] = ct.StringId;
item.Update();
ClientContext.ExecuteQueryRetry();
}
}
if (Values != null)
{
var fields =
ClientContext.LoadQuery(list.Fields.Include(f => f.InternalName, f => f.Title,
f => f.TypeAsString));
ClientContext.ExecuteQueryRetry();
Hashtable values = Values ?? new Hashtable();
foreach (var key in values.Keys)
{
var field = fields.FirstOrDefault(f => f.InternalName == key as string || f.Title == key as string);
if (field != null)
{
switch (field.TypeAsString)
{
case "User":
case "UserMulti":
{
List <FieldUserValue> userValues = new List <FieldUserValue>();
var value = values[key];
if (value == null)
{
goto default;
}
if (value.GetType().IsArray)
{
foreach (var arrayItem in (value as IEnumerable))
{
int userId;
if (!int.TryParse(arrayItem.ToString(), out userId))
{
var user = SelectedWeb.EnsureUser(arrayItem as string);
ClientContext.Load(user);
ClientContext.ExecuteQueryRetry();
userValues.Add(new FieldUserValue()
{
LookupId = user.Id
});
}
else
{
userValues.Add(new FieldUserValue()
{
LookupId = userId
});
}
}
item[key as string] = userValues.ToArray();
}
else
{
int userId;
if (!int.TryParse(value as string, out userId))
{
var user = SelectedWeb.EnsureUser(value as string);
ClientContext.Load(user);
ClientContext.ExecuteQueryRetry();
item[key as string] = new FieldUserValue()
{
LookupId = user.Id
};
}
else
{
item[key as string] = new FieldUserValue()
{
LookupId = userId
};
}
}
#if !ONPREMISES
item.SystemUpdate();
#else
item.Update();
#endif
break;
}
case "TaxonomyFieldType":
case "TaxonomyFieldTypeMulti":
{
var value = Values[key];
if (value != null && value.GetType().IsArray)
{
var taxSession = ClientContext.Site.GetTaxonomySession();
var terms = new List <KeyValuePair <Guid, string> >();
foreach (var arrayItem in value as object[])
{
TaxonomyItem taxonomyItem;
Guid termGuid;
if (!Guid.TryParse(arrayItem as string, out termGuid))
{
// Assume it's a TermPath
taxonomyItem = ClientContext.Site.GetTaxonomyItemByPath(arrayItem as string);
}
else
{
taxonomyItem = taxSession.GetTerm(termGuid);
ClientContext.Load(taxonomyItem);
ClientContext.ExecuteQueryRetry();
}
terms.Add(new KeyValuePair <Guid, string>(taxonomyItem.Id, taxonomyItem.Name));
}
TaxonomyField taxField = ClientContext.CastTo <TaxonomyField>(field);
taxField.EnsureProperty(tf => tf.AllowMultipleValues);
if (taxField.AllowMultipleValues)
{
var termValuesString = String.Empty;
foreach (var term in terms)
{
termValuesString += "-1;#" + term.Value + "|" + term.Key.ToString("D") + ";#";
}
termValuesString = termValuesString.Substring(0, termValuesString.Length - 2);
var newTaxFieldValue = new TaxonomyFieldValueCollection(ClientContext, termValuesString, taxField);
taxField.SetFieldValueByValueCollection(item, newTaxFieldValue);
#if !ONPREMISES
item.SystemUpdate();
#else
item.Update();
#endif
ClientContext.ExecuteQueryRetry();
}
else
{
WriteWarning($@"You are trying to set multiple values in a single value field. Skipping values for field ""{field.InternalName}""");
}
}
else
{
Guid termGuid = Guid.Empty;
var taxSession = ClientContext.Site.GetTaxonomySession();
TaxonomyItem taxonomyItem = null;
if (value != null && !Guid.TryParse(value as string, out termGuid))
{
// Assume it's a TermPath
taxonomyItem = ClientContext.Site.GetTaxonomyItemByPath(value as string);
}
else
{
if (value != null)
{
taxonomyItem = taxSession.GetTerm(termGuid);
ClientContext.Load(taxonomyItem);
ClientContext.ExecuteQueryRetry();
}
}
TaxonomyField taxField = ClientContext.CastTo <TaxonomyField>(field);
TaxonomyFieldValue taxValue = new TaxonomyFieldValue();
if (taxonomyItem != null)
{
taxValue.TermGuid = taxonomyItem.Id.ToString();
taxValue.Label = taxonomyItem.Name;
taxField.SetFieldValueByValue(item, taxValue);
}
else
{
taxField.ValidateSetValue(item, null);
}
}
#if !ONPREMISES
item.SystemUpdate();
#else
item.Update();
#endif
break;
}
case "Lookup":
case "LookupMulti":
{
var value = values[key];
if (value == null)
{
goto default;
}
int[] multiValue;
if (value is Array)
{
var arr = (object[])values[key];
multiValue = new int[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
multiValue[i] = int.Parse(arr[i].ToString());
}
}
else
{
string valStr = values[key].ToString();
multiValue = valStr.Split(',', ';').Select(int.Parse).ToArray();
}
var newVals = multiValue.Select(id => new FieldLookupValue {
LookupId = id
}).ToArray();
FieldLookup lookupField = ClientContext.CastTo <FieldLookup>(field);
lookupField.EnsureProperty(lf => lf.AllowMultipleValues);
if (!lookupField.AllowMultipleValues && newVals.Length > 1)
{
throw new Exception("Field " + field.InternalName + " does not support multiple values");
}
item[key as string] = newVals;
#if !ONPREMISES
item.SystemUpdate();
#else
item.Update();
#endif
break;
}
default:
{
item[key as string] = values[key];
#if !ONPREMISES
item.SystemUpdate();
#else
item.Update();
#endif
break;
}
}
}
else
{
throw new Exception("Field not present in list");
}
}
#if !ONPREMISES
if (SystemUpdate)
{
item.SystemUpdate();
}
else
{
item.Update();
}
#else
item.Update();
#endif
ClientContext.Load(item);
ClientContext.ExecuteQueryRetry();
}
WriteObject(item);
}
}
private static Field CreateTaxonomyFieldInternal(this Web web, Guid id, string internalName, string displayName, string group, TaxonomyItem taxonomyItem, bool multiValue)
{
internalName.ValidateNotNullOrEmpty("internalName");
displayName.ValidateNotNullOrEmpty("displayName");
taxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");
try
{
List<KeyValuePair<string, string>> additionalAttributes = new List<KeyValuePair<string, string>>();
additionalAttributes.Add(new KeyValuePair<string, string>("ShowField", "Term1033"));
FieldCreationInformation fieldCI = new FieldCreationInformation(multiValue ? "TaxonomyFieldTypeMulti" : "TaxonomyFieldType")
{
Id = id,
InternalName = internalName,
AddToDefaultView = true,
DisplayName = displayName,
Group = group,
AdditionalAttributes = additionalAttributes
};
var _field = web.CreateField(fieldCI);
WireUpTaxonomyFieldInternal(_field, taxonomyItem, multiValue);
_field.Update();
web.Context.ExecuteQuery();
return _field;
}
catch (Exception)
{
///If there is an exception the hidden field might be present
FieldCollection _fields = web.Fields;
web.Context.Load(_fields, fc => fc.Include(f => f.Id, f => f.InternalName));
web.Context.ExecuteQuery();
var _hiddenField = id.ToString().Replace("-", "");
var _field = _fields.FirstOrDefault(f => f.InternalName == _hiddenField);
if (_field != null)
{
_field.DeleteObject();
web.Context.ExecuteQuery();
}
throw;
}
}
