public static TermSet LookupTermSet(ClientRuntimeContext context, Site site,
TermStore termStore, TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermSet(context, termStore, site,
taxFieldModel.TermGroupName, taxFieldModel.TermGroupId, taxFieldModel.IsSiteCollectionGroup,
taxFieldModel.TermSetName, taxFieldModel.TermSetId, taxFieldModel.TermSetLCID));
}
public static TermSet LookupTermSet(
ClientContext clientContext,
TermStore termStore,
TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermSet(clientContext, clientContext.Site, termStore, taxFieldModel));
}
public static TermSet LookupTermSet(TermStore tesmStore, TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermSet(tesmStore,
taxFieldModel.TermSetName,
taxFieldModel.TermSetId,
taxFieldModel.TermSetLCID
));
}
public static TermSet LookupTermSet(
SiteModelHost currentSiteModelHost,
TermStore termStore,
TaxonomyFieldDefinition taxFieldModel)
{
var storeContext = currentSiteModelHost.HostClientContext;
return(LookupTermSet(storeContext, termStore, taxFieldModel));
}
private void Create()
{
belongToProjectField = GetBelognToProjectField();
documentResponsibleField = GetDocumentResponsibleField();
documentTypeField = GetDocumentTypeField();
expirationDateField = GetExpirationDateField();
projectDocumentsList = GetProjectDocumentsList();
projectDocumentContemtType = GetProjectDocumentContemtType();
projectDocumentsListView = GetProjectDocumentsListView();
}
public void TaxonomyFieldDefinition_AllowMultipleValues_ShouldUpdate_FieldType()
{
var def = new TaxonomyFieldDefinition();
def.IsMulti = false;
Assert.IsTrue(def.FieldType == BuiltInFieldTypes.TaxonomyFieldType);
def.IsMulti = true;
Assert.IsTrue(def.FieldType == BuiltInFieldTypes.TaxonomyFieldTypeMulti);
}
public static Term LookupTerm(SPSite site, TermStore tesmStore, TaxonomyFieldDefinition taxFieldModel)
{
Group currentGroup = null;
var termGroupName = taxFieldModel.TermGroupName;
var groupId = taxFieldModel.TermGroupId;
var isSiteCollectionGroup = taxFieldModel.IsSiteCollectionGroup;
if (!string.IsNullOrEmpty(termGroupName))
{
currentGroup = tesmStore.Groups.FirstOrDefault(g => g.Name.ToUpper() == termGroupName.ToUpper());
}
else if (groupId != null && groupId.HasGuidValue())
{
currentGroup = tesmStore.GetGroup(groupId.Value);
}
else if (isSiteCollectionGroup.HasValue && isSiteCollectionGroup.Value)
{
currentGroup = tesmStore.GetSiteCollectionGroup(site);
}
// TODO
// that should also check if the TermSet is there, so to scope the term
if (currentGroup != null)
{
if (taxFieldModel.TermId.HasValue)
{
return(tesmStore.GetTerm(taxFieldModel.TermId.Value));
}
if (!string.IsNullOrEmpty(taxFieldModel.TermName))
{
return(tesmStore.GetTerms(taxFieldModel.TermName, taxFieldModel.TermLCID, false)
.FirstOrDefault(t => t.TermSet.Group.Name == currentGroup.Name));
}
}
else
{
if (taxFieldModel.TermId.HasValue)
{
return(tesmStore.GetTerm(taxFieldModel.TermId.Value));
}
if (!string.IsNullOrEmpty(taxFieldModel.TermName))
{
return(tesmStore.GetTerms(taxFieldModel.TermName, taxFieldModel.TermLCID, false).FirstOrDefault());
}
}
return(null);
}
public void Create()
{
projectStatusField = GetProjectStatusField();
startDateField = GetStartDateField();
teamField = GetTeamField();
departmentField = GetDepartmentField();
endDateField = GetEndDateField();
projectManagerField = GetProjectManagerField();
projectValueField = GetProjectValueField();
projectContemtType = GetProjectContemtType();
projectsList = GetProjectsList();
managedProjectsListView = GetManagedProjectsListView();
}
public static Term LookupTerm(TermStore tesmStore, TaxonomyFieldDefinition taxFieldModel)
{
if (taxFieldModel.TermId.HasValue)
{
return(tesmStore.GetTerm(taxFieldModel.TermId.Value));
}
if (!string.IsNullOrEmpty(taxFieldModel.TermName))
{
return(tesmStore.GetTerms(taxFieldModel.TermName, taxFieldModel.TermLCID, false).FirstOrDefault());
}
return(null);
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as TaxonomyFieldReverseHost).HostTaxonomyField;
var def = new TaxonomyFieldDefinition();
// TODO
//def.Name = item.Name;
return(new TaxonomyFieldModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public static TermSet LookupTermSet(SPSite site, TermStore tesmStore, TaxonomyFieldDefinition taxFieldModel)
{
return LookupTermSet(tesmStore,
taxFieldModel.TermGroupName,
taxFieldModel.TermGroupId,
taxFieldModel.IsSiteCollectionGroup,
site,
taxFieldModel.TermSetName,
taxFieldModel.TermSetId,
taxFieldModel.TermSetLCID
);
}
public static TermStore LookupTermStore(SPSite site, TaxonomyFieldDefinition taxFieldModel)
{
var taxSession = new TaxonomySession(site);
if (taxFieldModel.UseDefaultSiteCollectionTermStore == true)
return taxSession.DefaultSiteCollectionTermStore;
if (taxFieldModel.SspId.HasValue)
return taxSession.TermStores[taxFieldModel.SspId.Value];
if (!string.IsNullOrEmpty(taxFieldModel.SspName))
return taxSession.TermStores[taxFieldModel.SspName];
return null;
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as TaxonomyFieldReverseHost).HostTaxonomyField;
var def = new TaxonomyFieldDefinition();
// TODO
//def.Name = item.Name;
return new TaxonomyFieldModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
};
}
public static TermStore LookupTermStore(SiteModelHost currentSiteModelHost, TaxonomyFieldDefinition taxFieldModel)
{
var termStore = TaxonomyTermStoreModelHandler.FindTermStore(currentSiteModelHost,
taxFieldModel.SspName,
taxFieldModel.SspId,
taxFieldModel.UseDefaultSiteCollectionTermStore);
if (termStore == null)
{
throw new ArgumentNullException("termStore is NULL. Please define SspName, SspId or ensure there is a default term store for the giving site.");
}
var storeContext = currentSiteModelHost.HostClientContext;
storeContext.Load(termStore, s => s.Id);
storeContext.ExecuteQueryWithTrace();
return(termStore);
}
public static TermSet LookupTermSet(ClientRuntimeContext context, TermStore termStore, TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermSet(context, termStore,
taxFieldModel.TermSetName, taxFieldModel.TermSetId, taxFieldModel.TermSetLCID));
}
public static TModelNode AddTaxonomyField <TModelNode>(this TModelNode model, TaxonomyFieldDefinition definition,
Action <TaxonomyFieldModelNode> action)
where TModelNode : ModelNode, IFieldHostModelNode, new()
{
return(model.AddTypedDefinitionNode(definition, action));
}
public static ModelNode AddTaxonomyField(this ModelNode model, TaxonomyFieldDefinition definition)
{
return(AddTaxonomyField(model, definition, null));
}
public static TermSet LookupTermSet(SiteModelHost currentSiteModelHost, TermStore termStore, TaxonomyFieldDefinition taxFieldModel)
{
var storeContext = currentSiteModelHost.HostClientContext;
if (!string.IsNullOrEmpty(taxFieldModel.TermSetName))
{
var termSets = termStore.GetTermSetsByName(taxFieldModel.TermSetName, taxFieldModel.TermSetLCID);
storeContext.Load(termSets);
storeContext.ExecuteQueryWithTrace();
return(termSets.FirstOrDefault());
}
if (taxFieldModel.TermSetId.HasValue)
{
TermSet termSet = null;
var scope = new ExceptionHandlingScope(storeContext);
using (scope.StartScope())
{
using (scope.StartTry())
{
termSet = termStore.GetTermSet(taxFieldModel.TermSetId.Value);
storeContext.Load(termSet);
}
using (scope.StartCatch())
{
}
}
storeContext.ExecuteQueryWithTrace();
if (termSet != null && termSet.ServerObjectIsNull == false)
{
storeContext.Load(termSet, g => g.Id);
storeContext.ExecuteQueryWithTrace();
return(termSet);
}
}
return(null);
}
public static TermStore LookupTermStore(ClientContext clientContext,
TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermStore(clientContext, taxFieldModel, false));
}
public static Term LookupTerm(ClientContext clientContext, TermStore termStore,
TermSet termSet,
TaxonomyFieldDefinition termModel)
{
var context = clientContext;
var site = clientContext.Site;
Term result = null;
TermGroup currenGroup = null;
var termGroupName = termModel.TermGroupName;
var termGroupId = termModel.TermGroupId;
var isSiteCollectionGroup = termModel.IsSiteCollectionGroup;
if (!string.IsNullOrEmpty(termGroupName))
{
currenGroup = termStore.Groups.GetByName(termGroupName);
context.Load(currenGroup);
context.ExecuteQueryWithTrace();
}
else if (termGroupId != null && termGroupId.HasGuidValue())
{
currenGroup = termStore.Groups.GetById(termGroupId.Value);
context.Load(currenGroup);
context.ExecuteQueryWithTrace();
}
else if (isSiteCollectionGroup == true)
{
currenGroup = termStore.GetSiteCollectionGroup(site, false);
context.Load(currenGroup);
context.ExecuteQueryWithTrace();
}
if (currenGroup != null)
{
if (termModel.TermId.HasValue)
{
// by ID, the only one match
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termStore.GetTerm(termModel.TermId.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.TermName))
{
var terms = termStore.GetTerms(new LabelMatchInformation(context)
{
Lcid = termModel.TermLCID,
TermLabel = termModel.TermName,
TrimUnavailable = false
});
context.Load(terms, t => t.Include(
i => i.Id,
i => i.Name,
i => i.TermSet,
i => i.TermSet.Group,
i => i.TermSet.Group.Name
));
context.ExecuteQueryWithTrace();
result = terms.FirstOrDefault(t => t.TermSet.Group.Name == currenGroup.Name);
if ((result == null) && (termSet != null))
// sometimes label match information does not return the term
{
var allTerms = termSet.GetAllTerms();
context.Load(allTerms, t => t.Include(
i => i.Id,
i => i.Name,
i => i.TermSet,
i => i.TermSet.Group,
i => i.TermSet.Group.Name,
i => i.Labels
));
context.ExecuteQueryWithTrace();
result = allTerms.FirstOrDefault(t => (t.TermSet.Group.Name == currenGroup.Name) && (t.Labels.Any(l => l.Value == termModel.TermName && l.Language == termModel.TermLCID)));
}
}
}
else
{
if (termModel.TermId.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termStore.GetTerm(termModel.TermId.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.TermName))
{
var terms = termStore.GetTerms(new LabelMatchInformation(context)
{
Lcid = termModel.TermLCID,
TermLabel = termModel.TermName,
TrimUnavailable = false
});
context.Load(terms);
context.ExecuteQueryWithTrace();
result = terms.FirstOrDefault();
if ((result == null) && (termSet != null))
// sometimes label match information does not return the termset
{
var allTerms = termSet.GetAllTerms();
context.Load(allTerms, t => t.Include(
i => i.Id,
i => i.Name,
i => i.TermSet,
i => i.TermSet.Group,
i => i.TermSet.Group.Name,
i => i.Labels
));
context.ExecuteQueryWithTrace();
result =
allTerms.FirstOrDefault(
t => (t.Labels.Any(l => l.Value == termModel.TermName && l.Language == termModel.TermLCID)));
}
}
}
if (result != null && result.ServerObjectIsNull == false)
{
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
public static ModelNode AddTaxonomyField(this ModelNode model, TaxonomyFieldDefinition definition, Action <ModelNode> action)
{
return(model.AddDefinitionNode(definition, action));
}
public static Term LookupTerm(SiteModelHost currentSiteModelHost, TermStore termStore, TaxonomyFieldDefinition termModel)
{
var context = currentSiteModelHost.HostClientContext;
Term result = null;
if (termModel.TermId.HasValue)
{
var scope = new ExceptionHandlingScope(context);
using (scope.StartScope())
{
using (scope.StartTry())
{
result = termStore.GetTerm(termModel.TermId.Value);
context.Load(result);
}
using (scope.StartCatch())
{
}
}
context.ExecuteQueryWithTrace();
}
else if (!string.IsNullOrEmpty(termModel.TermName))
{
var terms = termStore.GetTerms(new LabelMatchInformation(context)
{
Lcid = termModel.TermLCID,
TermLabel = termModel.TermName,
TrimUnavailable = false
});
context.Load(terms);
context.ExecuteQueryWithTrace();
result = terms.FirstOrDefault();
}
if (result != null && result.ServerObjectIsNull == false)
{
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
return(null);
}
public static TModelNode AddTaxonomyField <TModelNode>(this TModelNode model, TaxonomyFieldDefinition definition)
where TModelNode : ModelNode, IFieldHostModelNode, new()
{
return(AddTaxonomyField(model, definition, null));
}
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 TermStore LookupTermStore(SiteModelHost currentSiteModelHost,
TaxonomyFieldDefinition taxFieldModel)
{
return(LookupTermStore(currentSiteModelHost, taxFieldModel, false));
}
public static Term LookupTerm(SiteModelHost currentSiteModelHost, TermStore termStore,
TermSet termSet,
TaxonomyFieldDefinition termModel)
{
return(LookupTerm(currentSiteModelHost.HostClientContext, termStore, termSet, termModel));
}
