public ActionResult Index()
{
var viewModel = new MigrateViewModel {
ContentTypes = new List <ContentTypeEntry>()
};
foreach (var contentType in _contentDefinitionManager.ListTypeDefinitions().OrderBy(c => c.Name))
{
// only display parts with fields
if (contentType.Parts.Any(x => x.PartDefinition.Fields.Any()))
{
viewModel.ContentTypes.Add(new ContentTypeEntry {
ContentTypeName = contentType.Name
});
}
}
if (!viewModel.ContentTypes.Any())
{
_orchardServices.Notifier.Warning(T("There are no content types with custom fields"));
}
if (!_featureManager.GetEnabledFeatures().Any(x => x.Id == "Orchard.Fields"))
{
_orchardServices.Notifier.Warning(T("You need to enable Orchard.Fields in order to migrate current fields."));
}
return(View(viewModel));
}
private IEnumerable <ContentTypeDefinition> GetCreatableTypes(bool andContainable)
{
return(_contentDefinitionManager.ListTypeDefinitions().Where(ctd =>
Services.Authorizer.Authorize(Permissions.CreateContent, _contentManager.New(ctd.Name)) &&
ctd.Settings.GetModel <ContentTypeSettings>().Creatable&&
(!andContainable || ctd.Parts.Any(p => p.PartDefinition.Name == "ContainablePart"))));
}
public IEnumerable <ContentTypeDefinition> GetTerritoryTypes()
{
return(_contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.Parts.Any(pa => pa
.PartDefinition.Name.Equals(TerritoryPart.PartName, StringComparison.InvariantCultureIgnoreCase)) &&
_authorizer.Authorize(TerritoriesPermissions.GetTerritoryPermission(ctd))));
}
public IEnumerable <Permission> GetPermissions()
{
// manage rights only for Creatable types
var creatableTypes = _contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.Settings.GetModel <ContentTypeSettings>().Creatable);
foreach (var provider in _dynamicProviders)
{
foreach (var template in provider.GetCreatableContentPermissionTemplates())
{
foreach (var type in creatableTypes)
{
yield return(CreateDynamicPermission(template, type));
}
}
}
var widgetTypes = _contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.Settings["Stereotype"] == "Widget");
foreach (var provider in _dynamicProviders)
{
foreach (var template in provider.GetWidgetPermissionTemplates())
{
foreach (var type in creatableTypes)
{
yield return(CreateDynamicPermission(template, type));
}
}
}
}
public IEnumerable <Permission> ListTerritoryTypePermissions()
{
return(_contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.Parts.Any(pa => pa
.PartDefinition.Name.Equals(TerritoryPart.PartName, StringComparison.InvariantCultureIgnoreCase)))
.Select(ctd => GetTerritoryPermission(ctd)));
}
protected override DriverResult Editor(ContainerPart part, dynamic shapeHelper)
{
if (!_contentDefinitionManager.ListTypeDefinitions().Any(typeDefinition => typeDefinition.Parts.Any(partDefinition => partDefinition.PartDefinition.Name == "ContainablePart")))
{
_orchardServices.Notifier.Warning(T("There are no content types in the system with a Containable part attached. Consider adding a Containable part to some content type, existing or new, in order to relate items to this (Container enabled) item."));
}
return(Editor(part, (IUpdateModel)null, shapeHelper));
}
public override void Build(BuildContext context)
{
// Get all ContentTypes that contain TerritoryHierarchyPart or TerritoryPart
// because we will export their definitions and all ContentItems.
var hierarchyTypes = _contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.Parts.Any(pa => pa
.PartDefinition.Name.Equals(TerritoryHierarchyPart.PartName, StringComparison.InvariantCultureIgnoreCase)))
.Select(ctd => ctd.Name);
var territoryTypes = _contentDefinitionManager.ListTypeDefinitions()
.Where(ctd => ctd.Parts.Any(pa => pa
.PartDefinition.Name.Equals(TerritoryPart.PartName, StringComparison.InvariantCultureIgnoreCase)))
.Select(ctd => ctd.Name);
// Add a command telling to try and enable this feature
context.RecipeDocument.Element("Orchard")
.Add(EnableFeatureElement());
// Export the TerritoryInternalRecords: This adds to the exported xml commands to recreate the records.
context.RecipeDocument.Element("Orchard")
.Add(ExportInternalRecordsCommands());
// Export ContentDefinitions
if (hierarchyTypes.Any())
{
context.RecipeDocument.Element("Orchard")
.Add(ExportMetadata(hierarchyTypes));
}
if (territoryTypes.Any())
{
context.RecipeDocument.Element("Orchard")
.Add(ExportMetadata(territoryTypes));
}
// Export ContentItems
// 1. Export Hierarchies
// Get the ContentItems for the hierarchies (they have references to their territories)
var hierarchyItems = hierarchyTypes.Any()
? _contentManager
.Query(VersionOptions.Latest, hierarchyTypes.ToArray())
.List().ToList()
: Enumerable.Empty <ContentItem>().ToList();
if (hierarchyItems.Any())
{
context.RecipeDocument.Element("Orchard")
.Add(ExportData(hierarchyTypes, hierarchyItems));
}
// 2. Export Territories
foreach (var hierarchy in hierarchyItems.Select(ci => ci.As <TerritoryHierarchyPart>()))
{
if (hierarchy.Territories.Any())
{
context.RecipeDocument.Element("Orchard")
.Add(ExportTerritories(hierarchy.Territories));
}
}
}
protected override DriverResult Editor(ContentPart part, Fields.SmartContentPickerField field, dynamic shapeHelper)
{
return(ContentShape("Fields_SmartContentPicker_Edit", GetDifferentiator(field, part),
() => {
var settings = field.PartFieldDefinition.Settings.GetModel <SmartContentPickerFieldSettings>();
IEnumerable <ContentTypeDefinition> contentTypes;
if (!String.IsNullOrEmpty(settings.DisplayedContentTypes))
{
var rawTypes = settings.DisplayedContentTypes.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
contentTypes = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x => x.Parts.Any(p => rawTypes.Contains(p.PartDefinition.Name)) || rawTypes.Contains(x.Name))
.ToArray();
}
else
{
contentTypes = GetCreatableTypes(false).ToList();
}
var contentItems = Services.ContentManager.Query(VersionOptions.Latest, contentTypes.Select(ctd => ctd.Name).ToArray())
.OrderBy <TitlePartRecord>(cr => cr.Title)
//.OrderByDescending<CommonPartRecord>(cr => cr.ModifiedUtc)
.List();
var contentType = contentTypes.Select(ctd => ctd.Name).ToArray();
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner))
{
if (contentType.Contains("App"))
{
//App content item permission filtering by role
var roles = (Services.WorkContext.CurrentUser.ContentItem).As <UserRolesPart>().Roles;
contentItems = contentItems.Where(ci => roles.Select(x => x).Intersect((ci.As <ContentPermissionsPart>().ViewContent == null ? "0" : ci.As <ContentPermissionsPart>().ViewContent).Split(',')).Any());
}
else
{
//filter by owned items
//contentItems = contentItems.Where(cr => cr.As<CommonPart>().Owner.Id == Services.WorkContext.CurrentUser.Id);
contentItems = contentItems.Where(cr => Services.WorkContext.CurrentUser.Id == (cr.As <CommonPart>().Owner == null ? 0 : cr.As <CommonPart>().Owner.Id));
}
}
var model = new SmartContentPickerFieldViewModel
{
Field = field,
Part = part,
ContentItems = _contentManager.GetMany <ContentItem>(field.Ids, VersionOptions.Published, QueryHints.Empty).ToList(),
AvailableContentItems = contentItems
};
//model.SelectedIds = string.Concat(",", field.Ids);
return shapeHelper.EditorTemplate(TemplateName: "Fields/SmartContentPicker.Edit", Model: model, Prefix: GetPrefix(field, part));
}));
}
protected override DriverResult Editor(CustomFormPart part, dynamic shapeHelper)
{
return(ContentShape("Parts_CustomForm_Fields", () => {
var contentTypes = _contentDefinitionManager.ListTypeDefinitions().Select(x => x.Name).OrderBy(x => x);
var viewModel = new CustomFormPartEditViewModel {
ContentTypes = contentTypes,
CustomFormPart = part
};
return shapeHelper.EditorTemplate(TemplateName: "Parts.CustomForm.Fields", Model: viewModel, Prefix: Prefix);
}));
}
public int Create()
{
foreach (var typeDefinition in _contentDefinitionManager.ListTypeDefinitions())
{
if (typeDefinition.Settings.ContainsKey("ContentTypeSettings.Creatable") && Convert.ToBoolean(typeDefinition.Settings["ContentTypeSettings.Creatable"], CultureInfo.InvariantCulture))
{
typeDefinition.Settings["ContentTypeSettings.Listable"] = "True";
_contentDefinitionManager.StoreTypeDefinition(typeDefinition);
}
}
return(1);
}
public void GetNavigation(NavigationBuilder builder)
{
// if the user may edit at least one type of Listable content,
// we add the link to the admin menu for them
var contentTypeDefinitions = _contentDefinitionManager
.ListTypeDefinitions()
.OrderBy(d => d.Name);
var listableContentTypes = contentTypeDefinitions
.Where(ctd => ctd
.Settings
.GetModel <ContentTypeSettings>()
.Listable);
ContentItem listableCi = null;
foreach (var contentTypeDefinition in listableContentTypes)
{
listableCi = _contentManager.New(contentTypeDefinition.Name);
if (_authorizer.Authorize(Permissions.EditContent, listableCi))
{
builder.Add(T("Content"),
menu => menu
.Add(T("Advanced Search"), "0.5", item => item.Action("List", "Admin", new { area = "Laser.Orchard.AdvancedSearch" }).LocalNav())
);
break;
}
}
}
public override IDisplayResult Edit(MenuPart part)
{
return(Initialize <MenuPartEditViewModel>("MenuPart_Edit", async model =>
{
var menuItemContentTypes = _contentDefinitionManager.ListTypeDefinitions().Where(t => t.GetSettings <ContentTypeSettings>().Stereotype == "MenuItem");
var notify = false;
foreach (var menuItem in part.ContentItem.As <MenuItemsListPart>().MenuItems)
{
if (!menuItemContentTypes.Any(c => c.Name == menuItem.ContentType))
{
_logger.LogWarning("The menu item content item with id {ContentItemId} has no matching {ContentType} content type definition.", menuItem.ContentItem.ContentItemId, menuItem.ContentItem.ContentType);
await _notifier.WarningAsync(H["The menu item content item with id {0} has no matching {1} content type definition.", menuItem.ContentItem.ContentItemId, menuItem.ContentItem.ContentType]);
notify = true;
}
}
if (notify)
{
await _notifier.WarningAsync(H["Publishing this content item may erase created content. Fix any content type issues beforehand."]);
}
model.MenuPart = part;
model.MenuItemContentTypes = menuItemContentTypes;
}));
}
public async Task FilterAsync(IQuery <ContentItem> query, ListContentsViewModel model, PagerParameters pagerParameters, IUpdateModel updateModel)
{
var viewModel = new ListPartContentAdminFilterModel();
if (await updateModel.TryUpdateModelAsync(viewModel, ""))
{
// Show list content items
if (viewModel.ShowListContentTypes)
{
var listableTypes = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x =>
x.Parts.Any(p =>
p.PartDefinition.Name == nameof(ListPart)))
.Select(x => x.Name);
query.With <ContentItemIndex>(x => x.ContentType.IsIn(listableTypes));
}
// Show contained elements for the specified list
else if (viewModel.ListContentItemId != null)
{
query.With <ContainedPartIndex>(x => x.ListContentItemId == viewModel.ListContentItemId);
}
}
}
public override IDisplayResult Edit(ContentTypePartDefinition contentTypePartDefinition, IUpdateModel updater)
{
if (!String.Equals(nameof(ProjectionPart), contentTypePartDefinition.PartDefinition.Name, StringComparison.Ordinal))
{
return(null);
}
return(Initialize <ProjectionPartSettingsViewModel>("ProjectionPartSettings_Edit", model =>
{
model.ProjectionPartSettings = contentTypePartDefinition.GetSettings <ProjectionPartSettings>();
model.EnablePositioning = model.ProjectionPartSettings.EnablePositioning;
// model.ListViewProviders = _listViewService.Providers.ToList();
model.AdminListViewName = model.ProjectionPartSettings.AdminListViewName;
model.PageSize = model.ProjectionPartSettings.PageSize;
model.ContainedContentTypes = model.ProjectionPartSettings.ContainedContentTypes;
model.ContentTypes = new NameValueCollection();
foreach (var contentTypeDefinition in _contentDefinitionManager.ListTypeDefinitions())
{
model.ContentTypes.Add(contentTypeDefinition.Name, contentTypeDefinition.DisplayName);
}
}).Location("Content"));
}
public static IEnumerable <ContentTypeDefinition> ListUserDefinedTypeDefinitions(this IContentDefinitionManager contentDefinitionManager)
{
var contentTypes = contentDefinitionManager.ListTypeDefinitions();
var parts = contentDefinitionManager.ListPartDefinitions();
return(contentTypes.Where(t => parts.Any(p => p.Name == t.Name)));
}
private XElement ExportMetadata(IEnumerable <string> contentTypes)
{
var typesElement = new XElement("Types");
var partsElement = new XElement("Parts");
var typesToExport = _contentDefinitionManager.ListTypeDefinitions()
.Where(typeDefinition => contentTypes.Contains(typeDefinition.Name))
.ToList();
var partsToExport = new List <string>();
foreach (var contentTypeDefinition in typesToExport)
{
foreach (var contentPartDefinition in contentTypeDefinition.Parts)
{
if (partsToExport.Contains(contentPartDefinition.PartDefinition.Name))
{
continue;
}
partsToExport.Add(contentPartDefinition.PartDefinition.Name);
partsElement.Add(_contentDefinitionWriter.Export(contentPartDefinition.PartDefinition));
}
typesElement.Add(_contentDefinitionWriter.Export(contentTypeDefinition));
}
return(new XElement("Metadata", typesElement, partsElement));
}
private XElement ExportMetadata(IEnumerable <string> contentTypes)
{
var typesElement = new XElement("Types");
var partsElement = new XElement("Parts");
var typesToExport = _contentDefinitionManager.ListTypeDefinitions()
.Where(typeDefinition => contentTypes.Contains(typeDefinition.Name))
.ToList();
var partsToExport = new Dictionary <string, ContentPartDefinition>();
foreach (var contentTypeDefinition in typesToExport.OrderBy(x => x.Name))
{
foreach (var contentPartDefinition in contentTypeDefinition.Parts.OrderBy(x => x.PartDefinition.Name))
{
if (partsToExport.ContainsKey(contentPartDefinition.PartDefinition.Name))
{
continue;
}
partsToExport.Add(contentPartDefinition.PartDefinition.Name, contentPartDefinition.PartDefinition);
}
typesElement.Add(_contentDefinitionWriter.Export(contentTypeDefinition));
}
foreach (var part in partsToExport.Values.OrderBy(x => x.Name))
{
partsElement.Add(_contentDefinitionWriter.Export(part));
}
return(new XElement("ContentDefinition", typesElement, partsElement));
}
private async Task <XRpcArray> MetaWeblogGetUserBlogsAsync(XmlRpcContext context, string userName, string password)
{
var user = await ValidateUserAsync(userName, password);
XRpcArray array = new XRpcArray();
// Look for all types using ListPart
foreach (var type in _contentDefinitionManager.ListTypeDefinitions())
{
if (!type.Parts.Any(x => x.Name == nameof(ListPart)))
{
continue;
}
foreach (var list in await _session.Query <ContentItem, ContentItemIndex>(x => x.ContentType == type.Name).ListAsync())
{
// User needs to at least have permission to edit its own blog posts to access the service
if (await _authorizationService.AuthorizeAsync(user, Permissions.EditContent, list))
{
var metadata = _contentManager.PopulateAspect <ContentItemMetadata>(list);
var displayRouteValues = metadata.DisplayRouteValues;
array.Add(new XRpcStruct()
.Set("url", context.Url.Action(displayRouteValues["action"].ToString(), displayRouteValues["controller"].ToString(), displayRouteValues, context.HttpContext.Request.Scheme))
.Set("blogid", list.ContentItemId)
.Set("blogName", metadata.DisplayText));
}
}
}
return(array);
}
public IEnumerable <EditTypeViewModel> GetTypes()
{
return(_contentDefinitionManager
.ListTypeDefinitions()
.Select(ctd => new EditTypeViewModel(ctd))
.OrderBy(m => m.DisplayName));
}
public void GetNavigation(NavigationBuilder builder)
{
var contentTypeDefinitions = _contentDefinitionManager
.ListTypeDefinitions().OrderBy(d => d.Name);
var contentTypes = contentTypeDefinitions
.Where(ctd => ctd.Settings.GetModel <ContentTypeSettings>().Listable)
.OrderBy(ctd => ctd.DisplayName);
if (contentTypes.Any())
{
builder
.AddImageSet("content")
.Add(T("Content"), "1.4", menu => {
menu.LinkToFirstChild(false);
foreach (var contentTypeDefinition in contentTypes)
{
if (string.Compare(
contentTypeDefinition.Settings["ContentTypeSettings.Listable"],
"true", StringComparison.OrdinalIgnoreCase) == 0)
{
ContentTypeDefinition definition = contentTypeDefinition;
menu.Add(T(contentTypeDefinition.DisplayName), "5", item =>
item.Action("List", "Admin",
new RouteValueDictionary {
{ "area", "Laser.Orchard.AdvancedSearch" },
{ "model.Id", definition.Name }
})
.Permission(DynamicPermissions.CreateDynamicPermission(
DynamicPermissions.PermissionTemplates["EditOwnContent"],
definition)));
}
}
});
}
}
public override IDisplayResult Edit(ContentTypePartDefinition contentTypePartDefinition, IUpdateModel updater)
{
if (!String.Equals(nameof(FlowPart), contentTypePartDefinition.PartDefinition.Name))
{
return(null);
}
return(Initialize <FlowPartSettingsViewModel>("FlowPartSettings_Edit", model =>
{
model.FlowPartSettings = contentTypePartDefinition.GetSettings <FlowPartSettings>();
model.ContainedContentTypes = model.FlowPartSettings.ContainedContentTypes;
model.ContentTypes = new NameValueCollection();
foreach (var contentTypeDefinition in _contentDefinitionManager.ListTypeDefinitions().Where(t => t.GetSettings <ContentTypeSettings>().Stereotype == "Widget"))
{
model.ContentTypes.Add(contentTypeDefinition.Name, contentTypeDefinition.DisplayName);
}
model.Classes = model.FlowPartSettings.ContainerSettings.Classes;
model.Display = model.FlowPartSettings.ContainerSettings.Display;
model.Direction = model.FlowPartSettings.ContainerSettings.Direction;
model.Wrap = model.FlowPartSettings.ContainerSettings.Wrap;
model.JustifyContent = model.FlowPartSettings.ContainerSettings.JustifyContent;
model.AlignItems = model.FlowPartSettings.ContainerSettings.AlignItems;
model.AlignContent = model.FlowPartSettings.ContainerSettings.AlignContent;
model.EnableWidgetsPicker = model.FlowPartSettings.EnableWidgetsPicker;
model.EnableContentBlocksPicker = model.FlowPartSettings.EnableContentBlocksPicker;
model.ContentBlocksLibraryAliasId = model.FlowPartSettings.ContentBlocksLibraryAliasId;
}).Location("Content"));
}
public void GetNavigation(NavigationBuilder builder)
{
var contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions().OrderBy(d => d.Name);
builder.AddImageSet("content")
.Add(T("Content"), "1.4", menu => menu
.Permission(Permissions.EditOwnContent)
.Add(T("Content Items"), "1", item => item.Action("List", "Admin", new { area = "Contents", id = "" }).LocalNav()));
var contentTypes = contentTypeDefinitions.Where(ctd => ctd.Settings.GetModel <ContentTypeSettings>().Creatable).OrderBy(ctd => ctd.DisplayName);
if (contentTypes.Any())
{
builder.Add(T("New"), "-1", menu => {
menu.LinkToFirstChild(false);
foreach (var contentTypeDefinition in contentTypes)
{
var ci = _contentManager.New(contentTypeDefinition.Name);
var cim = _contentManager.GetItemMetadata(ci);
var createRouteValues = cim.CreateRouteValues;
// review: the display name should be a LocalizedString
if (createRouteValues.Any())
{
menu.Add(T(contentTypeDefinition.DisplayName), "5", item => item.Action(cim.CreateRouteValues["Action"] as string, cim.CreateRouteValues["Controller"] as string, cim.CreateRouteValues)
// Apply "PublishOwn" permission for the content type
.Permission(DynamicPermissions.CreateDynamicPermission(DynamicPermissions.PermissionTemplates[Permissions.PublishOwnContent.Name], contentTypeDefinition)));
}
}
});
}
}
public void Describe(DescribeContext context)
{
Func <IShapeFactory, object> form =
shape => {
var f = Shape.Form(
Id: "AnyOfContentTypes",
_Parts: Shape.SelectList(
Id: "contenttypes", Name: "ContentTypes",
Title: T("Content types"),
Description: T("Select some content types."),
Size: 10,
Multiple: true
)
);
f._Parts.Add(new SelectListItem {
Value = "", Text = T("Any").Text
});
foreach (var contentType in _contentDefinitionManager.ListTypeDefinitions().OrderBy(x => x.DisplayName))
{
f._Parts.Add(new SelectListItem {
Value = contentType.Name, Text = contentType.DisplayName
});
}
return(f);
};
context.Form("ContentTypesFilter", form);
}
public IEnumerable <ContentTypeDefinition> ListRoutableTypeDefinitions()
{
var ctds = _contentDefinitionManager.ListTypeDefinitions();
var rctds = ctds.Where(ctd => _options.ContentTypeOptions.Any(o => o.ContentType == ctd.Name));
return(rctds);
}
public override IDisplayResult Edit(ContentTypePartDefinition contentTypePartDefinition, IUpdateModel updater)
{
if (!String.Equals(nameof(CrossReferencePart), contentTypePartDefinition.PartDefinition.Name, StringComparison.Ordinal))
{
return(null);
}
return(Initialize <CrossReferencePartSettingsViewModel>("CrossReferencePartSettings_Edit", model =>
{
model.CrossReferencePartSettings = contentTypePartDefinition.GetSettings <CrossReferencePartSettings>();
model.PageSize = model.CrossReferencePartSettings.PageSize;
model.ContainedContentTypes = model.CrossReferencePartSettings.ContainedContentTypes;
model.ContentTypes = new NameValueCollection();
// model.PagerSlimDisabled = model.CrossReferencePartSettings.PagerSlimDisabled;
foreach (var contentTypeDefinition in _contentDefinitionManager.ListTypeDefinitions())
{
model.ContentTypes.Add(contentTypeDefinition.Name, contentTypeDefinition.DisplayName);
}
model.EnablePositioning = model.CrossReferencePartSettings.EnablePositioning;
model.AllowUserToSwitchListViews = model.CrossReferencePartSettings.AllowUserToSwitchListViews;
model.AllowUserToSwitchListViewsFrontEnd = model.CrossReferencePartSettings.AllowUserToSwitchListViewsFrontEnd;
model.AllowUserToAddChildItems = model.CrossReferencePartSettings.AllowUserToAddChildItems;
model.ShowLatestVersion = model.CrossReferencePartSettings.ShowLatestVersion;
model.ListViewProviders = _listViewService.Providers.ToList();
model.AdminListViewName = model.CrossReferencePartSettings.AdminListViewName;
model.FrontEndListViewName = model.CrossReferencePartSettings.FrontEndListViewName;
model.FrontEndListViews = model.CrossReferencePartSettings.FrontEndListViews;
model.Relation = model.CrossReferencePartSettings.Relation;
}).Location("Content"));
}
public IList <ContentTypeDefinition> GetSettingsTypes()
{
return(_contentDefinitionManager
.ListTypeDefinitions()
.Where(x => x.Settings.ToObject <ContentTypeSettings>().Stereotype == "CustomSettings")
.ToArray());
}
/// <summary>
/// Migrate existing ContentPart settings to WithSettings<typeparamref name="TSettings"/>
/// This method will be removed in a future release.
/// </summary>
/// <typeparam name="TPart"></typeparam>
/// <typeparam name="TSettings"></typeparam>
/// <param name="manager"></param>
public static void MigratePartSettings <TPart, TSettings>(this IContentDefinitionManager manager)
where TPart : ContentPart where TSettings : class
{
var contentTypes = manager.ListTypeDefinitions();
foreach (var contentType in contentTypes)
{
var partDefinition = contentType.Parts.FirstOrDefault(x => x.PartDefinition.Name == typeof(TPart).Name);
if (partDefinition != null)
{
var existingSettings = partDefinition.Settings.ToObject <TSettings>();
// Remove existing properties from JObject
var properties = typeof(TSettings).GetProperties();
foreach (var property in properties)
{
partDefinition.Settings.Remove(property.Name);
}
// Apply existing settings to type definition WithSettings<T>
manager.AlterTypeDefinition(contentType.Name, typeBuilder =>
{
typeBuilder.WithPart(partDefinition.Name, partBuilder =>
{
partBuilder.WithSettings(existingSettings);
});
});
}
}
}
public override async Task <IDisplayResult> EditAsync(TermContainerPart part, BuildPartEditorContext context)
{
var taxonomyIdViewModel = new TaxonomyPartIdViewModel();
if (await context.Updater.TryUpdateModelAsync(taxonomyIdViewModel) &&
!String.IsNullOrEmpty(taxonomyIdViewModel.TaxonomyContentItemId))
{
// By design only supports the first field using the contained editor.
var selectables = _contentDefinitionManager.ListTypeDefinitions()
.SelectMany(ctd => ctd.Parts.Where(p => p.PartDefinition.Fields.Any(f => f.FieldDefinition.Name == nameof(TaxonomyField) &&
f.GetSettings <TaxonomyFieldSettings>().TaxonomyContentItemId == taxonomyIdViewModel.TaxonomyContentItemId &&
f.Editor() == "Contained")));
var entries = selectables.Select(ctd => new ContentTypeEntryViewModel
{
ContentTypeName = ctd.ContentTypeDefinition.Name,
IsSelected = part.ContainedContentTypes.Any(selected => String.Equals(selected, ctd.ContentTypeDefinition.Name, StringComparison.OrdinalIgnoreCase)),
ContentTypeDisplayName = ctd.ContentTypeDefinition.DisplayName
}).ToArray();
return(Initialize <TermContainerPartViewModel>("TermContainerPart", model =>
{
model.TermContainerPart = part;
model.Multiple = part.Multiple;
model.ContainedContentTypes = entries;
}));
}
else
{
return(null);
}
}
private IEnumerable <string> GetContentTypes()
{
return(_contentDefinitionManager
.ListTypeDefinitions()
.Select(t => t.Name)
.OrderBy(x => x));
}
public async Task FilterAsync(ContentOptionsViewModel model, IQuery <ContentItem> query, IUpdateModel updater)
{
var viewModel = new LocalizationContentsAdminFilterViewModel();
if (await updater.TryUpdateModelAsync(viewModel, "Localization"))
{
// Show localization content items
// This is intended to be used by adding ?Localization.ShowLocalizedContentTypes to an AdminMenu url.
if (viewModel.ShowLocalizedContentTypes)
{
var localizedTypes = _contentDefinitionManager
.ListTypeDefinitions()
.Where(x =>
x.Parts.Any(p =>
p.PartDefinition.Name == nameof(LocalizationPart)))
.Select(x => x.Name);
query.With <ContentItemIndex>(x => x.ContentType.IsIn(localizedTypes));
}
// Show contained elements for the specified culture
else if (!String.IsNullOrEmpty(viewModel.SelectedCulture))
{
query.With <LocalizedContentItemIndex>(i => (i.Published || i.Latest) && i.Culture == viewModel.SelectedCulture);
}
}
}
