public void CanDeploy_TaxonomyFieldBindedToTermSetById()
{
var termSet = new TaxonomyTermSetDefinition
{
Name = Rnd.String(),
Description = Rnd.String(),
Id = Rnd.Guid()
};
var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
{
def.TermSetId = termSet.Id.Value;
});
var taxonomyModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomTermStore(termStore =>
{
termStore.AddRandomTermGroup(group =>
{
group.AddTaxonomyTermSet(termSet);
});
});
});
var fieldModel = SPMeta2Model
.NewSiteModel(site =>
{
site.AddTaxonomyField(taxField);
});
TestModels(new[] { taxonomyModel, fieldModel });
}
private static void MapTermSet(TermSet currentTermSet, TaxonomyTermSetDefinition termSetModel)
{
if (!string.IsNullOrEmpty(termSetModel.Description))
{
currentTermSet.Description = termSetModel.Description;
}
if (!string.IsNullOrEmpty(termSetModel.Contact))
{
currentTermSet.Contact = termSetModel.Contact;
}
if (!string.IsNullOrEmpty(termSetModel.CustomSortOrder))
{
currentTermSet.CustomSortOrder = termSetModel.CustomSortOrder;
}
if (termSetModel.IsOpenForTermCreation.HasValue)
{
currentTermSet.IsOpenForTermCreation = termSetModel.IsOpenForTermCreation.Value;
}
if (termSetModel.IsAvailableForTagging.HasValue)
{
currentTermSet.IsAvailableForTagging = termSetModel.IsAvailableForTagging.Value;
}
#if !NET35
foreach (var customProp in termSetModel.CustomProperties.Where(p => p.Override))
{
currentTermSet.SetCustomProperty(customProp.Name, customProp.Value);
}
#endif
}
private void SharePointOnlineWait(TermGroupModelHost groupModelHost, TaxonomyTermSetDefinition termSetModel)
{
// wait until the group is there
// Nested terms provisioning in Office 365 fails #995
// TermSet not found #994
var context = groupModelHost.HostClientContext;
if (IsSharePointOnlineContext(context))
{
var currentTermSet = FindTermSet(groupModelHost.HostGroup, termSetModel);
if (currentTermSet == null)
{
TryRetryService.TryWithRetry(() =>
{
currentTermSet = FindTermSet(groupModelHost.HostGroup, termSetModel);
return(currentTermSet != null);
});
}
if (currentTermSet == null)
{
throw new SPMeta2Exception(string.Format("Cannot find a termset after provision"));
}
}
}
protected TermSet FindTermSet(TermGroup termGroup, TaxonomyTermSetDefinition termSetModel)
{
TermSet result = null;
var context = termGroup.Context;
context.Load(termGroup.TermSets);
context.ExecuteQueryWithTrace();
if (termSetModel.Id.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termGroup.TermSets.GetById(termSetModel.Id.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
}
else if (!string.IsNullOrEmpty(termSetModel.Name))
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termGroup.TermSets.GetByName(termSetModel.Name);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
}
context.ExecuteQueryWithTrace();
if (result != null &&
result.ServerObjectIsNull.HasValue &&
result.ServerObjectIsNull == false)
{
context.Load(result);
//context.Load(result, g => g.Id);
//context.Load(result, g => g.Name);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
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);
}
private static void MapTermSet(TermSet currentTermSet, TaxonomyTermSetDefinition termSetModel)
{
currentTermSet.Description = termSetModel.Description;
if (termSetModel.IsOpenForTermCreation.HasValue)
{
currentTermSet.IsOpenForTermCreation = termSetModel.IsOpenForTermCreation.Value;
}
if (termSetModel.IsAvailableForTagging.HasValue)
{
currentTermSet.IsAvailableForTagging = termSetModel.IsAvailableForTagging.Value;
}
}
private void UpdateExistingTaxonomyTermSet(object modelHost, TaxonomyTermSetDefinition termSetModel, TermSet currentTermSet)
{
MapTermSet(currentTermSet, termSetModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTermSet,
ObjectType = typeof(TermSet),
ObjectDefinition = termSetModel,
ModelHost = modelHost
});
}
protected TermSet FindTermSet(Microsoft.SharePoint.Taxonomy.Group termGroup, TaxonomyTermSetDefinition termSetModel)
{
TermSet result = null;
if (termSetModel.Id.HasValue)
{
result = termGroup.TermSets.FirstOrDefault(t => t.Id == termSetModel.Id.Value);
}
else if (!string.IsNullOrEmpty(termSetModel.Name))
{
result = termGroup.TermSets.FirstOrDefault(t => t.Name.ToUpper() == termSetModel.Name.ToUpper());
}
return(result);
}
//[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);
}
public void CanDeploy_TaxonomyFieldBindedToTermByName()
{
var termSet = new TaxonomyTermSetDefinition
{
Name = Rnd.String(),
Description = Rnd.String(),
};
var term = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Description = Rnd.String(),
};
var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
{
def.TermSetName = termSet.Name;
def.TermName = term.Name;
});
var taxonomyModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomTermStore(termStore =>
{
termStore.AddRandomTermGroup(group =>
{
group.AddTaxonomyTermSet(termSet, t =>
{
t.AddTaxonomyTerm(term);
});
});
});
});
var fieldModel = SPMeta2Model
.NewSiteModel(site =>
{
site.AddTaxonomyField(taxField);
});
TestModels(new ModelNode[] { taxonomyModel, fieldModel });
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as TaxonomyTermSetReverseHost);
var item = typedHost.HostTermSet;
var def = new TaxonomyTermSetDefinition();
def.Id = item.Id;
def.Name = item.Name;
def.Description = item.Description;
def.Contact = item.Contact;
def.IsAvailableForTagging = item.IsAvailableForTagging;
def.IsOpenForTermCreation = item.IsOpenForTermCreation;
return(new TaxonomyTermSetModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
private void DeployTaxonomyTermSet(object modelHost, TermGroupModelHost groupModelHost, TaxonomyTermSetDefinition termSetModel)
{
var termStore = groupModelHost.HostTermStore;
var termGroup = groupModelHost.HostGroup;
var currentTermSet = FindTermSet(termGroup, termSetModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentTermSet,
ObjectType = typeof(TermSet),
ObjectDefinition = termSetModel,
ModelHost = modelHost
});
if (currentTermSet == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term Set");
currentTermSet = termSetModel.Id.HasValue
? termGroup.CreateTermSet(termSetModel.Name, termSetModel.Id.Value, termSetModel.LCID)
: termGroup.CreateTermSet(termSetModel.Name, Guid.NewGuid(), termSetModel.LCID);
currentTermSet.IsAvailableForTagging = termSetModel.IsAvailableForTagging;
currentTermSet.Description = termSetModel.Description;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTermSet,
ObjectType = typeof(TermSet),
ObjectDefinition = termSetModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term Set");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTermSet,
ObjectType = typeof(TermSet),
ObjectDefinition = termSetModel,
ModelHost = modelHost
});
}
termStore.CommitAll();
termStore.Context.ExecuteQuery();
}
//[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 ModelNode AddTaxonomyTermSet(this ModelNode model, TaxonomyTermSetDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNode(definition, action));
}
public static ModelNode AddHostTaxonomyTermSet(this ModelNode model, TaxonomyTermSetDefinition definition)
{
return(AddHostTaxonomyTermSet(model, definition, null));
}
public static TModelNode AddHostTaxonomyTermSet <TModelNode>(this TModelNode model, TaxonomyTermSetDefinition definition,
Action <TaxonomyTermSetModelNode> action)
where TModelNode : ModelNode, ITaxonomyTermSetHostModelNode, new()
{
return(model.AddTypedDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
public static TModelNode AddHostTaxonomyTermSet <TModelNode>(this TModelNode model, TaxonomyTermSetDefinition definition)
where TModelNode : ModelNode, ITaxonomyTermSetHostModelNode, new()
{
return(AddHostTaxonomyTermSet(model, definition, null));
}
public static TModelNode AddTaxonomyTermSet <TModelNode>(this TModelNode model, TaxonomyTermSetDefinition definition,
Action <TaxonomyTermSetModelNode> action)
where TModelNode : ModelNode, ITaxonomyTermSetHostModelNode, new()
{
return(model.AddTypedDefinitionNode(definition, action));
}
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 AddHostTaxonomyTermSet(this ModelNode model, TaxonomyTermSetDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
private void DeployTaxonomyTermSet(object modelHost, TermGroupModelHost groupModelHost, TaxonomyTermSetDefinition termSetModel)
{
var termStore = groupModelHost.HostTermStore;
var termGroup = groupModelHost.HostGroup;
var currentTermSet = FindTermSet(termGroup, termSetModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentTermSet,
ObjectType = typeof(TermSet),
ObjectDefinition = termSetModel,
ModelHost = modelHost
});
if (currentTermSet == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term Set");
currentTermSet = termSetModel.Id.HasValue
? termGroup.CreateTermSet(termSetModel.Name, termSetModel.Id.Value, termSetModel.LCID)
: termGroup.CreateTermSet(termSetModel.Name, Guid.NewGuid(), termSetModel.LCID);
MapTermSet(currentTermSet, termSetModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTermSet,
ObjectType = typeof(TermSet),
ObjectDefinition = termSetModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term Set");
UpdateExistingTaxonomyTermSet(modelHost, termSetModel, currentTermSet);
}
termStore.CommitAll();
try
{
termStore.Context.ExecuteQueryWithTrace();
}
catch (Exception e)
{
var context = groupModelHost.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 == -2146233088)
{
currentTermSet = FindTermSet(termGroup, termSetModel);
if (currentTermSet == null)
{
TryRetryService.TryWithRetry(() =>
{
currentTermSet = FindTermSet(termGroup, termSetModel);
return(currentTermSet != null);
});
}
UpdateExistingTaxonomyTermSet(modelHost, termSetModel, currentTermSet);
termStore.CommitAll();
termStore.RefreshLoad();
termStore.Context.ExecuteQueryWithTrace();
}
}
groupModelHost.ShouldUpdateHost = false;
}
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);
}
private void Internal_TaxonomyFieldBinded_ById_Within_SiteCollectionGroup(bool isTermSet, bool isTerm)
{
var termSetName = Rnd.String();
var termName = Rnd.String();
var termSet1Id = Rnd.Guid();
var termSet2Id = Rnd.Guid();
var termSet3Id = Rnd.Guid();
var term1Id = Rnd.Guid();
var term2Id = Rnd.Guid();
var term3Id = Rnd.Guid();
// same same names
var termSet1 = new TaxonomyTermSetDefinition
{
Name = termSetName,
Description = Rnd.String(),
};
var termSet2 = new TaxonomyTermSetDefinition
{
Name = termSetName,
Id = termSet2Id,
Description = Rnd.String(),
};
var termSet3 = new TaxonomyTermSetDefinition
{
Name = termSetName,
Description = Rnd.String(),
};
var term1 = new TaxonomyTermDefinition
{
Name = termName,
Description = Rnd.String(),
Id = term1Id
};
var term2 = new TaxonomyTermDefinition
{
Name = termName,
Description = Rnd.String(),
Id = term2Id,
};
var term3 = new TaxonomyTermDefinition
{
Name = termName,
Description = Rnd.String(),
Id = term3Id
};
var termGroup1 = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
{
});
var termGroup2 = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
{
def.IsSiteCollectionGroup = true;
});
var termGroup3 = ModelGeneratorService.GetRandomDefinition <TaxonomyTermGroupDefinition>(def =>
{
});
// binding to the 2nd one
var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
{
def.IsSiteCollectionGroup = true;
// these should be resolvbed as we are scoped to the 2nd group within site collection group
if (isTermSet)
{
def.TermSetId = termSet2.Id;
}
if (isTerm)
{
def.TermId = term2.Id;
}
});
var taxonomyModel = SPMeta2Model.NewSiteModel(site =>
{
site.AddRandomTermStore(termStore =>
{
termStore.AddTaxonomyTermGroup(termGroup1, group =>
{
group.AddTaxonomyTermSet(termSet1, t =>
{
t.AddTaxonomyTerm(term1);
});
});
termStore.AddTaxonomyTermGroup(termGroup2, group =>
{
group.AddTaxonomyTermSet(termSet2, t =>
{
t.AddTaxonomyTerm(term2);
});
});
termStore.AddTaxonomyTermGroup(termGroup3, group =>
{
group.AddTaxonomyTermSet(termSet3, t =>
{
t.AddTaxonomyTerm(term3);
});
});
});
});
var fieldModel = SPMeta2Model
.NewSiteModel(site =>
{
site.AddTaxonomyField(taxField);
});
TestModels(new ModelNode[] { taxonomyModel, fieldModel });
}
