// 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(); }
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 void CreateProductCategoriesTermset() { string termSetName = "Product Categories"; var aspnetHttpContext = System.Web.HttpContext.Current; var spContext = SharePointContextProvider.Current.GetSharePointContext(aspnetHttpContext); using (var clientContext = spContext.CreateUserClientContextForSPHost()) { if (clientContext != null) { Site siteCollection = clientContext.Site; clientContext.Load(siteCollection, sc => sc.Url); clientContext.ExecuteQuery(); TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext); taxonomySession.UpdateCache(); clientContext.Load(taxonomySession, ts => ts.TermStores); clientContext.ExecuteQuery(); TermStore termStore = taxonomySession.TermStores.FirstOrDefault <TermStore>(); Guid localTermStoreID = termStore.Id; TermGroup group = termStore.GetSiteCollectionGroup(siteCollection, true); clientContext.Load(group); clientContext.Load(group.TermSets); clientContext.ExecuteQuery(); // make sure it's deleted if exists foreach (TermSet termset in group.TermSets) { if (termset.Name.Equals(termSetName)) { termset.DeleteObject(); termStore.CommitAll(); clientContext.ExecuteQuery(); } } Guid termSetId = Guid.NewGuid(); TermSet tset = group.CreateTermSet(termSetName, termSetId, 1033); termStore.CommitAll(); clientContext.ExecuteQuery(); foreach (var term in terms) { CreateTopLevelTerm(tset, term); } termStore.CommitAll(); clientContext.ExecuteQuery(); clientContext.ExecuteQuery(); termStore.CommitAll(); } } }
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); }
// 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(); }
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 void CrearTermino(ref TermStore termStore, ref TermSet termSet, string[] arbol, ref Term termResult, string cadenaAnterior, int j, int lcid) { if (j == 0) { termResult = termSet.CreateTerm(arbol[j], lcid); termStore.CommitAll(); } else { Term termPadre = new List <Term>(termSet.GetTerms(arbol[j - 1], false, StringMatchOption.ExactMatch, 100000, false)).Find(t => t.GetPath().ToLower().Equals(cadenaAnterior.Remove(cadenaAnterior.Length - 1, 1).ToLower())); termResult = termPadre.CreateTerm(arbol[j], lcid); termStore.CommitAll(); } }
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); }
private static void GenerateDefaultTaxonomyTreeFromXMLFile(SPSite site) { using (site) { TaxonomySession taxonomySession = new TaxonomySession(site); TermStore termStore = taxonomySession.DefaultSiteCollectionTermStore; if (termStore != null) { TermStore = termStore; var web = site.RootWeb; XmlDocument document = new XmlDocument(); SPFile file = web.GetFile(String.Format("{0}/{1}", web.Url, valueSource)); using (Stream fileStream = file.OpenBinaryStream()) { document.Load(fileStream); fileStream.Close(); } GetNodes((XmlNode)document.DocumentElement); try { CreateTaxonomyTree(); TermStore.CommitAll(); } catch (Exception ex) { } } } }
protected override void ExecuteCmdlet() { var taxonomySession = TaxonomySession.GetTaxonomySession(ClientContext); // Get Term Store TermStore termStore = null; if (TermStore == null) { termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); } else { termStore = TermStore.GetTermStore(taxonomySession); } Term term = null; if (ParameterSetName == ParameterSet_TERMID) { term = Identity.GetTerm(ClientContext, termStore, null, false, null); } else { var termGroup = TermGroup.GetGroup(termStore); var termSet = TermSet.GetTermSet(termGroup); term = Identity.GetTerm(ClientContext, termStore, termSet, false, null); } if (ShouldProcess($"Delete term {term.Name} with id {term.Id}")) { term.DeleteObject(); termStore.CommitAll(); ClientContext.ExecuteQueryRetry(); } }
public void Import(TermStore parentTermStore) { if (parentTermStore == null) { throw new ArgumentNullException("parentTermStore", "The parent TermStore object is null."); } if (_xml.DocumentElement.Name == "Groups") { XmlNodeList groupNodes = _xml.SelectNodes("./Groups/Group"); if (groupNodes == null || groupNodes.Count == 0) { return; } foreach (XmlElement groupElement in groupNodes) { Import(groupElement, parentTermStore); } } else if (_xml.DocumentElement.Name == "Group") { Import(_xml.DocumentElement, parentTermStore); } parentTermStore.CommitAll(); }
/// <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(); }
/// <summary> /// Create client terms /// </summary> /// <param name="TermsData">Data for client terms</param> /// <param name="clientContext">Client Context object</param> private static void CreateTermsForClients(List <CustomClientGroup> TermsData, ClientContext clientContext) { TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext); clientContext.Load(taxonomySession.TermStores); //Execute the query to the server clientContext.ExecuteQuery(); TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); clientContext.Load(termStore.Groups); //Execute the query to the server clientContext.ExecuteQuery(); foreach (CustomClientGroup cltGroup in TermsData) { TermGroup group = termStore.Groups.Where(termGroup => termGroup.Name == cltGroup.name).Count() > 0 ? termStore.Groups.GetByName(cltGroup.name) : termStore.CreateGroup(cltGroup.name, Guid.NewGuid()); if (null != group) { TermSet cltTermSet = group.CreateTermSet(ConfigurationManager.AppSettings["clientterm"], Guid.NewGuid(), 1033); TermSet cltIDTermSet = group.CreateTermSet(ConfigurationManager.AppSettings["clientidterm"], Guid.NewGuid(), 1033); foreach (ClientList clients in cltGroup.clt) { Term clientCustom = cltTermSet.CreateTerm(clients.ClientName, 1033, Guid.NewGuid()); cltIDTermSet.CreateTerm(clients.ClientID, 1033, Guid.NewGuid()); clientCustom.SetCustomProperty("ClientID", clients.ClientID); clientCustom.SetCustomProperty("ClientURL", clients.ClientURL); } } } termStore.CommitAll(); clientContext.Load(termStore); //Execute the query to the server clientContext.ExecuteQuery(); }
public void Import(TermStore parentTermStore) { if (parentTermStore == null || parentTermStore.ServerObjectIsNull.Value) { throw new ArgumentNullException("parentTermStore", "The parent TermStore object is null."); } LoadWorkingLanguage(parentTermStore); if (_xml.DocumentElement.Name == "Groups") { XmlNodeList groupNodes = _xml.SelectNodes("./Groups/Group"); if (groupNodes == null || groupNodes.Count == 0) { return; } foreach (XmlElement groupElement in groupNodes) { Import(groupElement, parentTermStore); } } else if (_xml.DocumentElement.Name == "Group") { Import(_xml.DocumentElement, parentTermStore); } parentTermStore.CommitAll(); parentTermStore.Context.ExecuteQuery(); }
/// <summary> /// An item is being deleted. /// </summary> public override void ItemDeleting(SPItemEventProperties properties) { try { SPSecurity.RunWithElevatedPrivileges(delegate() { TaxonomySession session = new TaxonomySession(properties.Web.Site); TermStore mainTermStore = session.TermStores[0]; Group siteGroup = mainTermStore.GetSiteCollectionGroup(properties.Web.Site); TermSet issuingCompanyTermSet = GetTermSetByName("Issuing Company", siteGroup); if (issuingCompanyTermSet != null) { string newTerm = properties.ListItem["Title"].ToString(); Term matchingTerm = GetTermByName(newTerm, issuingCompanyTermSet); if (matchingTerm != null) { if (!matchingTerm.IsDeprecated) { matchingTerm.Deprecate(true); mainTermStore.CommitAll(); } } } else { throw new Exception("There was an error connecting to the SharePoint Managed Metadata Service"); } }); } catch (Exception taxonomyException) { properties.ErrorMessage = taxonomyException.Message; properties.Status = SPEventReceiverStatus.CancelWithError; } }
// 7. Crear el código en la función Main que cree los grupos, términos y los enlace para la navegación static void Main(string[] args) { SPSecurity.RunWithElevatedPrivileges( () => { using (SPSite site = new SPSite("http://" + sphost + "/sites/publicacion")) { TaxonomySession session = new TaxonomySession(site); TermStore termStore = session.TermStores["Managed Metadata Service"]; Group group = CreateGroup(termStore, "Navigation"); CreateNavigationTermSet(group, "Intranet"); TermSet s_termSet = group.TermSets["Intranet"]; CreateNavigationTerms(s_termSet); CreateNavigationTermSet(group, "Team"); TermSet t_termSet = group.TermSets["Team"]; PinTermSet(s_termSet, t_termSet); termStore.CommitAll(); } using (SPSite site = new SPSite("http://" + sphost + "/sites/publicacion")) { SetManagedNavigation(site, "Navigation", "Intranet"); } }); }
public static bool MakeTermSet(TermStore termstore, string _group, string _termset) { LogHelper logger = LogHelper.Instance; bool _result = false; try { SPSecurity.RunWithElevatedPrivileges(delegate() { Guid termSetId = Guid.NewGuid(); Guid uidStore = GetIdTermStoreGroup(termstore, _group); termstore.GetGroup(uidStore).CreateTermSet(_termset, termSetId, termstore.DefaultLanguage); termstore.CommitAll(); }); _result = true; logger.Log(string.Format("Set Termini {0} creato nel Gruppo {1}", _termset, _group, LogSeverity.Debug)); } catch (Exception ex) { _result = false; logger.Log(ex.Message + " : " + string.Format("Set Termini {0} non creato nel Gruppo {1}", _termset, _group, LogSeverity.Error)); } return _result; }
/// <summary> /// Creates child terms for the current model term if any exist /// </summary> /// <param name="web"></param> /// <param name="modelTerm"></param> /// <param name="term"></param> /// <param name="termStore"></param> /// <param name="parser"></param> /// <param name="scope"></param> /// <returns>Updated parser object</returns> private TokenParser CreateChildTerms(Web web, Model.Term modelTerm, Term term, TermStore termStore, TokenParser parser, PnPMonitoredScope scope) { if (modelTerm.Terms.Any()) { foreach (var modelTermTerm in modelTerm.Terms) { web.Context.Load(term.Terms); web.Context.ExecuteQueryRetry(); var termTerms = term.Terms; if (termTerms.Any()) { var termTerm = termTerms.FirstOrDefault(t => t.Id == modelTermTerm.Id); if (termTerm == null) { termTerm = termTerms.FirstOrDefault(t => t.Name == modelTermTerm.Name); if (termTerm == null) { var returnTuple = CreateTerm <Term>(web, modelTermTerm, term, termStore, parser, scope); if (returnTuple != null) { modelTermTerm.Id = returnTuple.Item1; parser = returnTuple.Item2; } } else { modelTermTerm.Id = termTerm.Id; } } else { modelTermTerm.Id = termTerm.Id; } } else { var returnTuple = CreateTerm <Term>(web, modelTermTerm, term, termStore, parser, scope); if (returnTuple != null) { modelTermTerm.Id = returnTuple.Item1; parser = returnTuple.Item2; } } } if (modelTerm.Terms.Any(t => t.CustomSortOrder > -1)) { var sortedTerms = modelTerm.Terms.OrderBy(t => t.CustomSortOrder); var customSortString = sortedTerms.Aggregate(string.Empty, (a, i) => a + i.Id.ToString() + ":"); customSortString = customSortString.TrimEnd(new[] { ':' }); term.CustomSortOrder = customSortString; termStore.CommitAll(); } } return(parser); }
protected override void ExecuteCmdlet() { var taxonomySession = TaxonomySession.GetTaxonomySession(ClientContext); // Get Term Store TermStore termStore = null; if (TermStore == null) { termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); } else { termStore = TermStore.GetTermStore(taxonomySession); } var termGroup = TermGroup.GetGroup(termStore); if (Id == Guid.Empty) { Id = Guid.NewGuid(); } var termSet = termGroup.CreateTermSet(Name, Id, Lcid); ClientContext.Load(termSet); ClientContext.ExecuteQueryRetry(); termSet.Contact = Contact; termSet.Description = Description; termSet.IsOpenForTermCreation = IsOpenForTermCreation; var customProperties = CustomProperties ?? new Hashtable(); foreach (var key in customProperties.Keys) { termSet.SetCustomProperty(key as string, customProperties[key] as string); } if (IsNotAvailableForTagging) { termSet.IsAvailableForTagging = false; } if (!string.IsNullOrEmpty(Owner)) { termSet.Owner = Owner; } if (StakeHolders != null) { foreach (var stakeHolder in StakeHolders) { termSet.AddStakeholder(stakeHolder); } } termStore.CommitAll(); ClientContext.ExecuteQueryRetry(); WriteObject(termSet); }
private static void AplicarOrdenVerdes(SPWeb web, Term term, string guid) { ResultTable resultTable = RealizarBusqueda(guid); int contador = 0; List <DocumentoSharePoint> primerOrden = OrdenarResultados(resultTable); foreach (DocumentoSharePoint doc in primerOrden) { contador++; Console.WriteLine(doc.Path + " " + contador + "/" + primerOrden.Count); SPListItem item = web.GetFile(doc.Path).Item; if (item.File.CheckOutType == SPFile.SPCheckOutType.None) { TaxonomyField campo = (TaxonomyField)item.Fields.GetField(field); int orden = contador * 100; Console.WriteLine(orden); item[campoOrden] = orden; AplicarTerminoVerdes(term, doc.Path, item, orden); } else { logDesprotegidos.WriteLine("Documento Desprotegido: " + doc.Path); } } if (ramaVirgen) { var borrables = term.Terms.Select(g => new { Guid = g.Id, Path = g.GetPath() }); foreach (var borrar in borrables) { try { Console.WriteLine("Se borrá: " + borrar.Path); logProceso.WriteLine("Se borrá: " + borrar.Path); termStore.GetTerm(borrar.Guid).Delete(); termStore.CommitAll(); } catch (Exception ex) { Console.WriteLine("Error borrando el siguiente término: " + borrar.Path + " " + ex.Message); logProceso.WriteLine("Error borrando el siguiente término: " + borrar.Path + " " + ex.Message); } } } }
private bool CreateStructureForTermSet(TermStore oStore, string termSetName, int lcid = 1045) { Group oGroup = oStore.Groups[TermStoreGroupName]; TermSet oTerms = oGroup.TermSets[termSetName]; CreateOrUpdateTerms(oTerms, Data[termSetName], lcid); oStore.CommitAll(); return(true); }
public void Import(TaxonomySession ts) { if (ts == null) { throw new ArgumentNullException("ts", "The TaxonomySession object is null."); } XmlNodeList termStoreNodes = _xml.SelectNodes("//TermStore"); if (termStoreNodes == null || termStoreNodes.Count == 0) { return; } var termStores = ts.TermStores; _ctx.Load(termStores); _ctx.ExecuteQuery(); foreach (XmlElement termStoreElement in termStoreNodes) { TermStore termStore = null; if (termStoreNodes.Count == 1 && termStores.Count == 1) { termStore = termStores[0]; } else { string termStoreName = termStoreElement.GetAttribute("Name"); termStore = ts.TermStores.GetByName(termStoreName); _ctx.ExecuteQuery(); if (termStore == null || termStore.ServerObjectIsNull.Value) { _cmdlet.WriteWarning(string.Format("Unable to locate target Term Store: {0}", termStoreName)); continue; } } LoadWorkingLanguage(termStore); _cmdlet.WriteVerbose(string.Format("Importing into Term Store: {0}", termStore.Name)); XmlNodeList groupNodes = termStoreElement.SelectNodes("./Groups/Group"); if (groupNodes == null || groupNodes.Count == 0) { _cmdlet.WriteWarning("No Group elements were defined in the import file for the Term Store."); continue; } foreach (XmlElement groupElement in groupNodes) { Import(groupElement, termStore); } termStore.CommitAll(); termStore.Context.ExecuteQuery(); } }
protected override void ExecuteCmdlet() { var taxonomySession = TaxonomySession.GetTaxonomySession(ClientContext); // Get Term Store TermStore termStore = null; if (TermStore == null) { termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); } else { termStore = TermStore.GetTermStore(taxonomySession); } termStore.EnsureProperty(ts => ts.DefaultLanguage); TermGroup termGroup = TermGroup.GetGroup(termStore); TermSet termSet = TermSet.GetTermSet(termGroup); if (Id == Guid.Empty) { Id = Guid.NewGuid(); } var termName = TaxonomyExtensions.NormalizeName(Name); if (!ParameterSpecified(nameof(Lcid))) { Lcid = termStore.EnsureProperty(ts => ts.DefaultLanguage); } var term = termSet.CreateTerm(termName, Lcid, Id); ClientContext.Load(term); ClientContext.ExecuteQueryRetry(); term.SetDescription(Description, Lcid); var customProperties = CustomProperties ?? new Hashtable(); foreach (var key in customProperties.Keys) { term.SetCustomProperty(key as string, customProperties[key] as string); } var localCustomProperties = LocalCustomProperties ?? new Hashtable(); foreach (var key in localCustomProperties.Keys) { term.SetLocalCustomProperty(key as string, localCustomProperties[key] as string); } termStore.CommitAll(); ClientContext.Load(term); ClientContext.ExecuteQueryRetry(); WriteObject(term); }
protected override void ExecuteCmdlet() { var taxonomySession = TaxonomySession.GetTaxonomySession(ClientContext); TermStore termStore = null; if (TermStore == null) { termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); } else { termStore = TermStore.GetTermStore(taxonomySession); } termStore.EnsureProperty(ts => ts.Languages); Term term = null; if (ParameterSetName == ParameterSet_BYID) { term = Term.GetTerm(ClientContext, termStore, null, false, null); } else { var termGroup = TermGroup.GetGroup(termStore); var termSet = TermSet.GetTermSet(termGroup); term = Term.GetTerm(ClientContext, termStore, termSet, false, null); } if (term != null) { term.EnsureProperties(t => t.Name, t => t.Id); if (ShouldProcess($"Delete label {Label} for language {Lcid} from Term {term.Name} with id {term.Id}")) { var labels = term.GetAllLabels(Lcid); ClientContext.Load(labels); ClientContext.ExecuteQueryRetry(); var label = labels.FirstOrDefault(l => l.Value == Label); if (label != null) { label.DeleteObject(); termStore.CommitAll(); ClientContext.ExecuteQueryRetry(); } else { throw new PSArgumentException($"Label {Label} not found for language {Lcid}"); } } } }
private static void ProcessGroup(XmlNode termGroup) { if (termGroup != null) { string strGroupName = termGroup.Attributes["Name"].Value; //Get TermStore Groups GroupCollection groups = termStore.Groups; //Find group that we want to Import to Group thisGroup = groups.Where(g => g.Name == strGroupName).SingleOrDefault(); //Check that group exist if (thisGroup != null) { //Get Current group group = termStore.GetGroup(thisGroup.Id); } else //If group doesn't exist, create it { group = termStore.CreateGroup(strGroupName); termStore.CommitAll(); } Console.WriteLine(strGroupName); ProcessTermSet(termGroup); } }
public static void CriarItemNaTermStore(string url) { using (SPSite site = new SPSite(url)) { TaxonomySession session = new TaxonomySession(site); TermStore termStore = session.TermStores["MMS"]; Group group1 = termStore.CreateGroup("Links1"); TermSet termSet1 = group1.CreateTermSet("TermSet1"); Term term1 = termSet1.CreateTerm("Term1", 1033); Term term2 = termSet1.CreateTerm("Term2", 1033); Term term3 = termSet1.CreateTerm("Term3", 1033); Term term1a = term1.CreateTerm("Term1a", 1033); Term term1b = term1.CreateTerm("Term1b", 1033); termStore.CommitAll(); term1.SetDescription("This is term1", 1033); term1.CreateLabel("TermOne", 1033, false); term1.CreateLabel("FirstTerm", 1033, false); termStore.CommitAll(); term3.Delete(); termStore.CommitAll(); } }
// 4. En el evento, en la activación de la feature, activar las etiquetas SEO. public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPSite site = (SPSite)properties.Feature.Parent; using (SPWeb web = site.RootWeb) { // configure SEO properties for the home page (does not use Navigation Term SEO properites) SPListItem welcomePage = web.GetListItem(web.RootFolder.WelcomePage); // Aqui hay 3 Resources descritos en Resources.resx welcomePage["SeoBrowserTitle"] = Resources.SeoBrowserTitle; welcomePage["SeoMetaDescription"] = Resources.SeoDescription; welcomePage["SeoKeywords"] = Resources.SeoKeywords; welcomePage["SeoRobotsNoIndex"] = false.ToString(); welcomePage.SystemUpdate(); // configure SEO propertie on all navigation terms associated with Welcome Pages TaxonomySession taxSession = new TaxonomySession(site, updateCache: true); TermStore termStore = taxSession.DefaultSiteCollectionTermStore; Group termGroup = termStore.GetSiteCollectionGroup(site, true); // locate the navigation term set for the site collection (there can be only one) foreach (TermSet termSet in termGroup.TermSets) { NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(termSet, site.RootWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider); if (navTermSet.IsNavigationTermSet) { // determine which navigation nodes are associated with Welcome Page content types foreach (NavigationTerm navTerm in navTermSet.Terms) { string pageUrl = SPUtility.GetServerRelativeUrlFromPrefixedUrl(navTerm.TargetUrl.Value); SPListItem pageItem = web.GetListItem(pageUrl); if (pageItem.ContentType.Name == "Welcome Page") { // set the SEO properties on the Navigation Term (all will have same SEO tags) Term term = termSet.GetTerm(navTerm.Id); term.SetLocalCustomProperty("_Sys_Seo_PropBrowserTitle", Resources.SeoBrowserTitle); term.SetLocalCustomProperty("_Sys_Seo_PropDescription", Resources.SeoDescription); term.SetLocalCustomProperty("_Sys_Seo_PropKeywords", Resources.SeoKeywords); term.SetLocalCustomProperty("_Sys_Seo_PropSiteNoIndex", false.ToString()); } } break; } } termStore.CommitAll(); web.Update(); } }
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext) { var modelHost = modelHostContext.ModelHost; var model = modelHostContext.Model; var childModelType = modelHostContext.ChildModelType; var action = modelHostContext.Action; var definition = model.WithAssertAndCast <TaxonomyTermDefinition>("model", value => value.RequireNotNull()); Term currentTerm = null; Group group = null; TermSet termSet = null; TermStore termStore = null; SPSite hostSite = null; if (modelHost is TermModelHost) { var h = (modelHost as TermModelHost); group = h.HostGroup; termSet = h.HostTermSet; termStore = h.HostTermStore; hostSite = h.HostSite; currentTerm = FindTermInTerm(h.HostTerm, definition); } else if (modelHost is TermSetModelHost) { var h = (modelHost as TermSetModelHost); termStore = h.HostTermStore; group = h.HostGroup; termSet = h.HostTermSet; hostSite = h.HostSite; currentTerm = FindTermInTermSet(h.HostTermSet, definition); } action(new TermModelHost { HostGroup = group, HostTermSet = termSet, HostTerm = currentTerm, HostTermStore = termStore, HostSite = hostSite }); termStore.CommitAll(); }
/// <summary> /// Create practice group terms /// </summary> /// <param name="TermsData">Practice group, SAOL and AOL data</param> /// <param name="clientContext">Client context object</param> private static void CreatePGTerms(List <CustomTermGroup> TermsData, ClientContext clientContext) { TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(clientContext); clientContext.Load(taxonomySession.TermStores); //Execute the query to the server clientContext.ExecuteQuery(); TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore(); clientContext.Load(termStore.Groups); //Execute the query to the server clientContext.ExecuteQuery(); foreach (CustomTermGroup termGroup in TermsData) { TermGroup group = termStore.Groups.Where(groupProperties => groupProperties.Name == termGroup.name).Count() > 0 ? termStore.Groups.GetByName(termGroup.name) : termStore.CreateGroup(termGroup.name, Guid.NewGuid()); TermSet pracGrp = group.CreateTermSet(ConfigurationManager.AppSettings["pgterm"], Guid.NewGuid(), 1033); foreach (CustomPracticeGroup pg in termGroup.Pg) { if (!string.IsNullOrWhiteSpace(pg.name)) { Console.WriteLine("Creating practice group " + pg.name); Term pgTermSet = pracGrp.CreateTerm(pg.name, 1033, Guid.NewGuid()); if (pg.properties.ContainsKey("PGFolders") && !string.IsNullOrWhiteSpace(pg.properties["PGFolders"])) { pgTermSet.SetCustomProperty("FolderNames", pg.properties["PGFolders"]); } foreach (CustomAreaOfLaw aol in pg.Aol) { if (!string.IsNullOrWhiteSpace(aol.name)) { Console.WriteLine("\tCreating area of law " + aol.name); Term AOLTerm = pgTermSet.CreateTerm(aol.name, 1033, Guid.NewGuid()); if (aol.properties.ContainsKey("AOLFolders") && !string.IsNullOrWhiteSpace(aol.properties["AOLFolders"])) { AOLTerm.SetCustomProperty("FolderNames", aol.properties["AOLFolders"]); } CustomArea(aol, AOLTerm); } } } } } termStore.CommitAll(); clientContext.Load(termStore); //Execute the query to the server clientContext.ExecuteQuery(); }
protected void Button1_Click(object sender, EventArgs e) { TaxonomySession session = new TaxonomySession(SPContext.Current.Site); TermStore termStore = session.TermStores[0]; Group myGroup = termStore.CreateGroup("Training"); TermSet topicTermSet = myGroup.CreateTermSet("Topics"); string[] topics = new string[] { "CRM", "SharePoint", "End User", "Developer", "IT Administrator", "Introduction", "Advanced" }; foreach (string topic in topics) { Term newTerm = topicTermSet.CreateTerm(topic, 1033); } termStore.CommitAll(); }
private void Import(XmlElement groupElement, TermStore parentTermStore) { string groupName = groupElement.GetAttribute("Name"); Guid groupId = new Guid(groupElement.GetAttribute("Id")); LoadWorkingLanguage(parentTermStore); TermGroup group = null; ExceptionHandlingScope scope = new ExceptionHandlingScope(_ctx); using (scope.StartScope()) { using (scope.StartTry()) { group = parentTermStore.Groups.GetByName(groupName); _ctx.Load(group); } using (scope.StartCatch()) { } } _ctx.ExecuteQuery(); if (group == null || group.ServerObjectIsNull == null || group.ServerObjectIsNull.Value) { _cmdlet.WriteVerbose(string.Format("Creating Group: {0}", groupName)); group = parentTermStore.CreateGroup(groupName, groupId); group.Description = groupElement.GetAttribute("Description"); group.Context.ExecuteQuery(); parentTermStore.CommitAll(); parentTermStore.Context.ExecuteQuery(); } XmlNodeList termSetNodes = groupElement.SelectNodes("./TermSets/TermSet"); if (termSetNodes != null && termSetNodes.Count > 0) { foreach (XmlElement termSetElement in termSetNodes) { Import(termSetElement, group); } } }
private void CreateTargetNewTermGroup(ClientContext sourceClientContext, ClientContext targetClientContext, TermGroup sourceTermGroup, TermStore targetTermStore) { try { this._destinationTermGroup = targetTermStore.CreateGroup(sourceTermGroup.Name, sourceTermGroup.Id); if(!string.IsNullOrEmpty(sourceTermGroup.Description)) { this._destinationTermGroup.Description = sourceTermGroup.Description; } TermOperation _op = new TermOperation(); _op.Term = sourceTermGroup.Name; _op.Id = sourceTermGroup.Id.ToString(); _op.Operation = "Add"; _op.Type = "TermGroup"; this._termStoreOperations.Add(_op); TermSetCollection _sourceTermSetCollection = sourceTermGroup.TermSets; if (_sourceTermSetCollection.Count > 0) { foreach (TermSet _sourceTermSet in _sourceTermSetCollection) { sourceClientContext.Load(_sourceTermSet, set => set.Name, set => set.Description, set => set.Id, set => set.Terms.Include( term => term.Name, term => term.Id), term => term.Description, term => term.Contact); sourceClientContext.ExecuteQuery(); TermSet _targetTermSet = _destinationTermGroup.CreateTermSet(_sourceTermSet.Name, _sourceTermSet.Id, targetTermStore.DefaultLanguage); if(!string.IsNullOrEmpty(_sourceTermSet.Description)) { _targetTermSet.Description = _sourceTermSet.Description; } foreach(Term _sourceTerm in _sourceTermSet.Terms) { Term _targetTerm = _targetTermSet.CreateTerm(_sourceTerm.Name, targetTermStore.DefaultLanguage, _sourceTerm.Id); _op = new TermOperation(); _op.Term = _sourceTerm.Name; _op.Id = _sourceTerm.Id.ToString(); _op.Operation = "Add"; _op.Type = "Term"; this._termStoreOperations.Add(_op); } } } try { targetClientContext.ExecuteQuery(); targetTermStore.CommitAll(); } catch { throw; } } catch { throw; } }
private void Import(XmlElement groupElement, TermStore parentTermStore) { string groupName = groupElement.GetAttribute("Name"); Group group = null; if (bool.Parse(groupElement.GetAttribute("IsSiteCollectionGroup"))) { XmlNodeList siteCollectionIdNodes = groupElement.SelectNodes("./SiteCollectionAccessIds/SiteCollectionAccessId"); if (siteCollectionIdNodes != null) { foreach (XmlElement siteCollectionIdElement in siteCollectionIdNodes) { SPSite site = null; if (!string.IsNullOrEmpty(siteCollectionIdElement.GetAttribute("Url"))) { try { site = new SPSite(siteCollectionIdElement.GetAttribute("Url")); } catch { Logger.WriteWarning("Unable to locate a Site Collection at {0}", siteCollectionIdElement.GetAttribute("Url")); } } else { try { site = new SPSite(new Guid(siteCollectionIdElement.GetAttribute("Id"))); } catch { Logger.WriteWarning("Unable to locate a Site Collection with ID {0}", siteCollectionIdElement.GetAttribute("Id")); } } if (site != null) { try { if (group == null) { group = parentTermStore.GetSiteCollectionGroup(site); } if (group != null && group.IsSiteCollectionGroup) { group.AddSiteCollectionAccess(site.ID); } } catch (MissingMethodException) { Logger.WriteWarning("Unable to retrieve or add Site Collection group. SharePoint 2010 Service Pack 1 or greater is required. ID={0}, Url={1}", siteCollectionIdElement.GetAttribute("Id"), siteCollectionIdElement.GetAttribute("Url")); } finally { site.Dispose(); } } } } } try { if (group == null) group = parentTermStore.Groups[groupName]; } catch (ArgumentException) {} if (group == null) { Logger.Write("Creating Group: {0}", groupName); #if SP2010 group = parentTermStore.CreateGroup(groupName); #else // Updated provided by John Calvert if (!string.IsNullOrEmpty(groupElement.GetAttribute("Id"))) { Guid id = new Guid(groupElement.GetAttribute("Id")); group = parentTermStore.CreateGroup(groupName, id); } else group = parentTermStore.CreateGroup(groupName); // End update #endif group.Description = groupElement.GetAttribute("Description"); } parentTermStore.CommitAll();//TEST XmlNodeList termSetNodes = groupElement.SelectNodes("./TermSets/TermSet"); if (termSetNodes != null && termSetNodes.Count > 0) { foreach (XmlElement termSetElement in termSetNodes) { Import(termSetElement, group); } } }
public void Import(TermStore parentTermStore) { if (parentTermStore == null) throw new ArgumentNullException("parentTermStore", "The parent TermStore object is null."); if (_xml.DocumentElement.Name == "Groups") { XmlNodeList groupNodes = _xml.SelectNodes("./Groups/Group"); if (groupNodes == null || groupNodes.Count == 0) return; foreach (XmlElement groupElement in groupNodes) { Import(groupElement, parentTermStore); } } else if (_xml.DocumentElement.Name == "Group") { Import(_xml.DocumentElement, parentTermStore); } parentTermStore.CommitAll(); }
private static void ImportTerms(string filePath, string urlSPSite) { using (SPSite site = new SPSite(urlSPSite)) { // function that return termstore from site. termStore = termstorefromWebApp(site); XmlDocument doc = new XmlDocument(); doc.Load(filePath); XmlNode termGroup = doc.SelectSingleNode("/Groups/Group"); ProcessGroup(termGroup); termStore.CommitAll(); } }
public void Import(TermStore parentTermStore) { if (parentTermStore == null || parentTermStore.ServerObjectIsNull.Value) throw new ArgumentNullException("parentTermStore", "The parent TermStore object is null."); LoadWorkingLanguage(parentTermStore); if (_xml.DocumentElement.Name == "Groups") { XmlNodeList groupNodes = _xml.SelectNodes("./Groups/Group"); if (groupNodes == null || groupNodes.Count == 0) return; foreach (XmlElement groupElement in groupNodes) { Import(groupElement, parentTermStore); } } else if (_xml.DocumentElement.Name == "Group") { Import(_xml.DocumentElement, parentTermStore); } parentTermStore.CommitAll(); parentTermStore.Context.ExecuteQuery(); }
private void DeleteGroupIfExists(TermStore defaultSiteCollectionTermStore, Guid testGroupId) { Group existingTestGroup = defaultSiteCollectionTermStore.GetGroup(testGroupId); if (existingTestGroup != null) { foreach (var termSet in existingTestGroup.TermSets) { termSet.Delete(); } existingTestGroup.Delete(); defaultSiteCollectionTermStore.CommitAll(); } }
private void DeleteTermGroupsImplementation(ClientContext cc, TermStore termStore) { cc.Load(termStore.Groups, p => p.Include(t => t.Name, t => t.TermSets.Include(s => s.Name, s => s.Terms.Include(q => q.IsDeprecated, q => q.ReusedTerms)))); cc.ExecuteQueryRetry(); foreach (var termGroup in termStore.Groups.ToList()) { DeleteTermGroupImplementation(cc, termGroup); } var siteCollectionGroup = termStore.GetSiteCollectionGroup(cc.Site, true); cc.Load(siteCollectionGroup, t => t.Name, t => t.TermSets.Include(s => s.Name, s => s.Terms.Include(q => q.IsDeprecated, q => q.ReusedTerms))); cc.ExecuteQueryRetry(); DeleteTermGroupImplementation(cc, siteCollectionGroup, true); termStore.CommitAll(); termStore.UpdateCache(); cc.ExecuteQueryRetry(); }
private static void AddLanguages(ClientContext clientContext, TermStore termStore) { clientContext.Load(clientContext.Web, w => w.ServerRelativeUrl); clientContext.Load(termStore, ts => ts.Languages); clientContext.ExecuteQuery(); var languages = new int[] { 1031, 1033, 1036, 1053 }; Array.ForEach(languages, l => { if (!termStore.Languages.Contains(l)) termStore.AddLanguage(l); }); termStore.CommitAll(); clientContext.ExecuteQuery(); }
private TermSet CreateTermSet(TermStore termStore, Guid termSetID, SPWeb currentWeb, TermStoreType tsType) { //termSet is null. Create new termSet, and set the property in the property bag. Group siteCollectionGroup = termStore.GetSiteCollectionGroup(currentWeb.Site); //Group navTermsGroup = termStore.Groups["Navigation"]; //TODO: Get this from configuration or passed in. string termStoreName = (tsType == TermStoreType.Global) ? string.Format("Global_Nav_For{0}", termSetID) : string.Format("Local_Nav_For{0}", termSetID); TermSet newTermSet = siteCollectionGroup.CreateTermSet(termStoreName, termSetID); NavigationTermSet navTermSet = NavigationTermSet.GetAsResolvedByWeb(newTermSet, currentWeb, StandardNavigationProviderNames.GlobalNavigationTaxonomyProvider); navTermSet.IsNavigationTermSet = true; navTermSet.TargetUrlForChildTerms.Value = "~site/SitePages/Home.aspx"; uint langID = (uint) currentWeb.Locale.LCID; string webTemplateID = Convert.ToString(currentWeb.Site.RootWeb.AllProperties["MARTA.WebTemplateID"]); string termStoreType = (tsType == TermStoreType.Global) ? "Global" : "Local"; string termMap = SPUtility.GetLocalizedString(string.Format("$Resources:MARTANavigation,{0}_{1}", webTemplateID, termStoreType) , "MARTANavigation", langID); string relativeURL = currentWeb.Site.ServerRelativeUrl; BuildNavTerms(navTermSet, termMap, relativeURL); termStore.CommitAll(); return newTermSet; //Add this to the property bag of the web as well. }