public static void SetTaxonomyFieldValue(this ListItem item, Guid fieldId, string label, Guid termGuid) { ClientContext clientContext = item.Context as ClientContext; List list = item.ParentList; clientContext.Load(list); clientContext.ExecuteQuery(); IEnumerable <Field> fieldQuery = clientContext.LoadQuery( list.Fields .Include( fieldArg => fieldArg.TypeAsString, fieldArg => fieldArg.Id, fieldArg => fieldArg.InternalName ) ).Where(fieldArg => fieldArg.Id == fieldId); clientContext.ExecuteQuery(); TaxonomyField taxField = fieldQuery.Cast <TaxonomyField>().FirstOrDefault(); clientContext.Load(taxField); clientContext.ExecuteQuery(); TaxonomyFieldValue fieldValue = new TaxonomyFieldValue(); fieldValue.Label = label; fieldValue.TermGuid = termGuid.ToString(); fieldValue.WssId = -1; taxField.SetFieldValueByValue(item, fieldValue); item.Update(); clientContext.ExecuteQuery(); }
/// <summary> /// Populates a list of <see cref="TermEntry"/> with the hierarchy of terms. /// The list is ordered so that roots appear right before their child terms. public static void PopulateTermEntries(List <TermEntry> termEntries, TaxonomyField field, IEnumerable <ContentItem> contentItems, int level) { foreach (var contentItem in contentItems) { var children = Array.Empty <ContentItem>(); if (contentItem.Content.Terms is JArray termsArray) { children = termsArray.ToObject <ContentItem[]>(); } var termEntry = new TermEntry { Term = contentItem, ContentItemId = contentItem.ContentItemId, Selected = field.TermContentItemIds.Contains(contentItem.ContentItemId), Level = level, IsLeaf = children.Length == 0 }; termEntries.Add(termEntry); if (children.Length > 0) { PopulateTermEntries(termEntries, field, children, level + 1); } } }
public static void ConnectTaxonomyField(TaxonomyField field, SPSite site, string termGroup, string termSetName, bool isOpen = false, bool createValuesInEditForm = false) { if (site == null) { return; } TaxonomySession session = new TaxonomySession(site); ConnectTaxonomyField(field, session, termGroup, termSetName, isOpen, createValuesInEditForm); }
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); }
private static string GetTaxonomyFieldValidatedValue(TaxonomyField field, string defaultValue) { string res = null; object parsedValue = null; field.EnsureProperty(f => f.AllowMultipleValues); if (field.AllowMultipleValues) { parsedValue = new TaxonomyFieldValueCollection(field.Context, defaultValue, field); } else { TaxonomyFieldValue taxValue = null; if (TryParseTaxonomyFieldValue(defaultValue, out taxValue)) { parsedValue = taxValue; } } if (parsedValue != null) { var validateValue = field.GetValidatedString(parsedValue); field.Context.ExecuteQueryRetry(); res = validateValue.Value; } return(res); }
private void MatchTaxonomyField(SPListItem targetSPListItem, SPField targetSPField, string sourceValue) { // this is a managed metadata field TaxonomyField managedField = targetSPField as TaxonomyField; TaxonomySession session = new TaxonomySession(targetSPListItem.Web.Site); TermStore termStore = session.TermStores[managedField.SspId]; TermSet termSet = termStore.GetTermSet(managedField.TermSetId); int lcid = CultureInfo.CurrentCulture.LCID; // TODO: this is Classification code; to be replaced with the one below! Term myTerm = termSet.GetTerms(this.SubstringBefore(sourceValue, "|"), false).FirstOrDefault(); if (myTerm != null) { string termString = string.Concat(myTerm.GetDefaultLabel(lcid), TaxonomyField.TaxonomyGuidLabelDelimiter, myTerm.Id); int[] ids = TaxonomyField.GetWssIdsOfTerm(targetSPListItem.Web.Site, termStore.Id, termSet.Id, myTerm.Id, true, 1); // set the WssId (TaxonomyHiddenList ID) to -1 so that it is added to the TaxonomyHiddenList if (ids.Length == 0) { termString = "-1;#" + termString; } else { termString = ids[0] + ";#" + termString; } targetSPListItem[targetSPField.Id] = termString; } }
public static void AssociateMetadata(SPSite site, Guid fieldId, string _MMSGroupName, string _MMSTermsetName) { string _MMSServiceAppName = "ManagedMetadataServiceApplication"; if (site.RootWeb.Fields.Contains(fieldId)) { TaxonomySession session = new TaxonomySession(site); if (session.TermStores.Count != 0) { var termStore = session.TermStores[_MMSServiceAppName]; foreach (Group grp in termStore.Groups) { if (grp.Name.ToUpper() == _MMSGroupName.ToUpper()) { var group = grp; var termSet = group.TermSets[_MMSTermsetName]; TaxonomyField field = site.RootWeb.Fields[fieldId] as TaxonomyField; field.SspId = termSet.TermStore.Id; field.TermSetId = termSet.Id; field.TargetTemplate = string.Empty; field.AnchorId = Guid.Empty; field.Update(); break; } } } } }
public override void AddFieldTo(SPFieldCollection fieldCollection) { AddFieldTo(fieldCollection, f => { TaxonomyField field = (TaxonomyField)f; if (TermStoreGuid != System.Guid.Empty && TermSetGuid != System.Guid.Empty) { field.SspId = TermStoreGuid; field.TermSetId = TermSetGuid; } else { TaxonomySession session = new TaxonomySession(field.ParentList.ParentWeb.Site); TermStore store = session.DefaultSiteCollectionTermStore != null ? session.DefaultSiteCollectionTermStore : session.TermStores[0]; Group group = store.Groups[TermGroup]; TermSet set = group.TermSets[TermSet]; field.SspId = store.Id; field.TermSetId = set.Id; } field.AllowMultipleValues = AllowMultipleValues; }); }
public static void SetDefaultValue(SPSite site, TaxonomyField field, string defaultValue, bool addIfDoesNotExist /*, out bool newTermAdded*/) { if (field.AllowMultipleValues) { TaxonomyFieldValueCollection oTaxonomyFieldValues = GetTaxonomyFieldValues(site, field, new[] { defaultValue }, addIfDoesNotExist /*, out newTermAdded*/); string validatedString = field.GetValidatedString(oTaxonomyFieldValues); if (field.DefaultValue != validatedString) { field.DefaultValue = validatedString; field.Update(); } } else { TaxonomyFieldValue oTaxonomyFieldValue = GetTaxonomyFieldValue(site, field, defaultValue, addIfDoesNotExist /*, out newTermAdded*/); //string validatedString = field.GetValidatedString(oTaxonomyFieldValue); if (field.DefaultValue != oTaxonomyFieldValue.ValidatedString) { field.DefaultValue = oTaxonomyFieldValue.ValidatedString; field.Update(); } } }
private static Dictionary <string, string> GetManagedPropertyNamesUncached(SPSite site) { Dictionary <string, string> dictionary = new Dictionary <string, string>(); SearchServiceApplication searchApplication = GetSearchServiceApplication(site); if (searchApplication != null) { SPFieldCollection fields = site.RootWeb.Fields; foreach (KeyValuePair <string, string> entry in GetManagedPropertyNames(searchApplication)) { SPField field; try { field = fields.GetFieldByInternalName(entry.Key); } catch (ArgumentException) { continue; } dictionary.Add(entry.Key, entry.Value); TaxonomyField taxField = CommonHelper.TryCastOrDefault <TaxonomyField>(field); if (taxField != null && taxField.TextField != Guid.Empty) { try { SPField textField = fields[taxField.TextField]; dictionary[textField.InternalName] = entry.Value; } catch { } } } } return(dictionary); }
protected override SPField CreateField(Microsoft.SharePoint.SPFieldCollection fieldCollection) { TaxonomyField field = (TaxonomyField)fieldCollection.CreateNewField(FieldType, Name); fieldCollection.Add(field); return(fieldCollection[Name]); }
public static void SetDefaultValue(SPSite site, TaxonomyField field, string[] defaultValue, bool addIfDoesNotExist /*, out bool newTermAdded*/) { if (defaultValue == null || defaultValue.Length == 0) { //newTermAdded = false; return; } if (field.AllowMultipleValues) { TaxonomyFieldValueCollection oTaxonomyFieldValues = GetTaxonomyFieldValues(site, field, defaultValue, addIfDoesNotExist /*, out newTermAdded*/); string validatedString = field.GetValidatedString(oTaxonomyFieldValues); if (field.DefaultValue != validatedString) { field.DefaultValue = validatedString; field.Update(); } } else { SetDefaultValue(site, field, defaultValue[0], addIfDoesNotExist /*, out newTermAdded*/); } }
private void AssociateTaxonomyFieldToMetadataStore(SPSite curSite, Guid fieldId, string taxGroup, string taxTermSet) { Logging.Logger.Instance.Info( String.Format("Connecting Site Column to Managed Metadata Service: Field Guid: {0}; Group: {1}; TermSet: {2}", fieldId, taxGroup, taxTermSet), Logging.DiagnosticsCategories.eCaseSite); if (curSite.RootWeb.Fields.Contains(fieldId)) { TaxonomySession session = new TaxonomySession(curSite); if (session.TermStores.Count != 0) { TermStore termStore = session.DefaultKeywordsTermStore; Group group = termStore.Groups[taxGroup]; TermSet termSet = group.TermSets[taxTermSet]; TaxonomyField field = curSite.RootWeb.Fields[fieldId] as TaxonomyField; // Connect to MMS field.SspId = termSet.TermStore.Id; field.TermSetId = termSet.Id; field.PushChangesToLists = true; field.Update(); } } }
public static void ConnectTaxonomyField(TaxonomyField field, TaxonomySession session, TermStore termStore, string termGroup, string termSetName, bool isOpen = false, bool createValuesInEditForm = false) { if (field == null || session == null || termStore == null) { return; } Group group = termStore.Groups.GetByName(termGroup); if (group != null) { TermSet termSet = group.TermSets.GetByName(termSetName); // connect the field to the specified term if (termSet != null) { field.SspId = termSet.TermStore.Id; field.TermSetId = termSet.Id; field.Open = isOpen && termSet.IsOpenForTermCreation; field.CreateValuesInEditForm = field.Open && createValuesInEditForm; } } field.TargetTemplate = string.Empty; field.AnchorId = Guid.Empty; field.Update(); }
/// <summary> /// Helper Method to set a Taxonomy Field on a list item /// </summary> /// <param name="ctx">The Authenticated ClientContext</param> /// <param name="listItem">The listitem to modify</param> /// <param name="model">Domain Object of key/value pairs of the taxonomy field & value</param> public static void SetTaxonomyField(ClientContext ctx, ListItem listItem, Hashtable model) { FieldCollection _fields = listItem.ParentList.Fields; ctx.Load(_fields); ctx.ExecuteQuery(); foreach (var _key in model.Keys) { var _termName = model[_key].ToString(); TaxonomyField _field = ctx.CastTo <TaxonomyField>(_fields.GetByInternalNameOrTitle(_key.ToString())); ctx.Load(_field); ctx.ExecuteQuery(); Guid _id = _field.TermSetId; string _termID = AutoTaggingHelper.GetTermIdByName(ctx, _termName, _id); var _termValue = new TaxonomyFieldValue() { Label = _termName, TermGuid = _termID, WssId = -1 }; _field.SetFieldValueByValue(listItem, _termValue); listItem.Update(); ctx.ExecuteQuery(); } }
/// <summary> /// Aplica el Metadato al listItem especificado. /// </summary> /// <param name="listItem"></param> /// <param name="site"></param> /// <param name="campo">Field Internal Name</param> /// <param name="valor">Term1/Term1Son/Term1GrandSon</param> /// <param name="lcid"></param> /// <returns></returns> public static void SetMetadata(ref SPListItem listItem, SPSite site, string campo, string valor, int lcid, bool multi) { TaxonomySession session = new TaxonomySession(site); TaxonomyField tagsField = (TaxonomyField)listItem.Fields.GetField(campo); TermStore termStore = session.TermStores[tagsField.SspId]; TermSet termSet = termStore.GetTermSet(tagsField.TermSetId); Term termResult; if (multi) { ICollection <Term> termCol = new List <Term>(); foreach (string term in valor.Split(';')) { termResult = CrearNuevosTerminos(ref termStore, ref termSet, valor.Split('/'), lcid); termCol.Add(termResult); } tagsField.SetFieldValue(listItem, termCol); } else { termResult = CrearNuevosTerminos(ref termStore, ref termSet, valor.Split('/'), lcid); tagsField.SetFieldValue(listItem, termResult); } listItem.SystemUpdate(); }
/// <summary> /// Function to map metadata columns with specific term set /// </summary> /// <param name="clientContext">SP client context</param> /// <param name="fieldCol">Field Collection object</param> internal static void MapMetadataColumns(ClientContext clientContext, FieldCollection fieldCol) { string termsetName = ConfigurationManager.AppSettings["DefaultTermSetName"]; string taxonomyFieldType = ConfigurationManager.AppSettings["TaxonomyFieldType"]; TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext); TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); TermSetCollection termSetCollection = termStore.GetTermSetsByName(termsetName, 1033); // Setting LCID=1033, as the default language is English clientContext.Load(termStore); clientContext.Load(termSetCollection); clientContext.ExecuteQuery(); string termStoreId = Convert.ToString(termStore.Id, CultureInfo.InvariantCulture); string termSetId = Convert.ToString(termSetCollection[0].Id, CultureInfo.InvariantCulture); TaxonomyField taxonomyField = null; foreach (Field field in fieldCol) { if (field.TypeAsString.Equals(taxonomyFieldType, StringComparison.OrdinalIgnoreCase)) { taxonomyField = clientContext.CastTo <TaxonomyField>(field); taxonomyField.SspId = new Guid(termStoreId); taxonomyField.TermSetId = new Guid(termSetId); taxonomyField.AnchorId = Guid.Empty; taxonomyField.Update(); } } }
/// <summary> /// Updates a single-value managed metatada column /// </summary> /// <param name="taxonomyTerm"></param> /// <param name="item"></param> /// <param name="fieldToUpdate"></param> public static void UpdateMMField(string taxonomyTerm, SPListItem item, string fieldToUpdate) { //Get the metadata taxonomy field, a taxonomy session, the term store, and a collection of term sets in the store TaxonomyField managedMetadataField = item.ParentList.Fields[fieldToUpdate] as TaxonomyField; Guid tsId = managedMetadataField.TermSetId; Guid termStoreId = managedMetadataField.SspId; TaxonomySession tSession = new TaxonomySession(item.ParentList.ParentWeb.Site); TermStore tStore = tSession.TermStores[termStoreId]; TermSet tSet = tStore.GetTermSet(tsId); TermCollection terms = tSet.GetTerms(taxonomyTerm, false); Term term = null; //If term doesn't exist, create it in the term store if (terms.Count == 0) { Console.WriteLine("Creating term in managed metadata, {0}", taxonomyTerm); term = tSet.CreateTerm(taxonomyTerm, tStore.Languages[0]); tStore.CommitAll(); } else { term = terms[0]; } //Set the managed metadata field to the term retrieved from the term store managedMetadataField.SetFieldValue(item, term); item.Update(); }
private void SetTaxonomyField(TaxonomySession metadataService, SPListItem item, Guid fieldId, string fieldValue) { TaxonomyField taxField = item.Fields[fieldId] as TaxonomyField; TermStore termStore = metadataService.TermStores[taxField.SspId]; TermSet termSet = termStore.GetTermSet(taxField.TermSetId); SetTaxonomyFieldValue(termSet, taxField, item, fieldValue); }
/// <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; }
/// <summary> /// Writes a Taxonomy Multi 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 termInfos = fieldValueInfo.Value as TaxonomyValueCollection; TaxonomyFieldValueCollection newTaxonomyFieldValueCollection = null; TaxonomyField taxonomyField = (TaxonomyField)item.Fields.GetField(fieldValueInfo.FieldInfo.InternalName); var noteField = item.Fields[taxonomyField.TextField]; if (termInfos != null && termInfos.Count > 0) { List <string> labelGuidPairsListOutParam = new List <string>(); newTaxonomyFieldValueCollection = CreateSharePointTaxonomyFieldValue(taxonomyField, termInfos, labelGuidPairsListOutParam); item[taxonomyField.Id] = newTaxonomyFieldValueCollection; // Must write associated note field as well as the main taxonomy field. // Note field value format: Label|Guid;Label|Guid;Label|Guid... // Reference: http://nickhobbs.wordpress.com/2012/02/21/sharepoint-2010-how-to-set-taxonomy-field-values-programmatically/ string labelGuidPairsAsString = string.Join(";", labelGuidPairsListOutParam.ToArray()); item[noteField.InternalName] = labelGuidPairsAsString; } else { // No taxonomy value, make sure to empty the note field as well item[noteField.InternalName] = null; } item[fieldValueInfo.FieldInfo.InternalName] = newTaxonomyFieldValueCollection; }
public static void CreateSiteColumn(ClientContext ctx, string displayName, string internalName, string termSetName) { Web rootWeb = ctx.Site.RootWeb; if (rootWeb.FieldExistsByName(internalName)) { return; } // Create as a regular field setting the desired type in XML //https://msdn.microsoft.com/da-dk/library/office/microsoft.sharepoint.client.addfieldoptions.aspx Field field = rootWeb.Fields.AddFieldAsXml("<Field DisplayName='" + displayName + "' Name='" + internalName + "' ID='" + Guid.NewGuid() + "' Group='LB Columns' Type='TaxonomyFieldType' />", false, AddFieldOptions.AddFieldInternalNameHint); ctx.ExecuteQuery(); Guid termStoreId = Guid.Empty; Guid termSetId = Guid.Empty; GetTaxonomyFieldInfo(ctx, out termStoreId, out termSetId, termSetName); // Retrieve as Taxonomy Field TaxonomyField taxonomyField = ctx.CastTo <TaxonomyField>(field); taxonomyField.SspId = termStoreId; taxonomyField.TermSetId = termSetId; taxonomyField.TargetTemplate = String.Empty; taxonomyField.AnchorId = Guid.Empty; taxonomyField.Update(); ctx.ExecuteQuery(); }
private void SetTaxonomyFieldValue(TermSet termSet, TaxonomyField taxField, SPListItem item, string value) { var terms = termSet.GetTerms(value, true, StringMatchOption.ExactMatch, 1, false); if (terms.Count > 0) { taxField.SetFieldValue(item, terms.First()); } }
private void SetTaxonomyField(TaxonomySession metadataService, SPListItem item, Guid fieldId, List<string> fieldValues) { TaxonomyField taxField = item.Fields[fieldId] as TaxonomyField; TermStore termStore = metadataService.TermStores[taxField.SspId]; TermSet termSet = termStore.GetTermSet(taxField.TermSetId); if (taxField.AllowMultipleValues) SetTaxonomyFieldMultiValue(termSet, taxField, item, fieldValues); else SetTaxonomyFieldValue(termSet, taxField, item, fieldValues.First()); }
public static List <Log> UpdateSite(ClientContext ctx, DefaultFields defaultFields) { const string TaxonomyFieldType = "TaxonomyFieldType"; const string TaxonomyFieldTypeMulti = "TaxonomyFieldTypeMulti"; Web web = ctx.Web; try { Log.ClearLog(); ctx.Load(web); FieldCollection fields = web.Fields; ctx.Load(fields, tcol => tcol.Where(t => t.TypeAsString == TaxonomyFieldType || t.TypeAsString == TaxonomyFieldTypeMulti)); ctx.ExecuteQuery(); /// Update Columns foreach (var column in defaultFields) { Field field = GetField(column.InternalName, fields); if (field == null) { Log.Error(web.Url, "", column.InternalName, "Invalid Field Name"); } else { TaxonomyField taxonomyField = ctx.CastTo <TaxonomyField>(field); if (taxonomyField.AllowMultipleValues) { TaxonomyFieldValueCollection taxonomyFieldValues = new TaxonomyFieldValueCollection(ctx, "", field); taxonomyFieldValues.PopulateFromLabelGuidPairs(column.TermLabel + "|" + column.Guid); var validatedValues = taxonomyField.GetValidatedString(taxonomyFieldValues); ctx.ExecuteQuery(); taxonomyField.DefaultValue = validatedValues.Value; } else { TaxonomyFieldValue taxonomyFieldValue = new TaxonomyFieldValue(); taxonomyFieldValue.WssId = -1; taxonomyFieldValue.Label = column.TermLabel; taxonomyFieldValue.TermGuid = column.Guid; var validatedValue = taxonomyField.GetValidatedString(taxonomyFieldValue); ctx.ExecuteQuery(); taxonomyField.DefaultValue = validatedValue.Value; } taxonomyField.UpdateAndPushChanges(true); ctx.ExecuteQuery(); } } } catch (Exception ex) { Log.Error(web.Url, "", "", ex.Message); } return(Log.GetLog()); }
List <SPTaggableList> GetModel(ClientContext ctx, AppWebHelper hlp) { List <SPTaggableList> model = null; try { model = new List <SPTaggableList>(); LogHelper.Log("Inside getmodel"); if (ctx != null) { ListCollection lists = ctx.Web.Lists; ctx.Load(lists, ListQuery => ListQuery.Include( l => l.Id, l => l.Title, l => l.BaseType, l => l.Fields.Where( f => f.TypeAsString == "TaxonomyFieldTypeMulti" || f.TypeAsString == "TaxonomyFieldType") )); ctx.ExecuteQuery(); foreach (List list in lists) { if (list.BaseType == BaseType.DocumentLibrary && list.Fields.Count > 0) { SPTaggableList NewList = new SPTaggableList(); NewList.Title = list.Title; NewList.Id = list.Id.ToString(); NewList.Disabled = (hlp.ListsInfo.ContainsKey(NewList.Id) && hlp.ListsInfo[NewList.Id].ChildCount > 0) ? "Disabled" : string.Empty; NewList.Asynchronous = (hlp.ListsInfo.ContainsKey(NewList.Id)) ? hlp.ListsInfo[NewList.Id].Asynchronous : true; List <SPTaggableField> ListFields = new List <SPTaggableField>(); foreach (Field field in list.Fields) { TaxonomyField TaxField = field as TaxonomyField; string key = string.Concat(NewList.Id, "_", TaxField.Id.ToString()); var isEnabled = hlp.CurrentlyEnabledFields.Where(c => c["Title"].Equals(key)).SingleOrDefault(); ListFields.Add(new SPTaggableField { Id = TaxField.Id.ToString(), Title = TaxField.Title, TaggingEnabled = (isEnabled != null) ? true : false }); } NewList.Fields = ListFields; model.Add(NewList); } } } return(model); } catch (Exception ex) { LogHelper.Log(ex.Message + ex.StackTrace); throw; } }
protected void btnSave_Click(object sender, EventArgs e) { try { SPSecurity.RunWithElevatedPrivileges(delegate() { Control control = null; string controlValue = null; foreach (SPListItem listItem in selectedListItems) { listItem.ParentList.ParentWeb.AllowUnsafeUpdates = true; foreach (SPField field in fieldsToUpdate) { control = phDynamicFormControls.FindControl(string.Format("ctrl_{0}", field.InternalName)); controlValue = GetControlValue(control); if (control != null && GetControlValue(control) != string.Empty) { if (control.GetType().Equals(typeof(Microsoft.SharePoint.Taxonomy.TaxonomyWebTaggingControl))) { TaxonomyField fld = (TaxonomyField)field; if (fld.AllowMultipleValues) { var values = new TaxonomyFieldValueCollection(field); values.PopulateFromLabelGuidPairs(controlValue); fld.SetFieldValue(listItem, values); } } else { listItem[field.Id] = controlValue; } } } listItem.Update(); listItem.ParentList.ParentWeb.AllowUnsafeUpdates = false; } }); } catch (Exception ex) { Logger.Instance.Error("Error while saving fields during batch moving.", ex, DiagnosticsCategories.eCaseSearch); } //show any error messages that we have lblErrors.Text = errorMessages == null ? null : errorMessages.ToString(); if (errorMessages == null || errorMessages.Length == 0) { //close the modal Response.Write(string.Format(CultureInfo.InvariantCulture, "<script type=\"text/javascript\">window.frameElement.commonModalDialogClose(1, '{0}');</script>", selectedLists.Count)); Response.Flush(); Response.End(); } }
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); }
public void AssignTermSetToListColumn(SPList list, Guid fieldId, string termStoreGroupName, string termSetName, string termSubsetName) { if (list.Fields.Contains(fieldId)) { TaxonomySession session = new TaxonomySession(list.ParentWeb.Site); TermStore termStore = session.DefaultSiteCollectionTermStore; TaxonomyField field = (TaxonomyField)list.Fields[fieldId]; InternalAssignTermSetToTaxonomyField(termStore, field, termStoreGroupName, termSetName, termSubsetName); } }
private void SetTaxonomyTextValue(string fieldName, IEnumerable <Term> terms) { TaxonomyField taxonomyField = this.ObjectCache.GetField(this.WebId, this.ListId, fieldName) as TaxonomyField; if (taxonomyField != null) { SPField textField = this.ObjectCache.GetField(this.WebId, this.ListId, taxonomyField.TextField); this[textField.InternalName] = String.Join("\r\n", terms.Select(v => v.Id.ToString()).ToArray()); } }
private string GetTermIdForTaxonomyField(TaxonomyField field, string term, ListItem pendingItem, Microsoft.SharePoint.Client.File pendingFile) { if (_terms == null) { _terms = new Dictionary <string, IDictionary <string, string> >(); } if (!_terms.Keys.Contains(field.Title)) { _terms[field.Title] = new Dictionary <string, string>(); } if (_terms[field.Title].Keys.Contains(term)) { return(_terms[field.Title][term].ToString()); } var termId = string.Empty; //before we go forward,save pending item pendingItem.Update(); ctx.Load(pendingFile); ctx.ExecuteQuery(); TaxonomySession tSession = TaxonomySession.GetTaxonomySession(ctx); ctx.Load(tSession.TermStores); ctx.ExecuteQuery(); TermStore ts = tSession.TermStores.First(); TermSet tset = ts.GetTermSet(field.TermSetId); LabelMatchInformation lmi = new LabelMatchInformation(ctx); lmi.Lcid = 1033; lmi.TrimUnavailable = true; lmi.TermLabel = term; TermCollection termMatches = tset.GetTerms(lmi); ctx.Load(tSession); ctx.Load(ts); ctx.Load(tset); ctx.Load(termMatches); ctx.ExecuteQuery(); if (termMatches != null && termMatches.Count() > 0) { termId = termMatches.First().Id.ToString(); } _terms[field.Title][term] = termId; return(termId); }
public static void ConnectTaxonomyField(TaxonomyField field, TaxonomySession session, string termGroup, string termSetName, bool isOpen = false, bool createValuesInEditForm = false) { TermStore termStore; if (field != null && field.SspId != default(Guid)) { termStore = session.TermStores.SingleOrDefault(ts => ts.Id == field.SspId) ?? session.DefaultKeywordsTermStore; } else { termStore = session.DefaultKeywordsTermStore; } ConnectTaxonomyField(field, session, termStore, termGroup, termSetName, isOpen, createValuesInEditForm); }
/// <summary> /// Initializes a <see cref="TermInfo"/> instance from a taxonomy field value and definition. /// </summary> /// <param name="field">The list field from which the TaxonomyFieldValue was extracted. This is needed to extract the full TaxonomyContext.</param> /// <param name="fieldValue">The actual taxonomy field value.</param> /// <returns>The easily serializable <see cref="TermInfo"/> object</returns> public TermInfo CreateFromTaxonomyFieldValue(TaxonomyField field, TaxonomyFieldValue fieldValue) { if (field == null) { throw new ArgumentNullException("field"); } if (fieldValue == null) { throw new ArgumentNullException("fieldValue"); } var termInfo = new TermInfo(); return termInfo; }
private static void AssignTermSetToTaxonomyField(TermStore termStore, TaxonomyField field, string termStoreGroupName, string termSetName, string termSubsetName) { int originalWorkingLanguage = termStore.WorkingLanguage; termStore.WorkingLanguage = Language.English.Culture.LCID; Group group = termStore.Groups[termStoreGroupName]; TermSet termSet = group.TermSets[termSetName]; // Connect to MMS field.SspId = termSet.TermStore.Id; field.TermSetId = termSet.Id; field.TargetTemplate = string.Empty; // Select a sub node of the termset to limit selection if (!string.IsNullOrEmpty(termSubsetName)) { Term term = termStore.GetTerms(termSubsetName, true)[0]; field.AnchorId = term.Id; } else { field.AnchorId = Guid.Empty; } field.Update(); termStore.WorkingLanguage = originalWorkingLanguage; }
public static TaxonomyFieldValue GetTaxonomyFieldValue(SPSite site, TaxonomyField field, string value, bool addIfDoesNotExist/*, out bool newTermAdded*/) { TaxonomyFieldValue taxonomyFieldValue = new TaxonomyFieldValue(field); TaxonomyFieldValue tempValue = GetTaxonomyFieldValue(site, field.SspId, field.TermSetId, value, addIfDoesNotExist/*, out newTermAdded*/); if (tempValue != null) { taxonomyFieldValue.PopulateFromLabelGuidPair(tempValue.ToString()); } return taxonomyFieldValue; }
public static void ConnectTaxonomyField(TaxonomyField field, TaxonomySession session, string termStoreName, string termGroup, string termSetName, bool isOpen = false, bool createValuesInEditForm = false) { TermStore termStore = session.TermStores.SingleOrDefault(ts => string.Equals(ts.Name, termStoreName)); ConnectTaxonomyField(field, session, termStore, termGroup, termSetName, isOpen, createValuesInEditForm); }
public static TaxonomyFieldValue GetTaxonomyFieldValue(SPSite site, TaxonomyField field, string value, out List<int> wssIds) { TaxonomySession taxonomySession = new TaxonomySession(site); TermStore termStore = taxonomySession.TermStores[field.SspId]; TermSet termSet = termStore.GetTermSet(field.TermSetId); wssIds = new List<int>(); TaxonomyFieldValue taxonomyFieldValue = TaxonomyFieldControl.GetTaxonomyValue(value); wssIds.AddRange(TaxonomyField.GetWssIdsOfTerm(site, termStore.Id, termSet.Id, new Guid(taxonomyFieldValue.TermGuid), true, 100)); return taxonomyFieldValue; }
private static void ValidateTaxonomyFieldDefaultValue(TaxonomyField field) { //get validated value with correct WssIds var validatedValue = GetTaxonomyFieldValidatedValue(field, field.DefaultValue); if (!string.IsNullOrEmpty(validatedValue) && field.DefaultValue != validatedValue) { field.DefaultValue = validatedValue; field.UpdateAndPushChanges(true); field.Context.ExecuteQueryRetry(); } }
private static string GetTaxonomyFieldValidatedValue(TaxonomyField field, string defaultValue) { string res = null; object parsedValue = null; field.EnsureProperty(f => f.AllowMultipleValues); if (field.AllowMultipleValues) { parsedValue = new TaxonomyFieldValueCollection(field.Context, defaultValue, field); } else { TaxonomyFieldValue taxValue = null; if (TryParseTaxonomyFieldValue(defaultValue, out taxValue)) { parsedValue = taxValue; } } if (parsedValue != null) { var validateValue = field.GetValidatedString(parsedValue); field.Context.ExecuteQueryRetry(); res = validateValue.Value; } return res; }
public static TaxonomyFieldValueCollection GetTaxonomyFieldValues(SPSite site, TaxonomyField field, IEnumerable<string> values, bool addIfDoesNotExist/*, out bool newTermsAdded*/) { if (values == null) throw new ArgumentNullException("values"); TaxonomySession taxonomySession = new TaxonomySession(site); TermStore termStore = taxonomySession.TermStores[field.SspId]; TermSet termSet = termStore.GetTermSet(field.TermSetId); TaxonomyFieldValueCollection termValues = new TaxonomyFieldValueCollection(field); bool newTermsAdded = false; if (values != null && values.Count() > 0) { bool[] newTermAddedResult = new bool[values.Count()]; termValues.AddRange( values.Where(termValue => termValue != null) .Select((value, i) => { bool newTermAdded; TaxonomyFieldValue val = GetTaxonomyFieldValue(termSet, value, addIfDoesNotExist, out newTermAdded); newTermAddedResult[i] = newTermAdded; return val; })); newTermsAdded = newTermAddedResult.Any(newTermAdded => newTermAdded); } if (newTermsAdded) { termStore.CommitAll(); } return termValues; }
public static void SetDefaultValue(SPSite site, TaxonomyField field, string[] defaultValue, bool addIfDoesNotExist/*, out bool newTermAdded*/) { if (defaultValue == null || defaultValue.Length == 0) { //newTermAdded = false; return; } if (field.AllowMultipleValues) { TaxonomyFieldValueCollection oTaxonomyFieldValues = GetTaxonomyFieldValues(site, field, defaultValue, addIfDoesNotExist/*, out newTermAdded*/); string validatedString = field.GetValidatedString(oTaxonomyFieldValues); if (field.DefaultValue != validatedString) { field.DefaultValue = validatedString; field.Update(); } } else { SetDefaultValue(site, field, defaultValue[0], addIfDoesNotExist/*, out newTermAdded*/); } }
public TermSetLookup(TaxonomyField taxonomyField, TermSet termSet) { this.taxonomyField = taxonomyField; this.terms = termSet.GetAllTerms(); Program.clientContext.Load(this.terms, termsArg => termsArg.Include( termArg => termArg.Id, termArg => termArg.Name ) ); }
public static TaxonomyFieldValueCollection GetTaxonomyFieldValues(SPSite site, TaxonomyField field, string values, out List<int> wssIds) { if (values == null) throw new ArgumentNullException("values"); TaxonomySession taxonomySession = new TaxonomySession(site); TermStore termStore = taxonomySession.TermStores[field.SspId]; TermSet termSet = termStore.GetTermSet(field.TermSetId); TaxonomyFieldValueCollection termValues = new TaxonomyFieldValueCollection(field); termValues.AddRange(TaxonomyFieldControl.GetTaxonomyCollection(values)); wssIds = new List<int>(); foreach (TaxonomyFieldValue termValue in termValues) { wssIds.AddRange(TaxonomyField.GetWssIdsOfTerm(site, termStore.Id, termSet.Id, new Guid(termValue.TermGuid), false, 500)); } return termValues; }
public static void SetDefaultValue(SPSite site, TaxonomyField field, string defaultValue, bool addIfDoesNotExist/*, out bool newTermAdded*/) { if (field.AllowMultipleValues) { TaxonomyFieldValueCollection oTaxonomyFieldValues = GetTaxonomyFieldValues(site, field, new[] { defaultValue }, addIfDoesNotExist/*, out newTermAdded*/); string validatedString = field.GetValidatedString(oTaxonomyFieldValues); if (field.DefaultValue != validatedString) { field.DefaultValue = validatedString; field.Update(); } } else { TaxonomyFieldValue oTaxonomyFieldValue = GetTaxonomyFieldValue(site, field, defaultValue, addIfDoesNotExist/*, out newTermAdded*/); //string validatedString = field.GetValidatedString(oTaxonomyFieldValue); if (field.DefaultValue != oTaxonomyFieldValue.ValidatedString) { field.DefaultValue = oTaxonomyFieldValue.ValidatedString; field.Update(); } } }
static void CreateWingtipSiteColumns() { Console.WriteLine(); fieldProductCode = CreateSiteColumn("ProductCode", "Product Code", "Text"); fieldProductCode.EnforceUniqueValues = true; fieldProductCode.Indexed = true; fieldProductCode.Required = true; fieldProductCode.Update(); clientContext.ExecuteQuery(); clientContext.Load(fieldProductCode); clientContext.ExecuteQuery(); fieldProductDescription = clientContext.CastTo<FieldMultiLineText>(CreateSiteColumn("ProductDescription", "Product Description", "Note")); fieldProductDescription.NumberOfLines = 4; fieldProductDescription.RichText = false; fieldProductDescription.Update(); clientContext.ExecuteQuery(); fieldProductListPrice = clientContext.CastTo<FieldCurrency>(CreateSiteColumn("ProductListPrice", "List Price", "Currency")); fieldProductListPrice.MinimumValue = 0; fieldProductListPrice.Update(); clientContext.ExecuteQuery(); fieldProductCategory = clientContext.CastTo<TaxonomyField>(CreateSiteColumn("ProductCategory", "Product Category", "TaxonomyFieldType")); fieldProductCategory.SspId = localTermStoreID; fieldProductCategory.TermSetId = termSetId; fieldProductCategory.AllowMultipleValues = false; fieldProductCategory.Update(); clientContext.ExecuteQuery(); fieldProductColor = clientContext.CastTo<FieldMultiChoice>(CreateSiteColumn("ProductColor", "Product Color", "MultiChoice")); string[] choicesProductColor = { "White", "Black", "Grey", "Blue", "Red", "Green", "Yellow" }; fieldProductColor.Choices = choicesProductColor; fieldProductColor.Update(); clientContext.ExecuteQuery(); fieldMinimumAge = clientContext.CastTo<FieldNumber>(CreateSiteColumn("MinimumAge", "Minimum Age", "Number")); fieldMinimumAge.MinimumValue = 1; fieldMinimumAge.MaximumValue = 100; fieldMinimumAge.Update(); clientContext.ExecuteQuery(); fieldMaximumAge = clientContext.CastTo<FieldNumber>(CreateSiteColumn("MaximumAge", "Maximum Age", "Number")); fieldMaximumAge.MinimumValue = 1; fieldMaximumAge.MaximumValue = 100; fieldMaximumAge.Update(); clientContext.ExecuteQuery(); fieldProductImageUrl = clientContext.CastTo<FieldUrl>(CreateSiteColumn("ProductImageUrl", "Product Image Url", "URL")); fieldProductImageUrl.DisplayFormat = UrlFieldFormatType.Image; fieldProductImageUrl.Update(); clientContext.ExecuteQuery(); }
private static void InternalAssignTermSetToTaxonomyField(TermStore termStore, TaxonomyField field, string termStoreGroupName, string termSetName, string termSubsetName) { Group group = termStore.Groups[termStoreGroupName]; TermSet termSet = group.TermSets[termSetName]; // Connect to MMS field.SspId = termSet.TermStore.Id; field.TermSetId = termSet.Id; field.TargetTemplate = string.Empty; // Select a sub node of the termset to limit selection if (!string.IsNullOrEmpty(termSubsetName)) { Term term = termSet.GetTerms(termSubsetName, true)[0]; field.AnchorId = term.Id; } else { field.AnchorId = Guid.Empty; } field.Update(); }
private TaxonomyFieldValueCollection GetTaxonomyFieldValueCollection(TaxonomyField fieldToSet) { byte someData = 0; // Create a temporary item to create the proper TaxonomyHiddenList items necessary to initialize the WSSids for the folder metadata defaults string tempPageName = string.Format(CultureInfo.InvariantCulture, "Temp-{0}.aspx", Guid.NewGuid().ToString()); SPFile tempFile = ((SPDocumentLibrary)fieldToSet.ParentList).RootFolder.Files.Add(tempPageName, new byte[1] { someData }); SPListItem tempItem = tempFile.Item; SPContentType contentTypeWithField = FindContentTypeWithField(fieldToSet.ParentList.ContentTypes, fieldToSet); SPContentTypeId contentTypeId = contentTypeWithField.Id; tempItem[SPBuiltInFieldId.ContentTypeId] = contentTypeId; tempItem.Update(); // re-fetch temp item, now with proper content types tempItem = fieldToSet.ParentList.GetItemById(tempItem.ID); var itemField = tempItem.Fields[fieldToSet.Id] as TaxonomyField; TaxonomyFieldValueCollection fieldValues = new TaxonomyFieldValueCollection(fieldToSet); foreach (Term term in this.Terms) { TaxonomyFieldValue fieldValue = new TaxonomyFieldValue(fieldToSet); fieldValue.TermGuid = term.Id.ToString(); fieldValue.Label = term.Name; fieldValues.Add(fieldValue); } // Force population of field values to hit the TaxonomyHiddenList and generate some WSSid's itemField.SetFieldValue(tempItem, fieldValues); // Those taxonomy field values in the collection don't have a proper ValidatedString, but their WSSid's have been populated TaxonomyFieldValueCollection finalValue = tempItem[itemField.InternalName] as TaxonomyFieldValueCollection; // Clean up the temporary item tempFile.Delete(); return finalValue; }
private static void InternalAssignTermSetToTaxonomyField(TermStore termStore, TaxonomyField field, Guid termStoreGroupId, Guid termSetId, Guid termSubsetId) { Group group = termStore.Groups[termStoreGroupId]; TermSet termSet = group.TermSets[termSetId]; // Connect to MMS field.SspId = termSet.TermStore.Id; field.TermSetId = termSet.Id; field.TargetTemplate = string.Empty; // Select a sub node of the termset to limit selection field.AnchorId = Guid.Empty != termSubsetId ? termSubsetId : Guid.Empty; field.Update(); }
public static void SetDefaultTermValue(TermSet termSet, TaxonomyField field, string defaultTermValue) { Term defaultTerm = termSet.Terms[defaultTermValue]; if (null != defaultTerm) { field.DefaultValue = string.Format("1;#{0}|{1}", defaultTerm.Name, defaultTerm.Id); } field.Update(true); }
private static SPContentType FindContentTypeWithField(SPContentTypeCollection contentTypeCollection, TaxonomyField fieldToSet) { return contentTypeCollection.Cast<SPContentType>().FirstOrDefault(ct => { return ct.Fields.Cast<SPField>().Any(spField => spField.InternalName == fieldToSet.InternalName); }); }
public static void SetDefaultTermValue(Group group, TaxonomyField field, string defaultTermText) { TermSet termSet = group.TermSets[field.TermSetId]; if (null != termSet) { SetDefaultTermValue(termSet, field, defaultTermText); } }
public void SetDefaultTermValue(TermSet termSet, TaxonomyField field, string defaultTermValue) { SharePointUtilities.SetDefaultTermValue(termSet, field, defaultTermValue); }
private string GetTermIdForTaxonomyField(TaxonomyField field, string term, ListItem pendingItem,Microsoft.SharePoint.Client.File pendingFile) { if (_terms == null) _terms = new Dictionary<string, IDictionary<string, string>>(); if (!_terms.Keys.Contains(field.Title)) _terms[field.Title] = new Dictionary<string, string>(); if (_terms[field.Title].Keys.Contains(term)) return _terms[field.Title][term].ToString(); var termId = string.Empty; //before we go forward,save pending item pendingItem.Update(); ctx.Load(pendingFile); ctx.ExecuteQuery(); TaxonomySession tSession = TaxonomySession.GetTaxonomySession(ctx); ctx.Load(tSession.TermStores); ctx.ExecuteQuery(); TermStore ts = tSession.TermStores.First(); TermSet tset = ts.GetTermSet(field.TermSetId); LabelMatchInformation lmi = new LabelMatchInformation(ctx); lmi.Lcid = 1033; lmi.TrimUnavailable = true; lmi.TermLabel = term; TermCollection termMatches = tset.GetTerms(lmi); ctx.Load(tSession); ctx.Load(ts); ctx.Load(tset); ctx.Load(termMatches); ctx.ExecuteQuery(); if (termMatches != null && termMatches.Count() > 0) termId = termMatches.First().Id.ToString(); _terms[field.Title][term] = termId; return termId; }