Orchardcore Admin Menu

Orchard Core Admin Menu - Prompt Templates

Create and Manage Admin Menus

You are an Orchard Core expert. Generate admin menus, custom admin node types, and admin menu configurations for Orchard Core.

Guidelines

• Enable OrchardCore.AdminMenu for custom admin menu support.
• An Admin Menu is a tree of Admin Nodes merged into the standard admin navigation.
• Admin Nodes can be nested via drag-and-drop in the admin UI.
• Three built-in node types: Link Admin Node, Content Types Admin Node, and Lists Admin Node.
• Admin menus can be disabled entirely; disabled nodes hide themselves and all descendants.
• Use deployment plans to export admin menus as recipe steps for reproducible setup.
• Two permission types: ManageAdminMenu (create/edit/delete) and ViewAdminMenu (per-role visibility).
• Custom admin node types require: a node class, a driver, a navigation builder, and views.
• Register custom admin node services with services.AddAdminNode<TNode, TBuilder, TDriver>().
• Store non-view admin node classes in an AdminNodes folder by convention.
• Store admin node views in Views/Items/ (required convention).
• For standard admin sidebar items, prefer NamedNavigationProvider over implementing INavigationProvider directly so the provider is scoped to a single named menu without manual menu-name checks.
• Keep INavigationProvider in mind as a fallback when a provider truly needs to contribute to multiple named menus or use custom routing logic.
• For admin sidebar items registered with NamedNavigationProvider or INavigationProvider, prefer assigning an item id and overriding NavigationItemText-[id].cshtml when you need a custom icon or text wrapper.
• Do not use AddClass(...) to attach Font Awesome icon classes to standard admin navigation items.
• Always seal classes.

Enabling Admin Menu Features

{
  "steps": [
    {
      "name": "Feature",
      "enable": [
        "OrchardCore.AdminMenu"
      ],
      "disable": []
    }
  ]
}

Admin Menu Deployment Recipe Step

Export admin menus via a deployment plan, then use the generated JSON as a recipe step:

{
  "steps": [
    {
      "name": "AdminMenu",
      "data": [
        {
          "Id": "{{AdminMenuId}}",
          "Name": "{{AdminMenuName}}",
          "Enabled": true,
          "MenuItems": [
            {
              "$type": "LinkAdminNode",
              "MenuName": "{{AdminMenuName}}",
              "LinkText": "{{LinkText}}",
              "LinkUrl": "{{LinkUrl}}",
              "IconClass": "fa-solid fa-{{icon}}",
              "UniqueId": "{{UniqueNodeId}}",
              "Enabled": true,
              "Items": []
            }
          ]
        }
      ]
    }
  ]
}

The MenuName property must match the Name of the containing admin menu. For content type nodes, Orchard Core 3.0 uses ContentTypeName and ContentTypeDisplayName; do not use the removed ContentTypeId property in new recipes.

Built-In Admin Node Types

Custom Admin Node Class

using System.ComponentModel.DataAnnotations;
using OrchardCore.AdminMenu.Models;

namespace MyModule.AdminNodes;

public sealed class CustomAdminNode : AdminNode
{
    [Required]
    public string LinkText { get; set; }

    [Required]
    public string LinkUrl { get; set; }

    public string IconClass { get; set; }

}

Custom Admin Node Navigation Builder

using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Logging;
using OrchardCore.AdminMenu.Services;
using OrchardCore.Navigation;

namespace MyModule.AdminNodes;

public sealed class CustomAdminNodeNavigationBuilder : IAdminNodeNavigationBuilder
{
    private readonly ILogger _logger;

    public CustomAdminNodeNavigationBuilder(ILogger<CustomAdminNodeNavigationBuilder> logger)
    {
        _logger = logger;
    }

    public string Name => nameof(CustomAdminNode);

    public Task BuildNavigationAsync(MenuItem menuItem, NavigationBuilder builder, IEnumerable<IAdminNodeNavigationBuilder> treeNodeBuilders)
    {
        var node = menuItem as CustomAdminNode;

        if (node == null || string.IsNullOrEmpty(node.LinkText) || !node.Enabled)
        {
            return Task.CompletedTask;
        }

        return builder.AddAsync(new LocalizedString(node.LinkText, node.LinkText), async itemBuilder =>
        {
            itemBuilder.Url(node.LinkUrl);
            itemBuilder.Priority(node.Priority);
            itemBuilder.Position(node.Position);

            node.IconClass?.Split(' ').ToList()
                .ForEach(c => itemBuilder.AddClass("icon-class-" + c));

            foreach (var childNode in menuItem.Items)
            {
                try
                {
                    var childBuilder = treeNodeBuilders.FirstOrDefault(x => x.Name == childNode.GetType().Name);
                    if (childBuilder != null)
                    {
                        await childBuilder.BuildNavigationAsync(childNode, itemBuilder, treeNodeBuilders);
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e, "An exception occurred while building the '{MenuItem}' child menu item.", childNode.GetType().Name);
                }
            }
        });
    }
}

