PowerfulAdmin - Best admin panel 1.0.4

// Build a Dictionary<string, object> and call API_AddSection. It returns true on success

    private const string SectionId = "mystats";

    private void RegisterSection()
    {
        PowerfulAdmin ??= plugins.Find("PowerfulAdmin");
        if (PowerfulAdmin == null)
            return;

        var definition = new Dictionary<string, object>
        {
            ["id"]             = SectionId,                                // required, unique
            ["icon"]           = "assets/icons/star.png",                 // sidebar icon
            ["category"]       = "nav.cat.tools",                         // nav group (see below)
            ["permission"]     = "myplugin.view",                         // auto-registered by PA
            ["title"]          = (Func<BasePlayer, string>)(p => "My Stats"),
            ["open"]           = (Action<BasePlayer>)OpenSection,         // draw the page
            ["cardRows"]       = (Func<string, List<string[]>>)CardRows,  // player-card rows
            ["settings"]       = (Action<BasePlayer, CuiElementContainer, string, int>)DrawSettings,
            ["settingsHeight"] = (Func<BasePlayer, int>)(p => 180),
            ["popupActions"]   = new Dictionary<string, Action<BasePlayer, ulong, string>>
            {
                ["ban"] = OnBan
            }
        };

        PowerfulAdmin.Call("API_AddSection", definition);
    }

// Only "id" is required; every other key is optional. The cast to the exact delegate
// type matters - PowerfulAdmin reads each key with "as <Type>", so a wrong signature is
// silently ignored.

// Definition keys:

//    id              string
//                    Unique section id (used by API_OpenSection / API_RemoveSection). REQUIRED.

//    icon            string
//                    Sidebar icon sprite. Default "assets/icons/file.png".

//    category        string
//                    Nav group key. Built-in: "nav.cat.main", "nav.cat.tools", "nav.cat.manage".
//                    Any other value creates a new group (its label is the localized category key).
//                    Default "nav.cat.manage".

//    permission      string
//                    Permission required to open the section. PowerfulAdmin registers it for you
//                    if no plugin has registered it yet.

//    title           Func<BasePlayer, string>
//                    Sidebar label / page header text.

//    open            Action<BasePlayer>
//                    Called when the player opens the section - draw your page here.

//    cardRows        Func<string, List<string[]>>
//                    Extra rows for the player card; the argument is the target steamid.

//    settings        Action<BasePlayer, CuiElementContainer, string, int>
//                    Draw controls into a card on the Settings page.

//    settingsHeight  Func<BasePlayer, int>
//                    Height (px) of your settings card.

//    popupActions    Dictionary<string, Action<BasePlayer, ulong, string>>
//                    Named handlers for player-popup actions. Key = action id, value =
//                    handler(admin, targetSteamId, targetName). PowerfulAdmin enables the popup
//                    "Ban" button while any section provides an action under the key "ban", and
//                    routes that click to your handler. (The dictionary is generic - the same
//                    mechanism is used for any popup action key, not only "ban".)

// Lifecycle - register on server init and whenever PowerfulAdmin (re)loads, remove on unload:

    private void OnServerInitialized() => RegisterSection();

    private void OnPluginLoaded(Plugin plugin)
    {
        if (plugin?.Name == "PowerfulAdmin")
        {
            PowerfulAdmin = plugin;
            RegisterSection();
        }
    }

    private void OnPluginUnloaded(Plugin plugin)
    {
        if (plugin?.Name == "PowerfulAdmin")
            PowerfulAdmin = null;
    }

    private void Unload() => PowerfulAdmin?.Call("API_RemoveSection", SectionId);



// When "open" fires, ask PowerfulAdmin for the render CONTEXT with API_SectionContext.
// It returns geometry, the player's language and the current theme palette, so your UI
// matches PowerfulAdmin's look and active theme.

    private void OpenSection(BasePlayer player)
    {
        var ctx = PowerfulAdmin.Call("API_SectionContext", player) as Dictionary<string, object>;
        if (ctx == null)
            return;

        var parent  = (string)ctx["parent"];                  // parent layer for your UI
        var bodyW   = Convert.ToInt32(ctx["bodyW"]);
        var pad     = Convert.ToInt32(ctx["pad"]);
        var palette = (Dictionary<string, string>)ctx["palette"];

        var surface = palette["surface"];
        var accent  = palette["accent"];
        var text    = palette["text"];
        var font    = palette["fontBold"];

        var container = new CuiElementContainer();
        const string root = "myplugin.page";
        container.Add(new CuiPanel
        {
            Image = { Color = surface },
            RectTransform = { AnchorMin = "0 0", AnchorMax = "1 1" }
        }, parent, root);
        container.Add(new CuiLabel
        {
            Text = { Text = "Hello from My Stats", FontSize = 16, Font = font, Color = accent },
            RectTransform = { AnchorMin = "0 1", AnchorMax = "1 1", OffsetMin = $"{pad} -48", OffsetMax = $"{-pad} -16" }
        }, root);
        CuiHelper.AddUi(player, container);
    }

//Context keys:

