public void Can_Reverse_TermGroups()
{
var siteTermStore = new TaxonomyTermStoreDefinition
{
Id = null,
Name = string.Empty,
UseDefaultSiteCollectionTermStore = true
};
var termGroup1 = new TaxonomyTermGroupDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid()
};
var termGroup2 = new TaxonomyTermGroupDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid()
};
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(siteTermStore, store =>
{
store.AddTaxonomyTermGroup(termGroup1);
store.AddTaxonomyTermGroup(termGroup2);
});
});
DeployReverseAndTestModel(model);
}
protected Group FindGroup(TermStoreModelHost termStoreHost, TaxonomyTermGroupDefinition groupModel)
{
Group currentGroup = null;
var termStore = termStoreHost.HostTermStore;
if (groupModel.IsSiteCollectionGroup)
{
currentGroup = FindSiteCollectionGroup(termStoreHost, groupModel);
return(currentGroup);
}
//if (groupModel.IsSystemGroup)
//{
// currentGroup = FindSystemGroup(termStoreHost, groupModel);
// return currentGroup;
//}
if (groupModel.Id.HasValue)
{
currentGroup = termStore.GetGroup(groupModel.Id.Value);
}
else if (!string.IsNullOrEmpty(groupModel.Name))
{
currentGroup = termStore.Groups.FirstOrDefault(g => g.Name.ToUpper() == groupModel.Name.ToUpper());
}
return(currentGroup);
}
private void SharePointOnlineWait(TermStoreModelHost siteModelHost, TaxonomyTermGroupDefinition groupModel)
{
// wait until the group is there
// Nested terms provisioning in Office 365 fails #995
// TermSet not found #994
var context = siteModelHost.HostClientContext;
if (IsSharePointOnlineContext(context))
{
var currentGroup = FindGroup(siteModelHost, groupModel);
if (currentGroup == null)
{
TryRetryService.TryWithRetry(() =>
{
currentGroup = FindGroup(siteModelHost, groupModel);
return(currentGroup != null);
});
}
if (currentGroup == null)
{
throw new SPMeta2Exception(string.Format("Cannot find a taxonomy group after provision"));
}
}
}
protected TermGroup FindGroup(TermStoreModelHost storeModelHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = storeModelHost.HostTermStore;
var context = termStore.Context;
TermGroup currentGroup = null;
if (groupModel.IsSiteCollectionGroup)
{
currentGroup = FindSiteCollectionGroup(storeModelHost, groupModel);
return(currentGroup);
}
if (groupModel.Id.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
currentGroup = termStore.Groups.GetById(groupModel.Id.Value);
context.Load(currentGroup);
}
using (scope.StartCatch())
{
}
}
}
else if (!string.IsNullOrEmpty(groupModel.Name))
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
currentGroup = termStore.Groups.GetByName(groupModel.Name);
context.Load(currentGroup);
}
using (scope.StartCatch())
{
}
}
}
context.ExecuteQueryWithTrace();
if (currentGroup != null && currentGroup.ServerObjectIsNull == false)
{
context.Load(currentGroup, g => g.Id);
context.Load(currentGroup, g => g.Name);
context.ExecuteQueryWithTrace();
return(currentGroup);
}
return(null);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleTaxonomyGroups()
{
var defaultSiteTermStore = new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
};
var clientsGroup = new TaxonomyTermGroupDefinition
{
Name = "Clients"
};
var parthersGroup = new TaxonomyTermGroupDefinition
{
Name = "Parthers"
};
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(defaultSiteTermStore, termStore =>
{
termStore
.AddTaxonomyTermGroup(clientsGroup)
.AddTaxonomyTermGroup(parthersGroup);
});
});
DeployModel(model);
}
protected Group FindSiteCollectionGroup(TermStoreModelHost termStoreHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = termStoreHost.HostTermStore;
#if NET35
return(termStore.GetSiteCollectionGroup(termStoreHost.HostSite));
#endif
#if !NET35
return(termStore.GetSiteCollectionGroup(termStoreHost.HostSite, true));
#endif
}
public void Can_Reverse_TermSets()
{
var siteTermStore = new TaxonomyTermStoreDefinition
{
Id = null,
Name = string.Empty,
UseDefaultSiteCollectionTermStore = true
};
var termGroup1 = new TaxonomyTermGroupDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid()
};
var termSet1 = new TaxonomyTermSetDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Contact = Rnd.String(),
Description = Rnd.String()
};
var termSet2 = new TaxonomyTermSetDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Contact = Rnd.String(),
Description = Rnd.String()
};
// only witin a tes term group
// performance boost
var groupName = termGroup1.Name;
var options = ReverseOptions.Default
.AddFilterOption <TaxonomyTermGroupDefinition>(g => g.Name == groupName);
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(siteTermStore, store =>
{
store.AddTaxonomyTermGroup(termGroup1, group =>
{
group.AddTaxonomyTermSet(termSet1);
group.AddTaxonomyTermSet(termSet2);
});
});
});
DeployReverseAndTestModel(model, options);
}
protected Group FindGroup(TermStore termStore, TaxonomyTermGroupDefinition groupModel)
{
Group currentGroup = null;
if (groupModel.Id.HasValue)
{
currentGroup = termStore.GetGroup(groupModel.Id.Value);
}
else if (!string.IsNullOrEmpty(groupModel.Name))
{
currentGroup = termStore.Groups.FirstOrDefault(g => g.Name.ToUpper() == groupModel.Name.ToUpper());
}
return(currentGroup);
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleTaxonomyTermSets()
{
var defaultSiteTermStore = new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
};
var clientsGroup = new TaxonomyTermGroupDefinition
{
Name = "Clients"
};
var smallBusiness = new TaxonomyTermSetDefinition
{
Name = "Small Business"
};
var mediumBusiness = new TaxonomyTermSetDefinition
{
Name = "Medium Business"
};
var enterpriseBusiness = new TaxonomyTermSetDefinition
{
Name = "Enterprise Business"
};
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(defaultSiteTermStore, termStore =>
{
termStore.AddTaxonomyTermGroup(clientsGroup, group =>
{
group
.AddTaxonomyTermSet(smallBusiness)
.AddTaxonomyTermSet(mediumBusiness)
.AddTaxonomyTermSet(enterpriseBusiness);
});
});
});
DeployModel(model);
}
private void UpdateExistingTaxonomyGroup(object modelHost, TaxonomyTermGroupDefinition groupModel, TermGroup currentGroup)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term Group");
if (!string.IsNullOrEmpty(groupModel.Description))
{
currentGroup.Description = groupModel.Description;
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(TermGroup),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as TaxonomyTermGroupReverseHost);
var item = typedHost.HostTermGroup;
var def = new TaxonomyTermGroupDefinition();
def.Id = item.Id;
def.Name = item.Name;
// TODO, M2
// https://github.com/SubPointSolutions/spmeta2/issues/827
//def.Descrption = item.Description;
return(new TaxonomyTermGroupModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
protected TermGroup FindSiteCollectionGroup(TermStoreModelHost storeModelHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = storeModelHost.HostTermStore;
var site = storeModelHost.HostSite;
var context = termStore.Context;
TermGroup currentGroup = termStore.GetSiteCollectionGroup(site, true);
context.Load(currentGroup);
context.ExecuteQueryWithTrace();
return(currentGroup);
}
private void DeployTaxonomyGroup(object modelHost, TermStoreModelHost siteModelHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = siteModelHost.HostTermStore;
var currentGroup = FindGroup(siteModelHost, groupModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentGroup,
ObjectType = typeof(TermGroup),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
if (currentGroup == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term Group");
currentGroup = groupModel.Id.HasValue
? termStore.CreateGroup(groupModel.Name, groupModel.Id.Value)
: termStore.CreateGroup(groupModel.Name, Guid.NewGuid());
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(TermGroup),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term Group");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(TermGroup),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
}
termStore.CommitAll();
termStore.Context.ExecuteQueryWithTrace();
}
protected Group FindSiteCollectionGroup(TermStoreModelHost termStoreHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = termStoreHost.HostTermStore;
return(termStore.GetSiteCollectionGroup(termStoreHost.HostSite));
}
protected Group FindSystemGroup(TermStoreModelHost termStoreHost, TaxonomyTermGroupDefinition groupModel)
{
return(termStoreHost.HostTermStore.SystemGroup);
}
public static TModelNode AddHostTaxonomyTermGroup <TModelNode>(this TModelNode model, TaxonomyTermGroupDefinition definition,
Action <TaxonomyTermGroupModelNode> action)
where TModelNode : ModelNode, ITaxonomyTermGroupHostModelNode, new()
{
return(model.AddTypedDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
private void DeployTaxonomyGroup(object modelHost, TermStoreModelHost siteModelHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = siteModelHost.HostTermStore;
var currentGroup = FindGroup(siteModelHost, groupModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentGroup,
ObjectType = typeof(Group),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
if (currentGroup == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term Group");
#if !NET35
currentGroup = groupModel.Id.HasValue
? termStore.CreateGroup(groupModel.Name, groupModel.Id.Value)
: termStore.CreateGroup(groupModel.Name);
#endif
#if NET35
// SP2010 API does not support creating groups with particular ID
currentGroup = termStore.CreateGroup(groupModel.Name);
#endif
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(Group),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term Group");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(Group),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
}
siteModelHost.HostTermStore.CommitAll();
}
//[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
public void CanDeploySimpleTaxonomyTerms()
{
// define term store
var defaultSiteTermStore = new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
};
// define group
var clientsGroup = new TaxonomyTermGroupDefinition
{
Name = "Clients"
};
// define term sets
var smallBusiness = new TaxonomyTermSetDefinition
{
Name = "Small Business"
};
var mediumBusiness = new TaxonomyTermSetDefinition
{
Name = "Medium Business"
};
var enterpriseBusiness = new TaxonomyTermSetDefinition
{
Name = "Enterprise Business"
};
// define terms
var microsoft = new TaxonomyTermDefinition
{
Name = "Microsoft"
};
var apple = new TaxonomyTermDefinition
{
Name = "Apple"
};
var oracle = new TaxonomyTermDefinition
{
Name = "Oracle"
};
var subPointSolutions = new TaxonomyTermDefinition
{
Name = "SubPoint Solutions"
};
// setup the model
var model = SPMeta2Model.NewSiteModel(site =>
{
site.AddTaxonomyTermStore(defaultSiteTermStore, termStore =>
{
termStore.AddTaxonomyTermGroup(clientsGroup, group =>
{
group
.AddTaxonomyTermSet(smallBusiness, termSet =>
{
termSet.AddTaxonomyTerm(subPointSolutions);
})
.AddTaxonomyTermSet(mediumBusiness)
.AddTaxonomyTermSet(enterpriseBusiness, termSet =>
{
termSet
.AddTaxonomyTerm(microsoft)
.AddTaxonomyTerm(apple)
.AddTaxonomyTerm(oracle);
});
});
});
});
DeployModel(model);
}
public static TModelNode AddHostTaxonomyTermGroup <TModelNode>(this TModelNode model, TaxonomyTermGroupDefinition definition)
where TModelNode : ModelNode, ITaxonomyTermGroupHostModelNode, new()
{
return(AddHostTaxonomyTermGroup(model, definition, null));
}
private void DeployTaxonomyGroup(object modelHost, TermStoreModelHost siteModelHost, TaxonomyTermGroupDefinition groupModel)
{
var termStore = siteModelHost.HostTermStore;
var currentGroup = FindGroup(siteModelHost, groupModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentGroup,
ObjectType = typeof(TermGroup),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
if (currentGroup == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term Group");
currentGroup = groupModel.Id.HasValue
? termStore.CreateGroup(groupModel.Name, groupModel.Id.Value)
: termStore.CreateGroup(groupModel.Name, Guid.NewGuid());
if (!string.IsNullOrEmpty(groupModel.Description))
{
currentGroup.Description = groupModel.Description;
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentGroup,
ObjectType = typeof(TermGroup),
ObjectDefinition = groupModel,
ModelHost = modelHost
});
}
else
{
UpdateExistingTaxonomyGroup(modelHost, groupModel, currentGroup);
}
termStore.CommitAll();
termStore.Groups.RefreshLoad();
termStore.RefreshLoad();
try
{
termStore.Context.ExecuteQueryWithTrace();
}
catch (Exception e)
{
var context = siteModelHost.HostClientContext;
if (!IsSharePointOnlineContext(context))
{
throw;
}
// SPMeta2 Provisioning Taxonomy Group with CSOM Standard #959
// https://github.com/SubPointSolutions/spmeta2/issues/959
// seems that newly created group might not be available for the time being
// handling that "Group names must be unique." exception
// trying to find the group and only update description
var serverException = e as ServerException;
if (serverException != null &&
serverException.ServerErrorCode == -2147024809)
{
currentGroup = FindGroup(siteModelHost, groupModel);
if (currentGroup == null)
{
TryRetryService.TryWithRetry(() =>
{
currentGroup = FindGroup(siteModelHost, groupModel);
return(currentGroup != null);
});
}
UpdateExistingTaxonomyGroup(modelHost, groupModel, currentGroup);
termStore.CommitAll();
termStore.Groups.RefreshLoad();
termStore.RefreshLoad();
termStore.Context.ExecuteQueryWithTrace();
}
}
siteModelHost.ShouldUpdateHost = false;
}
public void CanDeployTaxonomyField()
{
// define a taxonomy
// term store -> group -> term set -> terms
var taxDefaultTermStore = new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
};
var taxTermGroup = new TaxonomyTermGroupDefinition
{
Name = "M2 Taxonomy"
};
var taxTermSet = new TaxonomyTermSetDefinition
{
Name = "Locations"
};
var taxTermLondon = new TaxonomyTermDefinition
{
Name = "London"
};
var taxTermSydney = new TaxonomyTermDefinition
{
Name = "Sydney"
};
// define the field
var location = new TaxonomyFieldDefinition
{
Title = "Location",
InternalName = "dcs_LocationTax",
Group = "SPMeta2.Samples",
Id = new Guid("FE709AC2-E3A1-4A25-8F71-3480667CD98F"),
IsMulti = false,
UseDefaultSiteCollectionTermStore = true,
TermSetName = taxTermSet.Name
};
var model = SPMeta2Model.NewSiteModel(site =>
{
site
.AddHostTaxonomyTermStore(taxDefaultTermStore, store =>
{
store.AddTaxonomyTermGroup(taxTermGroup, group =>
{
group.AddTaxonomyTermSet(taxTermSet, termSet =>
{
termSet
.AddTaxonomyTerm(taxTermLondon)
.AddTaxonomyTerm(taxTermSydney);
});
});
})
.AddTaxonomyField(location);
});
DeployModel(model);
}
public static ModelNode AddHostTaxonomyTermGroup(this ModelNode model, TaxonomyTermGroupDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
public static ModelNode AddHostTaxonomyTermGroup(this ModelNode model, TaxonomyTermGroupDefinition definition)
{
return(AddHostTaxonomyTermGroup(model, definition, null));
}
public static ModelNode AddTaxonomyTermGroup(this ModelNode model, TaxonomyTermGroupDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNode(definition, action));
}
public void CanDeploy_WebNavigationSettings_As_TaxonomyProvider()
{
var globalTerm = Rnd.String();
var currentlTerm = Rnd.String();
var currentNavigationGroup = new TaxonomyTermGroupDefinition
{
Name = string.Format("{0}", globalTerm)
};
var currentNavigationTermSet = new TaxonomyTermSetDefinition
{
Name = string.Format("{0}", globalTerm)
};
var globalNavigationGroup = new TaxonomyTermGroupDefinition
{
Name = string.Format("{0}", currentlTerm)
};
var globalNavigationTermSet = new TaxonomyTermSetDefinition
{
Name = string.Format("{0}", currentlTerm)
};
var taxWeb = ModelGeneratorService.GetRandomDefinition <WebDefinition>(def =>
{
});
var siteModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddSiteFeature(BuiltInSiteFeatures.SharePointServerPublishingInfrastructure.Inherit(def =>
{
def.Enable = true;
}));
site.AddTaxonomyTermStore(new TaxonomyTermStoreDefinition
{
UseDefaultSiteCollectionTermStore = true
},
store =>
{
store.AddTaxonomyTermGroup(currentNavigationGroup, group =>
{
group.AddTaxonomyTermSet(currentNavigationTermSet, termSet =>
{
termSet.AddRandomTerm();
termSet.AddRandomTerm();
termSet.AddRandomTerm();
});
});
store.AddTaxonomyTermGroup(globalNavigationGroup, group =>
{
group.AddTaxonomyTermSet(globalNavigationTermSet, termSet =>
{
termSet.AddRandomTerm();
termSet.AddRandomTerm();
termSet.AddRandomTerm();
});
});
});
});
var webModel = SPMeta2Model.NewWebModel(web =>
{
web.AddWeb(taxWeb, subWeb =>
{
subWeb.AddSiteFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(def =>
{
def.Enable = true;
}));
subWeb.AddWebNavigationSettings(new WebNavigationSettingsDefinition()
{
CurrentNavigationSource = BuiltInStandardNavigationSources.TaxonomyProvider,
CurrentNavigationUseDefaultSiteCollectionTermStore = true,
CurrentNavigationTermSetName = currentNavigationGroup.Name,
GlobalNavigationSource = BuiltInStandardNavigationSources.TaxonomyProvider,
GlobalNavigationUseDefaultSiteCollectionTermStore = true,
GlobalNavigationTermSetName = globalNavigationGroup.Name,
DisplayShowHideRibbonAction = true
});
});
});
TestModel(siteModel, webModel);
}
public static TModelNode AddTaxonomyTermGroup <TModelNode>(this TModelNode model, TaxonomyTermGroupDefinition definition,
Action <TaxonomyTermGroupModelNode> action)
where TModelNode : ModelNode, ITaxonomyTermGroupHostModelNode, new()
{
return(model.AddTypedDefinitionNode(definition, action));
}