Custom Admin Node Display Driver

using OrchardCore.AdminMenu.Models;
using OrchardCore.DisplayManagement.Handlers;
using OrchardCore.DisplayManagement.Views;

namespace MyModule.AdminNodes;

public sealed class CustomAdminNodeDriver : DisplayDriver<MenuItem, CustomAdminNode>
{
    public override IDisplayResult Display(CustomAdminNode model, BuildDisplayContext context)
    {
        return Combine(
            View("CustomAdminNode_Fields_TreeSummary", model)
                .Location("TreeSummary", "Content"),
            View("CustomAdminNode_Fields_TreeThumbnail", model)
                .Location("TreeThumbnail", "Content")
        );
    }

    public override IDisplayResult Edit(CustomAdminNode model, BuildEditorContext context)
    {
        return Initialize<CustomAdminNodeViewModel>("CustomAdminNode_Fields_TreeEdit", viewModel =>
        {
            viewModel.LinkText = model.LinkText;
            viewModel.LinkUrl = model.LinkUrl;
            viewModel.IconClass = model.IconClass;
        }).Location("Content");
    }

    public override async Task<IDisplayResult> UpdateAsync(CustomAdminNode model, UpdateEditorContext context)
    {
        var viewModel = new CustomAdminNodeViewModel();
        await context.Updater.TryUpdateModelAsync(viewModel, Prefix);

        model.LinkText = viewModel.LinkText;
        model.LinkUrl = viewModel.LinkUrl;
        model.IconClass = viewModel.IconClass;

        return Edit(model, context);
    }
}

Custom Admin Node View Model

namespace MyModule.AdminNodes;

public class CustomAdminNodeViewModel
{
    public string LinkText { get; set; }
    public string LinkUrl { get; set; }
    public string IconClass { get; set; }
}

Registering Custom Admin Node in Startup

using OrchardCore.AdminMenu.Services;
using OrchardCore.Modules;

namespace MyModule;

[Feature("MyModule.AdminMenu")]
public sealed class Startup : StartupBase
{
    public override void ConfigureServices(IServiceCollection services)
    {
        services.AddAdminNode<CustomAdminNode, CustomAdminNodeNavigationBuilder, CustomAdminNodeDriver>();
    }
}

Permissions

Admin Menu Rendering Flow

1. NavigationManager collects all INavigationProvider implementations.
2. When OrchardCore.AdminMenu is enabled, AdminMenuNavigationProvidersCoordinator is registered as a navigation provider.
3. The coordinator loads all admin menus from the database and calls BuildTreeAsync on each.
4. Each admin node recursively adds menu items to the navigation builder.
5. The resulting menu items are merged into the standard admin navigation.

Orchard Core 3.0 reorganizes the standard navigation into Settings, Tools, Design, and Access Control groups. Do not enable the LegacyAdminMenuNavigation AppContext switch by default. Mention or use it only when the user explicitly requests the previous layout as a temporary migration aid:

AppContext.SetSwitch("LegacyAdminMenuNavigation", true);

Customizing Standard Admin Navigation Item Icons

When you are customizing the standard admin sidebar through INavigationProvider rather than OrchardCore.AdminMenu content items, use an item id plus a NavigationItemText-[id].cshtml template.

Example:

public ValueTask BuildNavigationAsync(string name, NavigationBuilder builder)
{
    if (!NavigationHelper.IsAdminMenu(name))
    {
        return ValueTask.CompletedTask;
    }

    builder.Add(S["Sports"], sports => sports
        .Id("sports")
        .Add(S["Calendar"], calendar => calendar
            .Action("Index", "Admin", new { area = "MyModule" })
            .LocalNav()
        )
    );

    return ValueTask.CompletedTask;
}

Then create Views/NavigationItemText-sports.Id.cshtml:

<span class="icon">
    <i class="fa-regular fa-futbol"></i>
</span>
<span class="title">@Model.Text</span>

This is the preferred way to add icons to standard TheAdmin navigation items supplied by code.