public async Task BuildNavigationAsync(string name, NavigationBuilder builder)
{
var context = _httpContextAccessor.HttpContext;
if (!String.Equals(name, "admin", StringComparison.OrdinalIgnoreCase))
{
return;
}
var contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions().OrderBy(d => d.Name);
var contentTypes = contentTypeDefinitions.Where(ctd => ctd.GetSettings <ContentTypeSettings>().Creatable).OrderBy(ctd => ctd.DisplayName);
await builder.AddAsync(S["Content"], NavigationConstants.AdminMenuContentPosition, async content =>
{
content.AddClass("content").Id("content");
await content.AddAsync(S["Content Items"], S["Content Items"].PrefixPosition(), async contentItems =>
{
if (!await _authorizationService.AuthorizeContentTypeDefinitionsAsync(context.User, CommonPermissions.EditContent, contentTypes, _contentManager))
{
contentItems.Permission(Permissions.EditContent);
}
contentItems.Action(nameof(AdminController.List), typeof(AdminController).ControllerName(), new { area = "OrchardCore.Contents", contentTypeId = "" });
contentItems.LocalNav();
});
});
var adminSettings = (await _siteService.GetSiteSettingsAsync()).As <AdminSettings>();
if (adminSettings.DisplayNewMenu && contentTypes.Any())
{
await builder.AddAsync(S["New"], "-1", async newMenu =>
{
newMenu.LinkToFirstChild(false).AddClass("new").Id("new");
foreach (var contentTypeDefinition in contentTypes)
{
var ci = await _contentManager.NewAsync(contentTypeDefinition.Name);
var cim = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(ci);
var createRouteValues = cim.CreateRouteValues;
createRouteValues.Add("returnUrl", _linkGenerator.GetPathByRouteValues(context, "", new
{
area = "OrchardCore.Contents",
controller = "Admin",
action = "List"
}));
if (createRouteValues.Any())
{
newMenu.Add(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName), "5", item => item
.Action(cim.CreateRouteValues["Action"] as string, cim.CreateRouteValues["Controller"] as string, cim.CreateRouteValues)
.Permission(ContentTypePermissionsHelper.CreateDynamicPermission(ContentTypePermissionsHelper.PermissionTemplates[CommonPermissions.EditOwnContent.Name], contentTypeDefinition))
);
}
}
});
}
}
public Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable <IAdminNodeNavigationBuilder> treeNodeBuilders)
{
var node = menuItem as LinkAdminNode;
if (node == null || String.IsNullOrEmpty(node.LinkText) || !node.Enabled)
{
return(Task.CompletedTask);
}
return(builder.AddAsync(new LocalizedString(node.LinkText, node.LinkText), async itemBuilder => {
// Add the actual link
itemBuilder.Url(node.LinkUrl);
itemBuilder.Priority(node.Priority);
itemBuilder.Position(node.Position);
// Add adminNode's IconClass property values to menuItem.Classes.
// Add them with a prefix so that later the shape template can extract them to use them on a <i> tag.
node.IconClass?.Split(' ').ToList().ForEach(c => itemBuilder.AddClass("icon-class-" + c));
// Let children build themselves inside this MenuItem
// todo: this logic can be shared by all TreeNodeNavigationBuilders
foreach (var childTreeNode in menuItem.Items)
{
try
{
var treeBuilder = treeNodeBuilders.Where(x => x.Name == childTreeNode.GetType().Name).FirstOrDefault();
await treeBuilder.BuildNavigationAsync(childTreeNode, itemBuilder, treeNodeBuilders);
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred while building the '{MenuItem}' child Menu Item.", childTreeNode.GetType().Name);
}
}
}));
}
public async Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable <IAdminNodeNavigationBuilder> treeNodeBuilders)
{
_node = menuItem as QueryAdminNode;
if (_node == null || !_node.Enabled || String.IsNullOrEmpty(_node.QueryId))
{
return;
}
// _contentType = _contentDefinitionManager.GetTypeDefinition(_node.ContentType);
// var taxonomyContentItem = await _contentManager.GetAsync(_node.ContentType);
//var taxonomyTree= await _taxonomyServices.BuildTaxonomyTree( _node.ContentType);
var query = await _queryManager.GetQueryAsync(_node.QueryId);
if (query == null)
{
_logger.LogError("Can't find The content type '{ContentType}' for list admin node.", _node.QueryId);
return;
}
var parameters = new Dictionary <string, object>();
var queryResult = await _queryManager.ExecuteQueryAsync(query, parameters);
if (_node.AddQueryIdAsParent)
{
// if (query == null)
// {
// _logger.LogError("Can't find The content type '{ContentType}' for list admin node.", _node.QueryId);
// }
await builder.AddAsync(new LocalizedString(query.Name, query.Name), async listTypeMenu =>
{
AddPrefixToClasses(_node.IconForParentLink).ForEach(c => listTypeMenu.AddClass(c));
//todo
// listTypeMenu.Permission(ContentTypePermissions.CreateDynamicPermission(
// ContentTypePermissions.PermissionTemplates[Contents.Permissions.EditContent.Name], taxonomyContentItem));
await AddContentItemsAsync(listTypeMenu, queryResult, _node.LinkMode);
});
}
else
{
await AddContentItemsAsync(builder, queryResult, _node.LinkMode);
}
// Add external children
foreach (var childNode in _node.Items)
{
try
{
var treeBuilder = treeNodeBuilders.Where(x => x.Name == childNode.GetType().Name).FirstOrDefault();
await treeBuilder.BuildNavigationAsync(childNode, builder, treeNodeBuilders);
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred while building the '{MenuItem}' child Menu Item.", childNode.GetType().Name);
}
}
}
public async Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable <IAdminNodeNavigationBuilder> treeNodeBuilders)
{
var node = menuItem as TaxonomyTermsAdminNode;
if ((node == null) || (!node.Enabled))
{
return;
}
var taxonomy = await _contentManager.GetAsync(node.TaxonomyContentItemId, VersionOptions.Latest);
if (taxonomy == null)
{
return;
}
//TODO this can move to a handler
var taxonomyRootRouteValues = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(taxonomy);
var taxonomyRouteValues = new RouteValueDictionary
{
{ "Area", "OrchardCore.Contents" },
{ "Controller", "Admin" },
{ "Action", "Display" },
{ "ContentItemId", taxonomy.ContentItemId }
};
var homeRoute = (await _siteService.GetSiteSettingsAsync()).HomeRoute;
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", taxonomy);
var taxonomyDisplayText = await _liquidTemplatemanager.RenderAsync(node.TaxonomyDisplayPattern, NullEncoder.Default, templateContext);
var termEntries = new List <TermMenuEntry>();
PopulateTermEntries(termEntries, taxonomy.As <TaxonomyPart>().Terms, 0);
await builder.AddAsync(new LocalizedString(taxonomyDisplayText, taxonomyDisplayText), async taxonomyRoot =>
{
//TODO this can route direct to taxonomy
//var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(homeRouteContentItem.ContentType);
taxonomyRoot.Action(taxonomyRootRouteValues.EditorRouteValues["Action"] as string, taxonomyRootRouteValues.EditorRouteValues["Controller"] as string, taxonomyRootRouteValues.EditorRouteValues);
taxonomyRoot.Resource(taxonomy);
taxonomyRoot.Priority(node.Priority);
taxonomyRoot.Position(node.Position);
taxonomyRoot.LocalNav();
AddPrefixToClasses(node.IconForTree).ToList().ForEach(c => taxonomyRoot.AddClass(c));
//taxonomyRoot.Permission(ContentTypePermissions.CreateDynamicPermission(
// ContentTypePermissions.PermissionTemplates[global::OrchardCore.Contents.Permissions.EditContent.Name], contentTypeDefinition));
await BuildMenuLevels(taxonomyRoot, termEntries, 0, taxonomyRouteValues);
});
}
public async Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable <IAdminNodeNavigationBuilder> treeNodeBuilders)
{
_node = menuItem as ListsAdminNode;
if (_node == null || !_node.Enabled || String.IsNullOrEmpty(_node.ContentType))
{
return;
}
_contentType = _contentDefinitionManager.GetTypeDefinition(_node.ContentType);
if (_node.AddContentTypeAsParent)
{
if (_contentType == null)
{
_logger.LogError("Can't find The content type '{ContentType}' for list admin node.", _node.ContentType);
}
await builder.AddAsync(new LocalizedString(_contentType.DisplayName, _contentType.DisplayName), async listTypeMenu =>
{
AddPrefixToClasses(_node.IconForParentLink).ForEach(c => listTypeMenu.AddClass(c));
listTypeMenu.Permission(ContentTypePermissions.CreateDynamicPermission(
ContentTypePermissions.PermissionTemplates[Contents.Permissions.EditContent.Name], _contentType));
await AddContentItemsAsync(listTypeMenu);
});
}
else
{
await AddContentItemsAsync(builder);
}
// Add external children
foreach (var childNode in _node.Items)
{
try
{
var treeBuilder = treeNodeBuilders.Where(x => x.Name == childNode.GetType().Name).FirstOrDefault();
await treeBuilder.BuildNavigationAsync(childNode, builder, treeNodeBuilders);
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred while building the '{MenuItem}' child Menu Item.", childNode.GetType().Name);
}
}
}
public async Task BuildNavigationAsync(string name, NavigationBuilder builder)
{
if (!String.Equals(name, "admin", StringComparison.OrdinalIgnoreCase))
{
return;
}
var contentTypeDefinitions = _contentDefinitionManager.ListTypeDefinitions().OrderBy(d => d.Name);
builder.Add(T["Content"], "1.4", content => content
.AddClass("content").Id("content")
.Add(T["Content Items"], "1", contentItems => contentItems
.Permission(Permissions.EditOwnContent)
.Action("List", "Admin", new { area = "OrchardCore.Contents" })
.LocalNav())
);
var contentTypes = contentTypeDefinitions.Where(ctd => ctd.Settings.ToObject <ContentTypeSettings>().Creatable).OrderBy(ctd => ctd.DisplayName);
if (contentTypes.Any())
{
await builder.AddAsync(T["New"], "-1", async newMenu =>
{
newMenu.LinkToFirstChild(false).AddClass("new").Id("new");
foreach (var contentTypeDefinition in contentTypes)
{
var ci = await _contentManager.NewAsync(contentTypeDefinition.Name);
var cim = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(ci);
var createRouteValues = cim.CreateRouteValues;
if (createRouteValues.Any())
{
newMenu.Add(new LocalizedString(contentTypeDefinition.DisplayName, contentTypeDefinition.DisplayName), "5", item => item
.Action(cim.CreateRouteValues["Action"] as string, cim.CreateRouteValues["Controller"] as string, cim.CreateRouteValues)
.Permission(Permissions.EditOwnContent)
// Apply "PublishOwn" permission for the content type
//.Permission(DynamicPermissions.CreateDynamicPermission(DynamicPermissions.PermissionTemplates[Permissions.PublishOwnContent.Name], contentTypeDefinition)
);
}
}
});
}
}
public async Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable <IAdminNodeNavigationBuilder> treeNodeBuilders)
{
var node = menuItem as UrlTreeAdminNode;
if ((node == null) || (!node.Enabled))
{
return;
}
//TODO cache (actually cache the levels.)
var contentItems = (await _session
.Query <ContentItem>()
.With <AutoroutePartIndex>(o => o.Published)
.ListAsync()).ToList();
var homeRoute = (await _siteService.GetSiteSettingsAsync()).HomeRoute;
// Return on no homeroute.
if (homeRoute == null)
{
return;
}
var homeRouteContentItemId = homeRoute[_options.ContentItemIdKey]?.ToString();
if (String.IsNullOrEmpty(homeRouteContentItemId))
{
return;
}
var homeRouteContentItem = await _contentManager.GetAsync(homeRouteContentItemId);
if (homeRouteContentItem == null)
{
return;
}
var homeRouteMetadata = await _contentManager.PopulateAspectAsync <ContentItemMetadata>(homeRouteContentItem);
if (!homeRouteMetadata.AdminRouteValues.Any())
{
return;
}
// In case of lists, which use display
homeRouteMetadata.AdminRouteValues["Action"] = "Edit";
var templateContext = new TemplateContext();
templateContext.SetValue("ContentItem", homeRouteContentItem);
var rootMenuDisplayText = await _liquidTemplatemanager.RenderAsync(node.TreeRootDisplayPattern, NullEncoder.Default, templateContext);
// In case of bad liquid.
if (String.IsNullOrEmpty(rootMenuDisplayText))
{
_logger.LogError("Bad liquid root menu display text");
}
var segments = new List <ContentItemSegment2>();
foreach (var ci in contentItems)
{
var part = ci.As <AutoroutePart>();
var contentItemSegment = new ContentItemSegment2
{
Segments = part.Path.Contains("/") ? part.Path.Split('/') : new string[] { part.Path },
Path = part.Path,
ContentItem = ci
};
segments.Add(contentItemSegment);
}
var levels = new List <Level>();
await BuildLevels(levels, segments, node, 0);
//TODO Dynamic string localization not supported yet.
await builder.AddAsync(new LocalizedString(rootMenuDisplayText, rootMenuDisplayText), async urlTreeRoot =>
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(homeRouteContentItem.ContentType);
urlTreeRoot.Action(homeRouteMetadata.AdminRouteValues["Action"] as string, homeRouteMetadata.AdminRouteValues["Controller"] as string, homeRouteMetadata.AdminRouteValues);
urlTreeRoot.Resource(homeRouteContentItem);
urlTreeRoot.Priority(node.Priority);
urlTreeRoot.Position(node.Position);
urlTreeRoot.LocalNav();
AddPrefixToClasses(node.IconForTree).ToList().ForEach(c => urlTreeRoot.AddClass(c));
urlTreeRoot.Permission(ContentTypePermissions.CreateDynamicPermission(
ContentTypePermissions.PermissionTemplates[global::OrchardCore.Contents.Permissions.EditContent.Name], contentTypeDefinition));
await BuildMenuLevels(urlTreeRoot, levels);
});
}
