public void RemoveType(string name, bool deleteContent)
{
// first remove all attached parts
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(name);
var partDefinitions = typeDefinition.Parts.ToArray();
foreach (var partDefinition in partDefinitions)
{
RemovePartFromType(partDefinition.PartDefinition.Name, name);
// delete the part if it's its own part
if (partDefinition.PartDefinition.Name == name)
{
RemovePart(name);
}
}
_contentDefinitionManager.DeleteTypeDefinition(name);
// TODO: Create a scheduled job to delete the content items
if (deleteContent)
{
var contentItems = _session
.QueryAsync <ContentItem, ContentItemIndex>(x => x.ContentType == name)
.List().Result;
foreach (var contentItem in contentItems)
{
_session.Delete(contentItem);
}
}
_eventBus.Notify <IContentDefinitionEventHandler>(x => x.ContentTypeRemoved(new ContentTypeRemovedContext {
ContentTypeDefinition = typeDefinition
}));
}
public void RemoveType(string name, bool deleteContent)
{
// first remove all attached parts
var typeDefinition = _contentDefinitionManager.GetTypeDefinition(name);
var partDefinitions = typeDefinition.Parts.ToArray();
foreach (var partDefinition in partDefinitions)
{
RemovePartFromType(partDefinition.PartDefinition.Name, name);
// delete the part if it's its own part
if (partDefinition.PartDefinition.Name == name)
{
RemovePart(name);
}
}
_contentDefinitionManager.DeleteTypeDefinition(name);
// delete all content items (but keep versions)
if (deleteContent)
{
var contentItems = Services.ContentManager.Query(name).List();
foreach (var contentItem in contentItems)
{
Services.ContentManager.Remove(contentItem);
}
}
_contentDefinitionEventHandlers.ContentTypeRemoved(new ContentTypeRemovedContext {
ContentTypeDefinition = typeDefinition
});
}
public void DeleteTaxonomy(TaxonomyPart taxonomy)
{
_contentManager.Remove(taxonomy.ContentItem);
// Removing terms
foreach (var term in GetTerms(taxonomy.Id))
{
DeleteTerm(term);
}
_contentDefinitionManager.DeleteTypeDefinition(taxonomy.TermTypeName);
}
// <RemoveContentDefinition>
// <Types>
// <Blog creatable = "true" >
// <Body format="abodyformat"/>
// </Blog>
// </Types>
// <Parts>
// </Parts>
// </RemoveContentDefinition>
public override void Execute(RecipeExecutionContext context)
{
foreach (var metadataElement in context.RecipeStep.Step.Elements())
{
Logger.Debug("Processing element '{0}'.", metadataElement.Name.LocalName);
switch (metadataElement.Name.LocalName)
{
case "Types":
foreach (var element in metadataElement.Elements())
{
var typeName = XmlConvert.DecodeName(element.Name.LocalName);
Logger.Information("Removing content type '{0}'.", typeName);
try {
_contentDefinitionManager.DeleteTypeDefinition(typeName);
_contentDefinitonEventHandlers.ContentTypeRemoved(new ContentTypeRemovedContext {
ContentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(typeName)
});
}
catch (Exception ex) {
Logger.Error(ex, "Error while removing content type '{0}'.", typeName);
throw;
}
}
break;
case "Parts":
foreach (var element in metadataElement.Elements())
{
var partElement = element;
var partName = XmlConvert.DecodeName(element.Name.LocalName);
Logger.Information("Removing content part definition '{0}'.", partName);
try {
_contentDefinitionManager.DeletePartDefinition(partName);
_contentDefinitonEventHandlers.ContentPartRemoved(new ContentPartRemovedContext {
ContentPartDefinition = _contentDefinitionManager.GetPartDefinition(partName)
});
}
catch (Exception ex) {
Logger.Error(ex, "Error while removing content part definition for '{0}'.", partName);
throw;
}
}
break;
default:
Logger.Warning("Unrecognized element '{0}' encountered; skipping", metadataElement.Name.LocalName);
break;
}
}
}
public void DeleteTaxonomy(TaxonomyPart taxonomy)
{
_contentManager.Remove(taxonomy.ContentItem);
// Removing terms
foreach (var term in GetRootTerms(taxonomy.Id))
{
DeleteTerm(term);
}
if (_contentManager.Query <TaxonomyPart, TaxonomyPartRecord>().Where(x => x.Id != taxonomy.Id && x.TermTypeName == taxonomy.TermTypeName).Count() == 0)
{
_contentDefinitionManager.DeleteTypeDefinition(taxonomy.TermTypeName);
}
}
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;
taxonomyService.CreateTermContentType(part);
if (previousName != null && part.Name != previousName)
{
// remove previous term type
contentDefinitionManager.DeleteTypeDefinition(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 OptionSetPartHandler(
IRepository <OptionSetPartRecord> repository,
IOptionSetService optionSetService,
IContentDefinitionManager contentDefinitionManager)
{
int?previousId = null;
Filters.Add(StorageFilter.For(repository));
OnPublished <OptionSetPart>((context, part) => {
var previousTermTypeName = part.TermTypeName;
if (previousId != null && part.Id != previousId)
{
// remove previous term type
contentDefinitionManager.DeleteTypeDefinition(previousTermTypeName);
// update existing fields
foreach (var partDefinition in contentDefinitionManager.ListPartDefinitions())
{
foreach (var field in partDefinition.Fields)
{
if (field.FieldDefinition.Name == typeof(OptionSetField).Name)
{
if (field.Settings.GetModel <OptionSetFieldSettings>().OptionSetId == previousId)
{
contentDefinitionManager.AlterPartDefinition(partDefinition.Name,
cfg => cfg.WithField(field.Name,
builder => builder.WithSetting("TaxonomyFieldSettings.TaxonomyId", part.Id.ToString())));
}
}
}
}
}
});
OnLoading <OptionSetPart>((context, part) => part.OptionItemsField.Loader(x => optionSetService.GetOptionItems(part.Id)));
OnUpdating <TitlePart>((context, part) => {
// if altering the title of a taxonomy, save the name
if (part.As <OptionSetPart>() != null)
{
previousId = 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;
taxonomyService.CreateTermContentType(part);
if (previousName != null && part.Name != previousName) {
// remove previous term type
contentDefinitionManager.DeleteTypeDefinition(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 OptionSetPartHandler(
IRepository<OptionSetPartRecord> repository,
IOptionSetService optionSetService,
IContentDefinitionManager contentDefinitionManager) {
int? previousId = null;
Filters.Add(StorageFilter.For(repository));
OnPublished<OptionSetPart>((context, part) => {
var previousTermTypeName = part.TermTypeName;
if (previousId != null && part.Id != previousId) {
// remove previous term type
contentDefinitionManager.DeleteTypeDefinition(previousTermTypeName);
// update existing fields
foreach (var partDefinition in contentDefinitionManager.ListPartDefinitions()) {
foreach (var field in partDefinition.Fields) {
if (field.FieldDefinition.Name == typeof (OptionSetField).Name) {
if (field.Settings.GetModel<OptionSetFieldSettings>().OptionSetId == previousId) {
contentDefinitionManager.AlterPartDefinition(partDefinition.Name,
cfg => cfg.WithField(field.Name,
builder => builder.WithSetting("TaxonomyFieldSettings.TaxonomyId", part.Id.ToString())));
}
}
}
}
}
});
OnLoading<OptionSetPart>((context, part) => part.OptionItemsField.Loader(x => optionSetService.GetOptionItems(part.Id)));
OnUpdating<TitlePart>((context, part) => {
// if altering the title of a taxonomy, save the name
if (part.As<OptionSetPart>() != null) {
previousId = part.Id;
}
});
}
public void RemoveType(string name, bool deleteContent)
{
// first remove all attached parts
var typeDefinition = _contentDefinitionManager.LoadTypeDefinition(name);
var partDefinitions = typeDefinition.Parts.ToArray();
foreach (var partDefinition in partDefinitions)
{
RemovePartFromType(partDefinition.PartDefinition.Name, name);
// delete the part if it's its own part
if (partDefinition.PartDefinition.Name == name)
{
RemovePart(name);
}
}
_contentDefinitionManager.DeleteTypeDefinition(name);
_contentDefinitionEventHandlers.Invoke((handler, context) => handler.ContentTypeRemoved(context), new ContentTypeRemovedContext {
ContentTypeDefinition = typeDefinition
}, Logger);
}