protected void MapTermProperties(Term currentTerm, TaxonomyTermDefinition termModel)
{
if (!string.IsNullOrEmpty(termModel.Description))
{
currentTerm.SetDescription(termModel.Description, termModel.LCID);
}
if (!string.IsNullOrEmpty(termModel.CustomSortOrder))
{
currentTerm.CustomSortOrder = termModel.CustomSortOrder;
}
if (termModel.IsAvailableForTagging.HasValue)
{
currentTerm.IsAvailableForTagging = termModel.IsAvailableForTagging.Value;
}
#if !NET35
foreach (var customProp in termModel.CustomProperties.Where(p => p.Override))
{
currentTerm.SetCustomProperty(customProp.Name, customProp.Value);
}
#endif
#if !NET35
foreach (var customProp in termModel.LocalCustomProperties.Where(p => p.Override))
{
currentTerm.SetLocalCustomProperty(customProp.Name, customProp.Value);
}
#endif
}
private void MapTermProperties(Term currentTerm, TaxonomyTermDefinition termModel)
{
currentTerm.SetDescription(termModel.Description, termModel.LCID);
foreach (var customProp in termModel.CustomProperties.Where(p => p.Override))
{
currentTerm.SetCustomProperty(customProp.Name, customProp.Value);
}
}
protected Term FindTermInTermSet(TermSet termSet, TaxonomyTermDefinition termModel)
{
Term result = null;
var context = termSet.Context;
if (termModel.Id.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termSet.Terms.GetById(termModel.Id.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.Name))
{
var termName = NormalizeTermName(termModel.Name);
var terms = termSet.GetTerms(new LabelMatchInformation(context)
{
Lcid = termModel.LCID,
TermLabel = termName,
TrimUnavailable = false
});
context.Load(terms);
context.ExecuteQueryWithTrace();
result = terms.FirstOrDefault();
}
if (result != null &&
result.ServerObjectIsNull.HasValue &&
result.ServerObjectIsNull == false)
{
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
protected Term FindTermInTermSet(TermSet termSet, TaxonomyTermDefinition termModel)
{
Term result = null;
if (termModel.Id.HasValue)
{
result = termSet.GetTerm(termModel.Id.Value);
}
else if (!string.IsNullOrEmpty(termModel.Name))
{
result = termSet.GetTerms(termModel.Name, termModel.LCID, false).FirstOrDefault();
}
return(result);
}
private Term FindTermInTerm(Term term, TaxonomyTermDefinition termModel)
{
Term result = null;
if (termModel.Id.HasValue)
{
result = term.Terms.FirstOrDefault(t => t.Id == termModel.Id.Value);
}
else if (!string.IsNullOrEmpty(termModel.Name))
{
result = term.Terms.FirstOrDefault(t => t.Name == termModel.Name);
}
return(result);
}
protected Term FindTermInTerm(Term term, TaxonomyTermDefinition termModel)
{
Term result = null;
var context = term.Context;
// TODO
if (termModel.Id.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = term.Terms.GetById(termModel.Id.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
}
else if (!string.IsNullOrEmpty(termModel.Name))
{
var terms = term.Terms;
context.Load(terms);
context.ExecuteQueryWithTrace();
result = term.Terms.FirstOrDefault(t => t.Name == termModel.Name);
}
if (result != null && result.ServerObjectIsNull == false)
{
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
public void CanDeploy_TaxonomyFieldBindedToTermById()
{
var termSet = new TaxonomyTermSetDefinition
{
Name = Rnd.String(),
Description = Rnd.String(),
};
var term = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Description = Rnd.String(),
Id = Guid.NewGuid()
};
var taxField = ModelGeneratorService.GetRandomDefinition <TaxonomyFieldDefinition>(def =>
{
def.TermSetName = termSet.Name;
def.TermId = term.Id.Value;
});
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[] { taxonomyModel, fieldModel });
}
protected Term FindTermInTerm(Term term, TaxonomyTermDefinition termModel)
{
Term result = null;
IEnumerable <Term> results = null;
var context = term.Context;
// TODO
if (termModel.Id.HasValue)
{
var id = termModel.Id.Value;
results = context.LoadQuery(term.Terms.Where(t => t.Id == id));
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.Name))
{
var name = termModel.Name;
//var terms = term.Terms;
//context.Load(terms);
//context.ExecuteQueryWithTrace();
results = context.LoadQuery(term.Terms.Where(t => t.Name == name));
context.ExecuteQueryWithTrace();
//result = term.Terms.FirstOrDefault(t => t.Name == termModel.Name);
}
result = results.FirstOrDefault();
if (result != null)
{
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
private void MapTermProperties(Term currentTerm, TaxonomyTermDefinition termModel, bool isNewObject)
{
if (!string.IsNullOrEmpty(termModel.Description))
{
currentTerm.SetDescription(termModel.Description, termModel.LCID);
}
if (!string.IsNullOrEmpty(termModel.CustomSortOrder))
{
currentTerm.CustomSortOrder = termModel.CustomSortOrder;
}
if (termModel.IsAvailableForTagging.HasValue)
{
currentTerm.IsAvailableForTagging = termModel.IsAvailableForTagging.Value;
}
UpdateTermProperties(currentTerm, termModel, false, isNewObject);
UpdateTermProperties(currentTerm, termModel, true, isNewObject);
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as TaxonomyTermReverseHost);
var item = typedHost.HostTerm;
var def = new TaxonomyTermDefinition();
def.Id = item.Id;
def.Name = item.Name;
def.Description = item.Description;
def.IsAvailableForTagging = item.IsAvailableForTagging;
return(new TaxonomyTermModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public static ModelNode AddHostTaxonomyTerm(this ModelNode model, TaxonomyTermDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
private void DeployTermUnderTerm(object modelHost, TermModelHost groupModelHost, TaxonomyTermDefinition termModel)
{
var termStore = groupModelHost.HostTermStore;
var termSet = groupModelHost.HostTerm;
var currentTerm = FindTermInTerm(termSet, termModel);
var termName = NormalizeTermName(termModel.Name);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
if (currentTerm == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term");
currentTerm = termModel.Id.HasValue
? termSet.CreateTerm(termName, termModel.LCID, termModel.Id.Value)
: termSet.CreateTerm(termName, termModel.LCID, Guid.NewGuid());
MapTermProperties(currentTerm, termModel, true);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term");
MapTermProperties(currentTerm, termModel, false);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
}
try
{
termStore.CommitAll();
currentTerm.RefreshLoad();
termStore.Context.ExecuteQueryWithTrace();
}
catch (Exception e)
{
var context = groupModelHost.HostClientContext;
if (!IsSharePointOnlineContext(context))
{
throw;
}
var serverException = e as ServerException;
if (serverException != null &&
ReflectionUtils.GetHResultValue(serverException).Value == -2146233088 &&
serverException.ServerErrorTypeName == "Microsoft.SharePoint.Taxonomy.TermStoreOperationException")
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term");
currentTerm = FindTermInTerm(termSet, termModel);
if (currentTerm == null)
{
TryRetryService.TryWithRetry(() =>
{
currentTerm = FindTermInTerm(termSet, termModel);
return(currentTerm != null);
});
}
MapTermProperties(currentTerm, termModel, false);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
termStore.CommitAll();
termStore.Context.ExecuteQueryWithTrace();
}
}
}
private void UpdateTermProperties(Term currentTerm, TaxonomyTermDefinition termModel, bool isLocalProperties, bool isNewObject)
{
// TaxonomyTermCustomProperty.Overwrite set to false - No properties are created. #932
// https://github.com/SubPointSolutions/spmeta2/issues/932
// 1 - set everything what is not there
var srcProperties = termModel.CustomProperties;
IDictionary <string, string> dstProperties = null;
if (!isNewObject)
{
dstProperties = currentTerm.CustomProperties;
}
if (isLocalProperties)
{
TraceService.Information((int)LogEventId.ModelProvision, "Processing local custom properties");
srcProperties = termModel.LocalCustomProperties;
if (!isNewObject)
{
dstProperties = currentTerm.LocalCustomProperties;
}
}
else
{
TraceService.Information((int)LogEventId.ModelProvision, "Processing custom properties");
srcProperties = termModel.CustomProperties;
if (!isNewObject)
{
dstProperties = currentTerm.CustomProperties;
}
}
foreach (var prop in srcProperties)
{
var propName = prop.Name;
var propValue = prop.Value;
var propExist = false;
if (isNewObject)
{
propExist = false;
}
else
{
propExist = dstProperties.Keys
.FirstOrDefault(k => k.ToUpper() == propName.ToUpper())
!= null;
}
if (!propExist)
{
TraceService.Information((int)LogEventId.ModelProvision,
string.Format("Property [{0}] does not exist. Adding with value:[{1}]",
new object[] { prop.Name, prop.Value }));
if (isLocalProperties)
{
currentTerm.SetLocalCustomProperty(propName, propValue);
}
else
{
currentTerm.SetCustomProperty(propName, propValue);
}
}
else
{
TraceService.Information((int)LogEventId.ModelProvision,
string.Format("Property [{0}] exists. No need to add it. Optionally, it will be owerwritten if .Override is set 'true'",
new object[] { propName, propValue }));
}
}
// 2 - override as needed
foreach (var prop in srcProperties.Where(p => p.Override))
{
var propName = prop.Name;
var propValue = prop.Value;
TraceService.Information((int)LogEventId.ModelProvision,
string.Format("Overwriting property [{0}] with value:[{1}] as .Override is set 'true'",
new object[] { propName, propValue }));
if (isLocalProperties)
{
currentTerm.SetLocalCustomProperty(propName, propValue);
}
else
{
currentTerm.SetCustomProperty(propName, propValue);
}
}
}
private void DeployTermUnderTerm(object modelHost, TermModelHost groupModelHost, TaxonomyTermDefinition termModel)
{
var termStore = groupModelHost.HostTermStore;
var termSet = groupModelHost.HostTerm;
var currentTerm = FindTermInTerm(termSet, termModel);
var termName = NormalizeTermName(termModel.Name);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
if (currentTerm == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term");
currentTerm = termModel.Id.HasValue
? termSet.CreateTerm(termName, termModel.LCID, termModel.Id.Value)
: termSet.CreateTerm(termName, termModel.LCID, Guid.NewGuid());
MapTermProperties(currentTerm, termModel, true);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term");
MapTermProperties(currentTerm, termModel, false);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
}
termStore.CommitAll();
termStore.Context.ExecuteQueryWithTrace();
}
public static TModelNode AddHostTaxonomyTerm <TModelNode>(this TModelNode model, TaxonomyTermDefinition definition,
Action <TaxonomyTermModelNode> action)
where TModelNode : ModelNode, ITaxonomyTermHostModelNode, new()
{
return(model.AddTypedDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing()));
}
public void Can_Reverse_Terms()
{
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 term1 = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Description = Rnd.String()
};
var term2 = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
Description = Rnd.String()
};
var term3 = new TaxonomyTermDefinition
{
Name = Rnd.String(),
Id = Rnd.Guid(),
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, termSet =>
{
termSet.AddTaxonomyTerm(term1, t =>
{
t.AddTaxonomyTerm(term3);
});
termSet.AddTaxonomyTerm(term2);
});
});
});
});
DeployReverseAndTestModel(model, options);
}
public static ModelNode AddHostTaxonomyTerm(this ModelNode model, TaxonomyTermDefinition definition)
{
return(AddHostTaxonomyTerm(model, definition, null));
}
public static ModelNode AddTaxonomyTerm(this ModelNode model, TaxonomyTermDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNode(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);
}
//[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);
}
private void DeployTermUnderTermSet(object modelHost, TermSetModelHost groupModelHost, TaxonomyTermDefinition termModel)
{
var termSet = groupModelHost.HostTermSet;
var currentTerm = FindTermInTermSet(termSet, termModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
if (currentTerm == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new Term");
currentTerm = termModel.Id.HasValue
? termSet.CreateTerm(termModel.Name, termModel.LCID, termModel.Id.Value)
: termSet.CreateTerm(termModel.Name, termModel.LCID);
currentTerm.SetDescription(termModel.Description, termModel.LCID);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing Term");
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = currentTerm,
ObjectType = typeof(Term),
ObjectDefinition = termModel,
ModelHost = modelHost
});
}
groupModelHost.HostTermStore.CommitAll();
}
public static TModelNode AddTaxonomyTerm <TModelNode>(this TModelNode model, TaxonomyTermDefinition definition,
Action <TaxonomyTermModelNode> action)
where TModelNode : ModelNode, ITaxonomyTermHostModelNode, new()
{
return(model.AddTypedDefinitionNode(definition, action));
}
public static TModelNode AddHostTaxonomyTerm <TModelNode>(this TModelNode model, TaxonomyTermDefinition definition)
where TModelNode : ModelNode, ITaxonomyTermHostModelNode, new()
{
return(AddHostTaxonomyTerm(model, definition, null));
}
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 });
}