//    parent        string                  Layer name to parent your UI to (the panel body).
//    root          string                  The panel root layer.
//    bodyW, bodyH  int                     Body width / height in pixels.
//    pad           int                     Standard content padding.
//    lang          string                  The player's active language code (e.g. "en").
//    palette       Dictionary<string,string>  Theme colors + fonts (below). Read it every render -
//                                          the user can switch themes.

// Palette keys (each value is a CUI color string "R G B A", fonts are font names):

//     page, bg, surface, elev, elev2, border, borderSoft,
//    text, text2, text3,
//    accent, accentH, accentSoft, accentText,
//    danger, dangerSoft, success, warn, warnSoft, info, clear,
//    fontBold, fontRegular, fontMono

// Build a CuiElementContainer parented to "parent", give your elements stable names, and
// prefer repainting a single named element over a full redraw to avoid a jumpy panel.



// Return extra [label, value] rows shown on the player card. The argument is the target
// steamid as a string.

    private List<string[]> CardRows(string steamId)
    {
        if (!ulong.TryParse(steamId, out var id))
            return null;
        return new List<string[]>
        {
            new[] { "Score", GetScore(id).ToString() },
            new[] { "Rank",  GetRank(id) }
        };
    }

Call API_RefreshPlayerCard(steamId) after your data changes to repaint the card.



// "settings" draws controls into a collapsible card on the Settings page; "settingsHeight"
// tells PowerfulAdmin how tall it is (used to size the scroll area). Use the same palette
// via API_SectionContext. After saving a value, call API_RefreshSettings(player) to repaint.

    private void DrawSettings(BasePlayer player, CuiElementContainer c, string card, int panelWidth)
    {
        var ctx = PowerfulAdmin.Call("API_SectionContext", player) as Dictionary<string, object>;
        var palette = ctx?["palette"] as Dictionary<string, string>;
        var text = palette?["text"] ?? "1 1 1 1";

        c.Add(new CuiLabel
        {
            Text = { Text = "My option", FontSize = 12, Color = text },
            RectTransform = { AnchorMin = "0 1", AnchorMax = "1 1", OffsetMin = "16 -40", OffsetMax = "-16 -16" }
        }, card);
        // add buttons / input fields here, wire them to your own console commands
    }

// settingsHeight must return a STABLE height for the current state. PowerfulAdmin sizes the
// Settings scroll once; if your card can grow, return the maximum height (or trigger a full
// refresh) so the bottom is never clipped.



// "popupActions" is a dictionary of named handlers. Each handler is called with the admin,
// the target steamid and the target name. PowerfulAdmin enables the popup "Ban" button while
// some section registers an action under the key "ban", and routes the click to your handler.
// A typical handler arms your own dialog and navigates to your section:

    private void OnBan(BasePlayer admin, ulong steamId, string name)
    {
        // prepare your dialog state for (steamId, name) ...
        PowerfulAdmin.Call("API_OpenSection", admin, SectionId);
    }

    // in the section definition:
    ["popupActions"] = new Dictionary<string, Action<BasePlayer, ulong, string>>
    {
        ["ban"] = OnBan
    }


    API_AddSection(Dictionary<string,object> def)  // -> bool
//        Register/replace a section.

    API_RemoveSection(string id)                    // -> bool
//        Remove a section (call in Unload).

    API_OpenSection(BasePlayer player, string id)   // -> bool
//        Navigate the player to a section.

    API_SectionContext(BasePlayer player)           // -> Dictionary<string,object>
//        Geometry + lang + palette for rendering.

    API_RefreshSettings(BasePlayer player)          // -> null
//        Repaint the Settings page (after a settings change).

    API_RefreshPlayerCard(string steamId)           // -> null
//        Repaint a player card.

    API_ReopenPanel(BasePlayer player)              // -> null
//        Re-open the whole panel for the player.

    API_Log(string message, string category = null)  // -> bool
//        Write a line into PowerfulAdmin's Logs. Category e.g. "Cmd", "Info".

    API_RustHours(string steamId)                   // -> string
//        Player's Rust hours ("N h", "..." while loading, "n/a", or "NO STEAM-API KEY").
//        Needs a Steam API key configured in PowerfulAdmin.

    API_KnownPlayers()                              // -> List<string[]>
//        Every known player as [steamid, name, online] (online = "1" / "0"), online first.

    API_GetInput(string key)                        // -> string
//        Read a stored input value (e.g. a shared setting).

    API_GetToggle(string key, bool def)            // -> bool
//        Read a stored toggle.

    API_GetSelect(string key, string def)           // -> string
//        Read a stored select value.                         

// Example - reading hours and logging:

    var hours = PowerfulAdmin.Call("API_RustHours", steamId.ToString()) as string ?? "n/a";
    PowerfulAdmin.Call("API_Log", $"checked {steamId}: {hours}", "Info");

    if (PowerfulAdmin.Call("API_KnownPlayers") is List<string[]> players)
        foreach (var p in players)
        {
            // p[0] = steamid, p[1] = name, p[2] = "1" (online) / "0" (offline)
        }