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");
MapTermSet(currentTermSet, termSetModel);
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();
}
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 == false)
{
context.Load(result);
//context.Load(result, g => g.Id);
//context.Load(result, g => g.Name);
context.ExecuteQueryWithTrace();
return result;
}
return null;
}
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;
}
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;
}
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);
}
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
};
}
public static ModelNode AddHostTaxonomyTermSet(this ModelNode model, TaxonomyTermSetDefinition definition, Action<ModelNode> action)
{
return model.AddDefinitionNodeWithOptions(definition, action, ModelNodeOptions.New().NoSelfProcessing());
}
public static ModelNode AddHostTaxonomyTermSet(this ModelNode model, TaxonomyTermSetDefinition definition)
{
return AddHostTaxonomyTermSet(model, definition, null);
}
public static ModelNode AddTaxonomyTermSet(this ModelNode model, TaxonomyTermSetDefinition definition, Action<ModelNode> action)
{
return model.AddDefinitionNode(definition, action);
}
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
}
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 });
}
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.AddWebFeature(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 });
}
