private void CreateTaxonomy(string taxonomyName, string[] terms)
{
var taxonomy = _taxonomyService.GetTaxonomyByName(taxonomyName);
if (taxonomy == null)
{
try
{
taxonomy = _orchardServices.ContentManager.New("Taxonomy").As <TaxonomyPart>();
taxonomy.Name = taxonomyName;
taxonomy.ContentItem.As <TitlePart>().Title = taxonomyName;
_taxonomyService.CreateTermContentType(taxonomy);
_orchardServices.ContentManager.Create(taxonomy);
_orchardServices.ContentManager.Publish(taxonomy.ContentItem);
foreach (var term in terms)
{
CreateTerm(taxonomy, term);
}
}
catch (System.Exception ex)
{
Logger.Error("Error occurs when create terms with the migration :" + ex.Message);
}
}
}
public void CreateLocalizedTermContentType(TaxonomyPart taxonomy)
{
_taxonomyService.CreateTermContentType(taxonomy);
_contentDefinitionManager.AlterTypeDefinition(taxonomy.TermTypeName,
cfg => cfg
.WithPart("LocalizationPart")
);
}
public TaxonomyPartHandler(
IRepository <TaxonomyPartRecord> repository,
ITaxonomyService taxonomyService,
IContentDefinitionManager contentDefinitionManager)
{
string previousName = null;
Filters.Add(StorageFilter.For(repository));
OnPublished <TaxonomyPart>((context, part) => {
var previousTermTypeName = part.TermTypeName;
if (previousName == null || part.Name == previousName)
{
// is it a new taxonomy ?
taxonomyService.CreateTermContentType(part);
}
else
{
// keep the previous term type name as it would otherwise force us
// to update all terms to use another type
part.TermTypeName = previousTermTypeName;
// update existing fields
foreach (var partDefinition in contentDefinitionManager.ListPartDefinitions())
{
foreach (var field in partDefinition.Fields)
{
if (field.FieldDefinition.Name == typeof(TaxonomyField).Name)
{
if (field.Settings.GetModel <TaxonomyFieldSettings>().Taxonomy == previousName)
{
contentDefinitionManager.AlterPartDefinition(partDefinition.Name,
cfg => cfg.WithField(field.Name,
builder => builder.WithSetting("TaxonomyFieldSettings.Taxonomy", part.Name)));
}
}
}
}
}
});
OnLoading <TaxonomyPart>((context, part) => part.TermsField.Loader(x => taxonomyService.GetTerms(part.Id)));
OnUpdating <TitlePart>((context, part) => {
// if altering the title of a taxonomy, save the name
if (part.As <TaxonomyPart>() != null)
{
previousName = part.Title;
}
});
}
public TaxonomyPartHandler(
IRepository<TaxonomyPartRecord> repository,
ITaxonomyService taxonomyService
)
{
Filters.Add(StorageFilter.For(repository));
OnPublished<TaxonomyPart>(
(context, part) => taxonomyService.CreateTermContentType(part));
OnLoading<TaxonomyPart>(
(context, part) =>
part._terms.Loader(x => taxonomyService.GetTerms(part.Id))
);
}
public TaxonomyPartHandler(
IRepository<TaxonomyPartRecord> repository,
ITaxonomyService taxonomyService,
IContentDefinitionManager contentDefinitionManager)
{
string previousName = null;
Filters.Add(StorageFilter.For(repository));
OnPublished<TaxonomyPart>((context, part) => {
var previousTermTypeName = part.TermTypeName;
if (previousName == null || part.Name == previousName) {
// is it a new taxonomy ?
taxonomyService.CreateTermContentType(part);
}
else {
// keep the previous term type name as it would otherwise force us
// to update all terms to use another type
part.TermTypeName = previousTermTypeName;
// update existing fields
foreach (var partDefinition in contentDefinitionManager.ListPartDefinitions()) {
foreach (var field in partDefinition.Fields) {
if (field.FieldDefinition.Name == typeof (TaxonomyField).Name) {
if (field.Settings.GetModel<TaxonomyFieldSettings>().Taxonomy == previousName) {
contentDefinitionManager.AlterPartDefinition(partDefinition.Name,
cfg => cfg.WithField(field.Name,
builder => builder.WithSetting("TaxonomyFieldSettings.Taxonomy", part.Name)));
}
}
}
}
}
});
OnLoading<TaxonomyPart>( (context, part) => part.TermsField.Loader(x => taxonomyService.GetTerms(part.Id)));
OnUpdating<TitlePart>((context, part) => {
// if altering the title of a taxonomy, save the name
if (part.As<TaxonomyPart>() != null) {
previousName = part.Title;
}
});
}
public TaxonomyPartHandler(
IRepository<TaxonomyPartRecord> repository,
ITaxonomySlugConstraint taxonomySlugConstraint,
ITaxonomyService taxonomyService
) {
Filters.Add(StorageFilter.For(repository));
OnPublished<TaxonomyPart>(
(context, part) => {
taxonomySlugConstraint.AddSlug(part.Slug);
taxonomyService.CreateTermContentType(part);
});
OnUnpublishing<TaxonomyPart>(
(context, part) =>
taxonomySlugConstraint.RemoveSlug(part.Slug)
);
}
public TaxonomyPartHandler(
IRepository <TaxonomyPartRecord> repository,
ITaxonomySlugConstraint taxonomySlugConstraint,
ITaxonomyService taxonomyService
)
{
Filters.Add(StorageFilter.For(repository));
OnPublished <TaxonomyPart>(
(context, part) => {
taxonomySlugConstraint.AddSlug(part.Slug);
taxonomyService.CreateTermContentType(part);
});
OnUnpublishing <TaxonomyPart>(
(context, part) =>
taxonomySlugConstraint.RemoveSlug(part.Slug)
);
}
public TaxonomyPart CreateTaxonomy(string taxonomyName)
{
var existingTaxonomy = _taxonomyService.GetTaxonomyByName(taxonomyName);
if (existingTaxonomy != null)
{
return(existingTaxonomy);
}
var taxonomy = _contentManager.New <TaxonomyPart>("Taxonomy");
taxonomy.As <ICommonPart>().Owner = _membershipService.GetUser(_siteService.GetSiteSettings().SuperUser);
taxonomy.Slug = taxonomyName.ToLowerInvariant();
taxonomy.As <TitlePart>().Title = taxonomyName;
_contentManager.Create(taxonomy, VersionOptions.Published);
_taxonomyService.CreateTermContentType(taxonomy.As <TaxonomyPart>());
return(taxonomy.As <TaxonomyPart>());
}
public TaxonomyPartHandler(
IRepository <TaxonomyPartRecord> repository,
ITaxonomyService taxonomyService,
IContentDefinitionManager contentDefinitionManager,
ILocalizationService localizationService = null) //Localization feature may not be active
{
string previousName = null;
Filters.Add(StorageFilter.For(repository));
OnPublished <TaxonomyPart>((context, part) => {
if (string.IsNullOrWhiteSpace(part.TermTypeName))
{
// is it a new taxonomy ?
taxonomyService.CreateTermContentType(part);
}
else
{
// update existing fields
foreach (var partDefinition in contentDefinitionManager.ListPartDefinitions())
{
foreach (var field in partDefinition.Fields)
{
if (field.FieldDefinition.Name == typeof(TaxonomyField).Name)
{
if (field.Settings.GetModel <TaxonomyFieldSettings>().Taxonomy == previousName)
{
//could either be a name change, or we could be publishing a translation
if (localizationService != null) //Localization feature may not be active
{
var locPart = part.ContentItem.As <LocalizationPart>();
if (locPart != null)
{
var localizedTaxonomies = localizationService
.GetLocalizations(part.ContentItem) //versions in all cultures
.Where(pa => pa.ContentItem.Id != part.ContentItem.Id) //but not the one we are publishing
.Select(pa => {
var tax = pa.ContentItem.As <TaxonomyPart>(); //the TaxonomyPart
return(tax == null ? string.Empty : tax.Name); //get its name (with sanity check)
});
if (localizedTaxonomies.Contains(previousName))
{
continue; //this is a new localization, so move along
}
}
}
contentDefinitionManager.AlterPartDefinition(partDefinition.Name,
cfg => cfg.WithField(field.Name,
builder => builder.WithSetting("TaxonomyFieldSettings.Taxonomy", part.Name)));
}
}
}
}
}
});
OnLoading <TaxonomyPart>((context, part) => part.TermsField.Loader(() => taxonomyService.GetTerms(part.Id)));
OnUpdating <TitlePart>((context, part) => {
// if altering the title of a taxonomy, save the name
if (part.As <TaxonomyPart>() != null)
{
previousName = part.Title;
}
});
}
