// Create the TermSetGoal objects in the specified TermStore object.
static void SyncTermSet(TermStore termStore, TermSetGoal termSetGoal)
{
Group group = termStore.Groups.FirstOrDefault(g => g.Name == termSetGoal.GroupName);
if (group == null)
{
Log("* Creating missing group \"" + termSetGoal.GroupName + "\"");
group = termStore.CreateGroup(termSetGoal.GroupName);
}
TermSet termSet = termStore.GetTermSet(termSetGoal.Id);
if (termSet == null)
{
Log("* Creating missing term set \"" + termSetGoal.Name + "\"");
termSet = group.CreateTermSet(termSetGoal.Name, termSetGoal.Id, lcid);
}
else
{
if (termSet.Group.Id != group.Id)
{
Log("* Moving term set to group \"" + group.Name + "\"");
termSet.Move(group);
}
if (termSet.Name != termSetGoal.Name)
{
termSet.Name = termSetGoal.Name;
}
}
termStore.CommitAll();
// Load the tree of terms as a flat list.
Dictionary <Guid, Term> termsById = new Dictionary <Guid, Term>();
foreach (Term term in termSet.GetAllTerms())
{
termsById.Add(term.Id, term);
}
Log("Step 1: Adds and Moves");
ProcessAddsAndMoves(termSet, termSetGoal, termsById);
Log("Step 2: Deletes");
// Requery the TermSet object to reflect changes to the topology.
termSet = termStore.GetTermSet(termSetGoal.Id);
ProcessDeletes(termSet, termSetGoal); // Step 2
Log("Step 3: Property Updates");
termSet = termStore.GetTermSet(termSetGoal.Id);
ProcessPropertyUpdates(termSet, termSetGoal); // Step 3
termStore.CommitAll();
}
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>
/// 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();
}
// Create the goal objects in the specified term store
static void ImportTermSet(TermStore termStore, TermSetGoal termSetGoal)
{
Log("Setting up term set \"" + termSetGoal.Name + "\"");
Group group = termStore.Groups.FirstOrDefault(g => g.Name == termSetGoal.GroupName);
if (group == null)
{
Log("Creating missing group \"" + termSetGoal.GroupName + "\"");
group = termStore.CreateGroup(termSetGoal.GroupName);
}
TermSet termSet = termStore.GetTermSet(termSetGoal.Id);
if (termSet != null)
{
Log("Deleting existing term set \"" + termSetGoal.Name + "\"");
termSet.Delete();
termStore.CommitAll();
}
Log("Creating new term set \"" + termSetGoal.Name + "\"");
termSet = group.CreateTermSet(termSetGoal.Name, termSetGoal.Id);
termStore.CommitAll();
ImportTerms(termSet, termSetGoal);
termStore.CommitAll();
}
internal static List <SelectListItem> getTaxItems(ClientContext ctx)
{
List <SelectListItem> items = new List <SelectListItem>();
TermStore store = ctx.Site.GetDefaultKeywordsTermStore();
TermSet tset = store.GetTermSet("{3D4C7DE0-3867-44C3-871A-C36DEC4E1970}".ToGuid());
TermCollection terms = tset.Terms;
ctx.Load(terms);
ctx.Load(terms, tms => tms.Include(l => l.Labels));
ctx.ExecuteQuery();
foreach (Term t in terms)
{
SelectListItem item = new SelectListItem();
item.Value = t.Id.ToString();
item.Text = t.Labels.Where(l => l.Language == 1033).FirstOrDefault().Value;
items.Add(item);
}
return(items);
}
/// <summary>
/// Tokenizes the taxonomy field.
/// </summary>
/// <param name="web">The web.</param>
/// <param name="element">The element.</param>
/// <returns></returns>
protected string TokenizeTaxonomyField(Web web, XElement element)
{
// Replace Taxonomy field references to SspId, TermSetId with tokens
TaxonomySession session = TaxonomySession.GetTaxonomySession(web.Context);
TermStore store = session.GetDefaultSiteCollectionTermStore();
var sspIdElement = element.XPathSelectElement("./Customization/ArrayOfProperty/Property[Name = 'SspId']/Value");
if (sspIdElement != null)
{
sspIdElement.Value = "{sitecollectiontermstoreid}";
}
var termSetIdElement = element.XPathSelectElement("./Customization/ArrayOfProperty/Property[Name = 'TermSetId']/Value");
if (termSetIdElement != null)
{
Guid termSetId = Guid.Parse(termSetIdElement.Value);
if (termSetId != Guid.Empty)
{
Microsoft.SharePoint.Client.Taxonomy.TermSet termSet = store.GetTermSet(termSetId);
store.Context.ExecuteQueryRetry();
if (!termSet.ServerObjectIsNull())
{
termSet.EnsureProperties(ts => ts.Name, ts => ts.Group);
termSetIdElement.Value = String.Format("{{termsetid:{0}:{1}}}", termSet.Group.IsSiteCollectionGroup ? "{sitecollectiontermgroupname}" : termSet.Group.Name, termSet.Name);
}
}
}
return(element.ToString());
}
public static bool mk_NOR(TermStore termstore, string _group, string _termset, string _nor)
{
LogHelper logger = LogHelper.Instance;
bool _result = false;
try
{
TermSet termset = termstore.GetTermSet(GetIdTermSet(termstore, _group, _termset));
SPSecurity.RunWithElevatedPrivileges(delegate()
{
Term term = termset.CreateTerm(_nor, termstore.DefaultLanguage);
termset.TermStore.CommitAll();
});
_result = true;
logger.Log(string.Format("Normativa {0} creata nel Set {1}", _nor, _termset, LogSeverity.Debug));
}
catch (Exception ex)
{
_result = false;
logger.Log(ex.Message + " : " + string.Format("Normativa {0} non creata nel Set {1}", _nor, _termset, LogSeverity.Error));
}
return _result;
}
public static bool sp_NOR(TermStore termstore, string _group, string _termset, string _nor, string _p, string _v)
{
LogHelper logger = LogHelper.Instance;
bool _result = false;
try
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
Guid uidStore = new Guid(idStore);
TermSet termset = termstore.GetTermSet(GetIdTermSet(termstore, _group, _termset));
Term term = termset.Terms[_nor];
term.SetCustomProperty(_p, _v);
termset.TermStore.CommitAll();
});
_result = true;
logger.Log(string.Format("Proprietà {0} aggiunta nella Normativa {1} ", _p, _nor, LogSeverity.Debug));
}
catch (Exception ex)
{
_result = false;
logger.Log(ex.Message + " : " + string.Format("Proprietà {0} non aggiunta nella Normativa {1} ", _p, _nor, LogSeverity.Error));
}
return _result;
}
public static void CreateProductTaxonomy(ClientContext ctx)
{
TermStore store = ctx.Site.GetDefaultKeywordsTermStore();
TermGroup productCategoryGroup = store.GetTermGroupByName("OD2");
if (productCategoryGroup == null)
{
productCategoryGroup = store.CreateTermGroup("OD2", Constants.TAXONOMY_OD2_GROUP_ID.ToGuid(), "Stuff for od2");
}
TermSet ts = store.GetTermSet(Constants.TAXONOMY_PRODUCTCAT_TERMSET_ID.ToGuid());
ctx.Load(ts);
ctx.ExecuteQuery();
// if term store does not exist create a new one.
if (ts.ServerObjectIsNull.Value)
{
ts = productCategoryGroup.CreateTermSet("Product Category", Constants.TAXONOMY_PRODUCTCAT_TERMSET_ID.ToGuid(), 1033);
store.CommitAll();
ctx.Load(ts);
ctx.ExecuteQuery();
ts.CreateTerm("Prod Cat 1", 1033, Guid.NewGuid());
ts.CreateTerm("Prod Cat 2", 1033, Guid.NewGuid());
ts.CreateTerm("Prod Cat 3", 1033, Guid.NewGuid());
ts.CreateTerm("Prod Cat 4", 1033, Guid.NewGuid());
store.CommitAll();
ctx.ExecuteQuery();
}
}
public static bool mk_At(TermStore termstore, string _group, string _termset, string _am, string _pr, string _at)
{
LogHelper logger = LogHelper.Instance;
bool _result = false;
try
{
TermSet termset = termstore.GetTermSet(GetIdTermSet(termstore, _group, _termset));
Term term = termset.Terms[_am].Terms[_pr];
SPSecurity.RunWithElevatedPrivileges(delegate()
{
term.CreateTerm(_at, termstore.DefaultLanguage);
termset.TermStore.CommitAll();
});
_result = true;
logger.Log(string.Format("Attivita {0} creata nel processo {1} dell'ambito {2} nel set {3}", _pr, _am, _termset, LogSeverity.Debug));
}
catch (Exception ex)
{
_result = false;
logger.Log(ex.Message + " : " + string.Format("Attivita {0} creata nel processo {1} dell'ambito {2} nel set {3}", _at, _pr, _am, _termset, LogSeverity.Debug));
}
return _result;
}
public static string GetTermIdForTerm(string term, Guid termSetId, ClientContext clientContext)
{
string termId = string.Empty;
//Get term set from ID
TaxonomySession tSession = TaxonomySession.GetTaxonomySession(clientContext);
TermStore ts = tSession.GetDefaultSiteCollectionTermStore();
TermSet tset = ts.GetTermSet(termSetId);
LabelMatchInformation lmi = new LabelMatchInformation(clientContext);
lmi.Lcid = 1033;
lmi.TrimUnavailable = true;
lmi.TermLabel = term;
//Search for matching terms in the term set based on label
TermCollection termMatches = tset.GetTerms(lmi);
clientContext.Load(tSession);
clientContext.Load(ts);
clientContext.Load(tset);
clientContext.Load(termMatches);
clientContext.ExecuteQuery();
//Set term ID to first match
if (termMatches != null && termMatches.Count() > 0)
{
termId = termMatches.First().Id.ToString();
}
return(termId);
}
/// <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();
}
protected override void ProcessFieldProperties(SPField field, FieldDefinition fieldModel)
{
// let base setting be setup
base.ProcessFieldProperties(field, fieldModel);
// process taxonomy field specific properties
var taxField = field.WithAssertAndCast <TaxonomyField>("field", value => value.RequireNotNull());
var taxFieldModel = fieldModel.WithAssertAndCast <TaxonomyFieldDefinition>("model", value => value.RequireNotNull());
var site = GetCurrentSite();
var taxSession = new TaxonomySession(site);
TermStore tesmStore = null;
if (taxFieldModel.UseDefaultSiteCollectionTermStore == true)
{
tesmStore = taxSession.DefaultSiteCollectionTermStore;
}
else if (taxFieldModel.SspId.HasValue)
{
tesmStore = taxSession.TermStores[taxFieldModel.SspId.Value];
}
else if (!string.IsNullOrEmpty(taxFieldModel.SspName))
{
tesmStore = taxSession.TermStores[taxFieldModel.SspName];
}
TermSet termSet = null;
if (taxFieldModel.TermSetId.HasValue)
{
termSet = tesmStore.GetTermSet(taxFieldModel.TermSetId.Value);
}
else if (!string.IsNullOrEmpty(taxFieldModel.TermSetName))
{
termSet = tesmStore.GetTermSets(taxFieldModel.TermSetName, taxFieldModel.TermSetLCID).FirstOrDefault();
}
Term term = null;
if (taxFieldModel.TermId.HasValue)
{
term = tesmStore.GetTerm(taxFieldModel.TermId.Value);
}
else if (!string.IsNullOrEmpty(taxFieldModel.TermName))
{
term = tesmStore.GetTerms(taxFieldModel.TermName, taxFieldModel.TermLCID, false).FirstOrDefault();
}
taxField.SspId = tesmStore.Id;
if (termSet != null)
{
taxField.TermSetId = termSet.Id;
}
else if (term != null)
{
taxField.TermSetId = term.Id;
}
}
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;
}
}
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());
}
internal static bool CheckIfTermSetIdIsUnique(TermStore store, Guid id)
{
var existingTermSet = store.GetTermSet(id);
store.Context.Load(existingTermSet);
store.Context.ExecuteQueryRetry();
return(existingTermSet.ServerObjectIsNull == true);
}
public static NavigationTermSet CriarItemNaTermStore(string url, string urlweb, Guid NavTermSetId, Guid TaggingTermSetId)
{
SPSite site = new SPSite(url);
SPWeb web = site.AllWebs[urlweb];
TaxonomySession taxonomySession = new TaxonomySession(site);
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("O Serviço de taxonomia não existe");
}
TermStore termStore = taxonomySession.TermStores[0];
TermSet existingTermSet = termStore.GetTermSet(NavTermSetId);
if (existingTermSet != null)
{
existingTermSet.Delete();
termStore.CommitAll();
}
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(web.Site);
TermSet termSet = siteCollectionGroup.CreateTermSet("Teste01", NavTermSetId);
termStore.CommitAll();
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
termStore.CommitAll();
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "/en/Pages/default.aspx";
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink);
term1.SimpleLinkUrl = "http://h9j/pt/Paginas/default.aspx";
termStore.CommitAll();
/*
* NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl, Guid.NewGuid());
*
* term2.FriendlyUrlSegment.Value = "PAgInicial";
*
* term2.TargetUrl.Value = "/en/Pages/default.aspx";
*/
termStore.CommitAll();
return(navTermSet);
}
public ActionResult GetFields(string SelectedCT, string SPHostUrl)
{
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var ctx = spContext.CreateUserClientContextForSPHost())
{
List list = ctx.Web.Lists.GetByTitle("karlshamn");
ContentType contentTypeToEdit = list.ContentTypes.GetById(SelectedCT);
ctx.Load(list);
ctx.Load(contentTypeToEdit, include => include.Fields, include => include.Name);
ctx.ExecuteQuery();
TermStore store = ctx.Site.GetDefaultSiteCollectionTermStore();
//TermGroup group = store.GetTermGroupByName("Qian_OfficeAddin");
TermSet termSet = store.GetTermSet("08b6e1c6-d9ac-4014-bcbf-6e23987fb5c5".ToGuid());
ctx.Load(store);
//ctx.Load(group);
ctx.Load(termSet, include => include.Terms);
ctx.ExecuteQuery();
List <string> termList = new List <string>();
foreach (Term term in termSet.Terms)
{
termList.Add(term.Name);
}
ViewBag.Term = termList;
ViewBag.Term1 = "Meh";
List <string> fieldList = new List <string>();
foreach (Field item in contentTypeToEdit.Fields)
{
if (item.Group == "Karlshamn Fields")
{
fieldList.Add(item.Title);
}
}
FieldCollection fields = contentTypeToEdit.Fields;
ViewBag.Title = contentTypeToEdit.Name;
ViewBag.SelectedCT = SelectedCT;
ViewBag.SPHostUrl = SPHostUrl;
return(View(fields));
}
}
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);
}
private IEnumerable <NavigationNode> FilterNavigationNodesToRestrictedTermSet(SPWeb web, NavigationQueryParameters queryParameters, IEnumerable <NavigationNode> nodes, Term[] restrictedTerms = null)
{
// If first pass, initialize the restricted nodes with first level terms
if (restrictedTerms == null)
{
// Get restricted term set
var session = new TaxonomySession(web.Site);
TermStore termStore = null;
if (queryParameters.TermStoreId == Guid.Empty)
{
termStore = this.taxonomyHelper.GetDefaultSiteCollectionTermStore(session);
}
else
{
termStore = session.TermStores[queryParameters.TermStoreId];
}
var termSet = termStore.GetTermSet(queryParameters.RestrictedTermSetId);
var nodeMatchingSettings = queryParameters.NodeMatchingSettings;
if ((nodeMatchingSettings != null) && nodeMatchingSettings.RestrictToCurrentNavigationLevel)
{
var currentTermId = TaxonomyNavigationContext.Current.NavigationTerm.Id;
restrictedTerms = termSet.GetTerm(currentTermId).Parent.Terms.ToArray();
}
else
{
restrictedTerms = termSet.Terms.ToArray();
}
}
// Flattened navigation nodes for easier search
var flattenedNodes = nodes.Flatten(node => node.ChildNodes);
var restrictedNodes = restrictedTerms.Select(term => flattenedNodes.SingleOrDefault(node => node.Id.Equals(term.Id))).ToArray();
for (var i = 0; i < restrictedTerms.Length; i++)
{
var restrictedTerm = restrictedTerms[i];
var restrictedNode = restrictedNodes[i];
// If term contains children, recurvise call
if (restrictedTerm.Terms.Count > 0)
{
restrictedNode.ChildNodes = this.FilterNavigationNodesToRestrictedTermSet(web, queryParameters, nodes, restrictedTerm.Terms.ToArray());
}
else
{
restrictedNode.ChildNodes = new List <NavigationNode>();
}
}
return(restrictedNodes);
}
public static string SetReference(ClientContext ctx, TaxonomyFieldValueCollection tax, TaxonomyFieldValue typeDoc, int Id)
{
TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(ctx);
taxonomySession.UpdateCache();
TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore();
ctx.Load(termStore,
termStoreArg => termStoreArg.WorkingLanguage,
termStoreArg => termStoreArg.Id,
termStoreArg => termStoreArg.Groups.Include(
groupArg => groupArg.Id,
groupArg => groupArg.Name
)
);
Guid catTermId = new Guid(tax.ElementAt(0).TermGuid);
TermSet catTermSet = termStore.GetTermSet(new Guid("6792f6c1-20ec-4e10-a1e8-a2c04f2906ec"));
Term catTerm = catTermSet.GetTerm(catTermId);
ctx.Load(catTermSet);
ctx.Load(catTerm);
ctx.Load(catTerm.Labels);
// ctx.Load(catTerm.Parent.Labels);
Guid docTermId = new Guid(typeDoc.TermGuid);
TermSet docTermSet = termStore.GetTermSet(new Guid("40ae95fa-353f-4154-a574-65f7297286ca"));
Term docTerm = docTermSet.GetTerm(docTermId);
ctx.Load(docTermSet);
ctx.Load(docTerm);
ctx.Load(docTerm.Labels);
ctx.ExecuteQuery();
string reference = catTerm.Labels[1].Value + "/" + docTerm.Labels[1].Value + "/" + Id;
//if(catTerm.Parent.Labels.Count > 1)
//{
// reference = catTerm.Parent.Labels[1].Value + "/" + catTerm.Labels[1].Value + "/" + docTerm.Labels[1].Value + "/" + Id;
//}
return(reference);
}
/// <summary>Fixes the SP field taxonomy.</summary>
/// <param name="contextSpSite">The context sp site.</param>
/// <param name="fileSPListItem">The file sp list item.</param>
/// <param name="sourceValue">The source value.</param>
/// <returns>The fix sp field taxonomy.</returns>
private string FixSPFieldTaxonomy(SPSite contextSpSite, SPListItem fileSPListItem, string sourceValue)
{
string s = "\t\tTaxonomy\n\t\t-" + contextSpSite.Url + ",\n\t\t-" + sourceValue + "\n";
int lcid = CultureInfo.CurrentCulture.LCID;
// this is a managed metadata field
TaxonomyField taxonomyField = this.ContextSPField as TaxonomyField;
TaxonomySession taxonomySession = new TaxonomySession(contextSpSite);
TermStore termStore = taxonomySession.TermStores[taxonomyField.SspId];
TermSet termSet = termStore.GetTermSet(taxonomyField.TermSetId);
s += "\t\tlcid:\t\t" + lcid + "\n\t\ttaxField:\t" + taxonomyField.Title + "\n";
s += "\t\ttermstores:\t" + taxonomySession.TermStores.Count + "\n";
s += "\t\ttermstore:\t" + termStore.Name + "\n\t\ttermset:\t" + termSet.Name + "\n";
// this is Classification code; to be replaced with the one below!
Term myTerm = termSet.GetTerms(this.SubStringBefore(sourceValue, "|"), false).FirstOrDefault();
if (myTerm != null)
{
s += "\t\tmyTerm:\t\t" + myTerm.Name + "\n";
s += "\t\twas:" + fileSPListItem[this.ContextSPField.Id] + "\n";
string termString = String.Concat(myTerm.GetDefaultLabel(lcid),
TaxonomyField.TaxonomyGuidLabelDelimiter,
myTerm.Id);
int[] ids = TaxonomyField.GetWssIdsOfTerm(
contextSpSite,
termStore.Id,
termSet.Id,
myTerm.Id,
true,
1);
s += "\t\ttermString:\t" + termString + "\n\t\tids:\t\t" + ids.Length + "\n";
// set the WssId (TaxonomyHiddenList ID) to -1 so that it is added to the TaxonomyHiddenList
// fileSPListItem[this.ContextSPField.Id] = (ids.Length == 0) ? "-1;#" + termString : ids[0] + ";#" + termString;
if (ids.Length == 0)
{
termString = "-1;#" + termString;
}
else
{
termString = ids[0] + ";#" + termString;
}
fileSPListItem[this.ContextSPField.Id] = termString;
}
s += "\t\tis_:" + fileSPListItem[this.ContextSPField.Id] + "\n";
return(s);
}
public static NavigationTermSet RecreateSampleNavTermSet(TestContext testContext,
TaxonomySession taxonomySession, SPWeb web)
{
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): START");
// Use the first TermStore object in the list.
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("The Taxonomy Service is offline or missing.");
}
TermStore termStore = taxonomySession.TermStores[0];
// Does the TermSet object already exist?
TermSet existingTermSet = termStore.GetTermSet(TestConfig.NavTermSetId);
if (existingTermSet != null)
{
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): Deleting old TermSet");
existingTermSet.Delete();
termStore.CommitAll();
}
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): Creating new TermSet");
// Create a new TermSet object.
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(web.Site);
TermSet termSet = siteCollectionGroup.CreateTermSet("Navigation Demo", TestConfig.NavTermSetId);
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "~site/Pages/Topics/Topic.aspx";
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink);
term1.SimpleLinkUrl = "http://www.bing.com/";
NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl);
NavigationTerm term2a = term2.CreateTerm("Term 2 A", NavigationLinkType.FriendlyUrl);
NavigationTerm term2b = term2.CreateTerm("Term 2 B", NavigationLinkType.FriendlyUrl);
NavigationTerm term3 = navTermSet.CreateTerm("Term 3", NavigationLinkType.FriendlyUrl);
termStore.CommitAll();
Console.WriteLine(testContext, "RecreateSampleNavTermSet(): FINISH");
return(navTermSet);
}
private static Term GetTermByName(ClientContext ctx, string issueCategory)
{
TermStore store = ctx.Site.GetDefaultSiteCollectionTermStore();
TermSet termSet = store.GetTermSet("{3D4C7DE0-3867-44C3-871A-C36DEC4E1970}".ToGuid());
TermCollection terms = termSet.Terms;
ctx.Load(terms);
ctx.ExecuteQuery();
Term term = terms.Where(t => t.Name == issueCategory).FirstOrDefault();
return(term);
}
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);
}
/// <summary>
/// Extract all the terms from a termset for caching and quicker processing
/// </summary>
/// <param name="termSetId"></param>
/// <param name="context"></param>
/// <returns></returns>
public static Dictionary <Guid, TermData> GetAllTermsFromTermSet(Guid termSetId, ClientContext context)
{
//Use a source and target Dictionary<guid,string>
//Key = Id, Value = Path(e.g.termgroup | termset | term)
var termsCache = new Dictionary <Guid, TermData>();
try
{
using (var clonedContext = context.Clone(context.Web.GetUrl()))
{
TaxonomySession session = TaxonomySession.GetTaxonomySession(clonedContext);
TermStore termStore = session.GetDefaultSiteCollectionTermStore();
var termSet = termStore.GetTermSet(termSetId);
var termGroup = termSet.Group;
clonedContext.Load(termSet, t => t.Terms, t => t.Name);
clonedContext.Load(termGroup, g => g.Name);
clonedContext.ExecuteQueryRetry();
var termGroupName = termGroup.Name;
var setName = termSet.Name;
var termSetPath = $"{termGroupName}{TermTransformator.TermNodeDelimiter}{setName}";
foreach (var term in termSet.Terms)
{
var termName = term.Name;
var termPath = $"{termSetPath}{TermNodeDelimiter}{termName}";
termsCache.Add(term.Id,
new TermData()
{
TermGuid = term.Id, TermLabel = termName, TermPath = termPath, TermSetId = termSetId
});
if (term.TermsCount > 0)
{
var subTerms = ParseSubTerms(termPath, term, termSetId, clonedContext);
//termsCache
foreach (var foundTerm in subTerms)
{
termsCache.Add(foundTerm.Key, foundTerm.Value);
}
}
}
}
}
catch (Exception)
{
//TODO: Record any failure
}
return(termsCache);
}
public static TermSet LookupTermSet(TermStore tesmStore, string termSetName, Guid?termSetId, int termSetLCID)
{
if (termSetId.HasGuidValue())
{
return(tesmStore.GetTermSet(termSetId.Value));
}
if (!string.IsNullOrEmpty(termSetName))
{
return(tesmStore.GetTermSets(termSetName, termSetLCID).FirstOrDefault());
}
return(null);
}
public static NavigationTermSet CriarItemNaTermStore(string url, string urlweb, Guid NavTermSetId, Guid TaggingTermSetId)
{
SPSite site = new SPSite(url);
SPWeb web = site.AllWebs[url];
TaxonomySession taxonomySession = new TaxonomySession(site);
if (taxonomySession.TermStores.Count == 0)
{
throw new InvalidOperationException("O Serviço de taxonomia não existe");
}
TermStore termStore = taxonomySession.TermStores[0];
TermSet existingTermSet = termStore.GetTermSet(NavTermSetId);
if (existingTermSet != null)
{
existingTermSet.Delete();
termStore.CommitAll();
}
Group siteCollectionGroup = termStore.GetSiteCollectionGroup(web.Site);
TermSet termSet = siteCollectionGroup.CreateTermSet("Teste01", NavTermSetId);
NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, web,
StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider);
navTermSet.IsNavigationTermSet = true;
navTermSet.TargetUrlForChildTerms.Value = "~site/Pages/Topics/Topic.aspx";
NavigationTerm term1 = navTermSet.CreateTerm("Term 1", NavigationLinkType.SimpleLink);
term1.SimpleLinkUrl = "https://ekisiot.sharepoint.com/";
NavigationTerm term2 = navTermSet.CreateTerm("Term 2", NavigationLinkType.FriendlyUrl);
NavigationTerm term2a = term2.CreateTerm("Term 2 A", NavigationLinkType.FriendlyUrl);
NavigationTerm term2b = term2.CreateTerm("Term 2 B", NavigationLinkType.FriendlyUrl);
NavigationTerm term3 = navTermSet.CreateTerm("Term 3", NavigationLinkType.FriendlyUrl);
termStore.CommitAll();
return(navTermSet);
}
public static TaxonomyFieldValueCollection GetTaxonomyFieldValues(SPSite site, Guid sspId, Guid termSetId, IEnumerable <string> values, bool addIfDoesNotExist /*, out bool newTermsAdded*/)
{
bool newTermsAdded;
TaxonomySession taxonomySession = new TaxonomySession(site);
TermStore termStore = taxonomySession.TermStores[sspId];
TermSet termSet = termStore.GetTermSet(termSetId);
TaxonomyFieldValueCollection val = GetTaxonomyFieldValues(termSet, values, addIfDoesNotExist, out newTermsAdded);
if (newTermsAdded)
{
termStore.CommitAll();
}
return(val);
}
private static TermSet AddTermSet(ClientContext clientContext, TermStore termStore, TermGroup termGroup)
{
var termSetId = new Guid("56ca0eea-635e-4cc1-ac35-fc2040f4cfe5");
var termSet = termStore.GetTermSet(termSetId);
clientContext.Load(termSet, ts => ts.Terms);
clientContext.ExecuteQuery();
if (termSet.ServerObjectIsNull.Value)
{
termSet = termGroup.CreateTermSet("Taxonomy Navigation", termSetId, 1033);
termSet.SetCustomProperty("_Sys_Nav_IsNavigationTermSet", "True");
clientContext.Load(termSet, ts => ts.Terms);
clientContext.ExecuteQuery();
}
return termSet;
}
public static TermSet LookupTermSet(ClientRuntimeContext context, TermStore termStore,
string termSetName, Guid?termSetId, int termSetLCID)
{
var storeContext = context;
if (!string.IsNullOrEmpty(termSetName))
{
var termSets = termStore.GetTermSetsByName(termSetName, termSetLCID);
storeContext.Load(termSets);
storeContext.ExecuteQueryWithTrace();
return(termSets.FirstOrDefault());
}
if (termSetId.HasGuidValue())
{
TermSet termSet = null;
var scope = new ExceptionHandlingScope(storeContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
termSet = termStore.GetTermSet(termSetId.Value);
storeContext.Load(termSet);
}
using (scope.StartCatch())
{
}
}
storeContext.ExecuteQueryWithTrace();
if (termSet != null && termSet.ServerObjectIsNull == false)
{
storeContext.Load(termSet, g => g.Id);
storeContext.ExecuteQueryWithTrace();
return(termSet);
}
}
return(null);
}
public static TermSet LookupTermSet(ClientRuntimeContext context, TermStore termStore,
Site site,
string termGroupName, Guid? termGroupId, bool? isSiteCollectionGroup,
string termSetName, Guid? termSetId, int termSetLCID)
{
var storeContext = context;
TermGroup currenGroup = null;
if (!string.IsNullOrEmpty(termGroupName))
{
currenGroup = termStore.Groups.GetByName(termGroupName);
storeContext.Load(currenGroup);
storeContext.ExecuteQueryWithTrace();
}
else if (termGroupId != null && termGroupId.HasGuidValue())
{
currenGroup = termStore.Groups.GetById(termGroupId.Value);
storeContext.Load(currenGroup);
storeContext.ExecuteQueryWithTrace();
}
else if (isSiteCollectionGroup == true)
{
currenGroup = termStore.GetSiteCollectionGroup(site, false);
storeContext.Load(currenGroup);
storeContext.ExecuteQueryWithTrace();
}
if (!string.IsNullOrEmpty(termSetName))
{
if (currenGroup != null && (currenGroup.ServerObjectIsNull == false))
{
TermSet termSet = null;
var scope = new ExceptionHandlingScope(storeContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
termSet = currenGroup.TermSets.GetByName(termSetName);
storeContext.Load(termSet);
}
using (scope.StartCatch())
{
}
}
storeContext.ExecuteQueryWithTrace();
if (termSet != null && termSet.ServerObjectIsNull == false)
{
storeContext.Load(termSet, g => g.Id);
storeContext.ExecuteQueryWithTrace();
return termSet;
}
}
else
{
var termSets = termStore.GetTermSetsByName(termSetName, termSetLCID);
storeContext.Load(termSets);
storeContext.ExecuteQueryWithTrace();
return termSets.FirstOrDefault();
}
}
if (termSetId.HasGuidValue())
{
if (currenGroup != null && (currenGroup.ServerObjectIsNull == false))
{
TermSet termSet = null;
var scope = new ExceptionHandlingScope(storeContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
termSet = currenGroup.TermSets.GetById(termSetId.Value);
storeContext.Load(termSet);
}
using (scope.StartCatch())
{
}
}
storeContext.ExecuteQueryWithTrace();
if (termSet != null && termSet.ServerObjectIsNull == false)
{
storeContext.Load(termSet, g => g.Id);
storeContext.ExecuteQueryWithTrace();
return termSet;
}
}
else
{
TermSet termSet = null;
var scope = new ExceptionHandlingScope(storeContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
termSet = termStore.GetTermSet(termSetId.Value);
storeContext.Load(termSet);
}
using (scope.StartCatch())
{
}
}
storeContext.ExecuteQueryWithTrace();
if (termSet != null && termSet.ServerObjectIsNull == false)
{
storeContext.Load(termSet, g => g.Id);
storeContext.ExecuteQueryWithTrace();
return termSet;
}
}
}
return null;
}
public static TermSet LookupTermSet(
TermStore tesmStore,
string termGroupName, Guid? groupId, bool? isSiteCollectionGroup, SPSite site,
string termSetName, Guid? termSetId, int termSetLCID)
{
Group currentGroup = null;
if (!string.IsNullOrEmpty(termGroupName))
{
currentGroup = tesmStore.Groups.FirstOrDefault(g => g.Name.ToUpper() == termGroupName.ToUpper());
}
else if (groupId != null && groupId.HasGuidValue())
{
currentGroup = tesmStore.GetGroup(groupId.Value);
}
else if (isSiteCollectionGroup.HasValue && isSiteCollectionGroup.Value)
{
currentGroup = tesmStore.GetSiteCollectionGroup(site);
}
if (termSetId.HasGuidValue())
{
if (currentGroup != null)
return currentGroup.TermSets.FirstOrDefault(t => t.Id == termSetId.Value);
return tesmStore.GetTermSet(termSetId.Value);
}
if (!string.IsNullOrEmpty(termSetName))
{
if (currentGroup != null)
return currentGroup.TermSets.FirstOrDefault(t => t.Name.ToUpper() == termSetName.ToUpper());
return tesmStore.GetTermSets(termSetName, termSetLCID).FirstOrDefault();
}
return null;
}
public static TermSet LookupTermSet(TermStore tesmStore, string termSetName, Guid? termSetId, int termSetLCID)
{
if (termSetId.HasGuidValue())
return tesmStore.GetTermSet(termSetId.Value);
if (!string.IsNullOrEmpty(termSetName))
return tesmStore.GetTermSets(termSetName, termSetLCID).FirstOrDefault();
return null;
}
public static TermSet LookupTermSet(ClientRuntimeContext context, TermStore termStore,
string termSetName, Guid? termSetId, int termSetLCID)
{
var storeContext = context;
if (!string.IsNullOrEmpty(termSetName))
{
var termSets = termStore.GetTermSetsByName(termSetName, termSetLCID);
storeContext.Load(termSets);
storeContext.ExecuteQueryWithTrace();
return termSets.FirstOrDefault();
}
if (termSetId.HasGuidValue())
{
TermSet termSet = null;
var scope = new ExceptionHandlingScope(storeContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
termSet = termStore.GetTermSet(termSetId.Value);
storeContext.Load(termSet);
}
using (scope.StartCatch())
{
}
}
storeContext.ExecuteQueryWithTrace();
if (termSet != null && termSet.ServerObjectIsNull == false)
{
storeContext.Load(termSet, g => g.Id);
storeContext.ExecuteQueryWithTrace();
return termSet;
}
}
return null;
}
/// <summary>
/// Exports the full list of terms from all termsets in all termstores.
/// </summary>
/// <param name="site">The site to export the termsets from</param>
/// <param name="termSetId">The ID of the termset to export</param>
/// <param name="includeId">if true, Ids of the the taxonomy items will be included</param>
/// <param name="termStore">The term store to export the termset from</param>
/// <param name="delimiter">if specified, this delimiter will be used. Notice that IDs will be delimited with ;# from the label</param>
/// <returns></returns>
public static List<string> ExportTermSet(this Site site, Guid termSetId, bool includeId, TermStore termStore, string delimiter = "|")
{
var clientContext = site.Context;
var termsString = new List<string>();
TermCollection terms = null;
if (termSetId != Guid.Empty)
{
var termSet = termStore.GetTermSet(termSetId);
terms = termSet.Terms;
clientContext.Load(terms, t => t.IncludeWithDefaultProperties(s => s.TermSet), t => t.IncludeWithDefaultProperties(s => s.TermSet.Group));
}
clientContext.ExecuteQueryRetry();
if (terms.Any())
{
foreach (var term in terms)
{
var groupName = DenormalizeName(term.TermSet.Group.Name);
var termsetName = DenormalizeName(term.TermSet.Name);
var termName = DenormalizeName(term.Name);
clientContext.ExecuteQueryRetry();
var groupPath = string.Format("{0}{1}", groupName, (includeId) ? string.Format(";#{0}", term.TermSet.Group.Id.ToString()) : "");
var termsetPath = string.Format("{0}{1}", termsetName, (includeId) ? string.Format(";#{0}", term.TermSet.Id.ToString()) : "");
var termPath = string.Format("{0}{1}", termName, (includeId) ? string.Format(";#{0}", term.Id.ToString()) : "");
termsString.Add(string.Format("{0}{3}{1}{3}{2}", groupPath, termsetPath, termPath, delimiter));
if (term.TermsCount > 0)
{
var subTermPath = string.Format("{0}{3}{1}{3}{2}", groupPath, termsetPath, termPath, delimiter);
termsString.AddRange(ParseSubTerms(subTermPath, term, includeId, delimiter, clientContext));
}
termsString.Add(string.Format("{0}{3}{1}{3}{2}", groupPath, termsetPath, termPath, delimiter));
}
}
return termsString.Distinct().ToList<string>();
}
