commands/settings/HelpCommand.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import {
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    Collection,
    EmbedBuilder,
    PermissionResolvable,
    SlashCommandBuilder,
    escapeCodeBlock,
    escapeInlineCode
} from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { GatewayEventListener } from "../../decorators/GatewayEventListener";
import Pagination from "../../utils/Pagination";
import { DOCS_URL, GITHUB_URL, WEBSITE_URL } from "../../utils/links";
import { log } from "../../utils/logger";
import { forceGetPermissionNames, getComponentEmojiResolvable } from "../../utils/utils";

export interface CommandInfo {
    name: string;
    aliases: string[];
    group: string;
    description?: string;
    detailedDscription?: string;
    systemAdminOnly: boolean;
    beta: boolean;
    argumentSyntaxes?: string[];
    botRequiredPermissions?: PermissionResolvable[];
    availableOptions?: Record<string, string>;
    since: string;
    supportsInteractions: boolean;
    supportsLegacy: boolean;
}

export default class HelpCommand extends Command {
    public readonly name = "help";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.String],
            name: "command",
            optional: true
        },
        {
            types: [ArgumentType.String],
            name: "subcommand",
            optional: true
        }
    ];
    public readonly permissions = [];

    public readonly description = "Shows this help information.";
    public readonly detailedDescription =
        "Shows documentation about the bot's commands. You can even get information about individual commands by running `help <command>` where `<command>` is the command name.";

    public readonly argumentSyntaxes = ["[command]"];

    public readonly commandInformation = new Collection<string, string[]>();
    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addStringOption(option => option.setName("command").setDescription("Shows help for this command"))
        .addStringOption(option => option.setName("subcommand").setDescription("Shows help for this subcommand"));

    @GatewayEventListener("ready")
    async onReady() {
        log("Attempting to read and extract meta info from all the loaded commands...");

        for await (const command of this.client.commands.values()) {
            if (command.name.includes("__")) continue;
            const commands = this.commandInformation.get(command.group) ?? [];

            if (commands.includes(command.name)) {
                continue;
            }

            commands.push(command.name);
            this.commandInformation.set(command.group, commands);
        }

        for (const group of this.commandInformation.keys()) {
            this.commandInformation.get(group)?.sort((a, b) => a.localeCompare(b, ["en-US"]));
        }

        log("Successfully read metadata of " + this.commandInformation.size + " commands");
    }

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message);
        const commandName = context.isLegacy ? context.parsedNamedArgs.command : context.options.getString("command");
        const subcommand = context.isLegacy ? context.parsedNamedArgs.subcommand : context.options.getString("subcommand");

        const config = this.client.configManager.config[message.guildId!];

        if (!config) {
            await this.error(
                message,
                "This server isn't configured. Please ask a system administrator to configure this server."
            );
            return;
        }

        if (!commandName) {
            const pagination = new Pagination([...this.commandInformation.entries()], {
                channelId: message.channelId!,
                client: this.client,
                guildId: message.guildId!,
                limit: 1,
                timeout: 200_000,
                userId: message.member!.user.id,
                embedBuilder: ({ currentPage, maxPages, data: [[group, commandNames]] }) => {
                    let description: string = `Run \`${config.prefix}help <commandName>\` to get help about a specific command.\n\`<...>\` means required argument, \`[...]\` means optional argument.\n\n`;
                    description += `**${group}**\n\`${commandNames.join("`, `")}\`\n\n`;

                    return new EmbedBuilder({
                        author: {
                            name: "Help",
                            iconURL: this.client.user?.displayAvatarURL() ?? undefined
                        },
                        color: 0x007bff,
                        description,
                        footer: {
                            text: `Page ${currentPage} of ${maxPages}`
                        }
                    }).setTimestamp();
                },
                messageOptions: {
                    components: [
                        new ActionRowBuilder<ButtonBuilder>().addComponents(
                            new ButtonBuilder()
                                .setStyle(ButtonStyle.Link)
                                .setEmoji("📘")
                                .setURL(DOCS_URL)
                                .setLabel("Documentation"),
                            new ButtonBuilder()
                                .setStyle(ButtonStyle.Link)
                                .setEmoji(getComponentEmojiResolvable(this.client, "github") ?? "☄️")
                                .setURL(GITHUB_URL)
                                .setLabel("GitHub"),
                            new ButtonBuilder().setStyle(ButtonStyle.Link).setEmoji("🌍").setURL(WEBSITE_URL).setLabel("Website")
                        )
                    ]
                }
            });

            const reply = await this.deferredReply(message, await pagination.getMessageOptions(1));
            await pagination.start(reply);
        } else {
            const name = subcommand ? `${commandName} ${subcommand}` : commandName;
            const command = this.client.commands.get(subcommand ? `${commandName}__${subcommand}` : commandName);

            if (!command) {
                await this.error(
                    message,
                    subcommand
                        ? `No command \`${commandName}\` or no subcommand \`${subcommand}\` exists.`
                        : `No command named \`${escapeInlineCode(escapeCodeBlock(commandName))}\` exists!`
                );
                return;
            }

            const options = command.availableOptions ? Object.entries(command.availableOptions) : [];

            await this.deferredReply(message, {
                embeds: [
                    new EmbedBuilder({
                        title: `${config.prefix}${name}${command.beta ? ` [BETA]` : ""}`,
                        color: 0x007bff,
                        fields: [
                            {
                                name: "Name",
                                value: `\`${subcommand ? name : command.name}\``,
                                inline: true
                            },
                            {
                                name: "Group",
                                value: `\`${command.group}\``,
                                inline: true
                            },
                            ...(command.aliases.length > 0
                                ? [
                                      {
                                          name: "Aliases",
                                          value: command.aliases.map(c => `\`${c}\``).join("\n")
                                      }
                                  ]
                                : []),
                            {
                                name: "Description",
                                value: command.detailedDescription ?? command.description ?? "*No description available*"
                            },
                            {
                                name: "Syntax",
                                value: `\`\`\`\n${
                                    command.argumentSyntaxes
                                        ? command.argumentSyntaxes.map(s => `${config.prefix}${name} ${s}`).join("\n")
                                        : `${config.prefix}${name}`
                                }\n\`\`\``
                            },
                            ...(command.subcommands.length > 0
                                ? [
                                      {
                                          name: "Subcommands",
                                          value: `Run \`${config.prefix}help ${
                                              command.name
                                          } <subcommand>\` to see information about specific subcommands.\n\n* ${command.subcommands
                                              .map(s => `\`${s}\``)
                                              .join("\n* ")}`
                                      }
                                  ]
                                : []),
                            ...(command.botRequiredPermissions.length > 0
                                ? [
                                      {
                                          name: "Required Bot Permissions",
                                          value: "`" + forceGetPermissionNames(command.botRequiredPermissions).join("`\n`") + "`",
                                          inline: true
                                      }
                                  ]
                                : []),
                            ...(command.permissions.length > 0
                                ? [
                                      {
                                          name: "Required User Permissions",
                                          value:
                                              "`" +
                                              forceGetPermissionNames(command.permissions).join(
                                                  `\`\n${command.permissionMode === "or" ? "or, " : ""}\``
                                              ) +
                                              "`",
                                          inline: true
                                      }
                                  ]
                                : []),
                            ...(options.length > 0
                                ? [
                                      {
                                          name: "Options",
                                          value: options.map(([name, description]) => `* \`${name}\` - ${description}`).join("\n")
                                      }
                                  ]
                                : []),
                            {
                                name: "Mode",
                                value: `${this.emoji(command.supportsLegacy ? "check" : "error")} Legacy\n${this.emoji(
                                    command.supportsInteractions ? "check" : "error"
                                )} Interaction-based`
                            },
                            {
                                name: "Other Information",
                                value: `Available since \`${command.since}\`.\n${
                                    command.beta ? "This command is under beta testing.\n" : ""
                                }${
                                    command.systemAdminOnly
                                        ? "This command can only be used by the System Administrators of the bot.\n"
                                        : ""
                                }`,
                                inline: true
                            }
                        ]
                    }).setTimestamp()
                ]
            });
        }
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import {
21			ActionRowBuilder,
22			ButtonBuilder,
23			ButtonStyle,
24			Collection,
25			EmbedBuilder,
26			PermissionResolvable,
27			SlashCommandBuilder,
28			escapeCodeBlock,
29			escapeInlineCode
30			} from "discord.js";
31			import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
32			import { GatewayEventListener } from "../../decorators/GatewayEventListener";
33			import Pagination from "../../utils/Pagination";
34			import { DOCS_URL, GITHUB_URL, WEBSITE_URL } from "../../utils/links";
35			import { log } from "../../utils/logger";
36			import { forceGetPermissionNames, getComponentEmojiResolvable } from "../../utils/utils";
37
38			export interface CommandInfo {
39			name: string;
40			aliases: string[];
41			group: string;
42			description?: string;
43			detailedDscription?: string;
44			systemAdminOnly: boolean;
45			beta: boolean;
46			argumentSyntaxes?: string[];
47			botRequiredPermissions?: PermissionResolvable[];
48			availableOptions?: Record<string, string>;
49			since: string;
50			supportsInteractions: boolean;
51			supportsLegacy: boolean;
52			}
53
54			export default class HelpCommand extends Command {
55			public readonly name = "help";
56			public readonly validationRules: ValidationRule[] = [
57			{
58			types: [ArgumentType.String],
59			name: "command",
60			optional: true
61			},
62			{
63			types: [ArgumentType.String],
64			name: "subcommand",
65			optional: true
66			}
67			];
68			public readonly permissions = [];
69
70			public readonly description = "Shows this help information.";
71			public readonly detailedDescription =
72			"Shows documentation about the bot's commands. You can even get information about individual commands by running `help <command>` where `<command>` is the command name.";
73
74			public readonly argumentSyntaxes = ["[command]"];
75
76			public readonly commandInformation = new Collection<string, string[]>();
77			public readonly slashCommandBuilder = new SlashCommandBuilder()
78			.addStringOption(option => option.setName("command").setDescription("Shows help for this command"))
79			.addStringOption(option => option.setName("subcommand").setDescription("Shows help for this subcommand"));
80
81			@GatewayEventListener("ready")
82			async onReady() {
83			log("Attempting to read and extract meta info from all the loaded commands...");
84
85			for await (const command of this.client.commands.values()) {
86			if (command.name.includes("__")) continue;
87			const commands = this.commandInformation.get(command.group) ?? [];
88
89			if (commands.includes(command.name)) {
90			continue;
91			}
92
93			commands.push(command.name);
94			this.commandInformation.set(command.group, commands);
95			}
96
97			for (const group of this.commandInformation.keys()) {
98			this.commandInformation.get(group)?.sort((a, b) => a.localeCompare(b, ["en-US"]));
99			}
100
101			log("Successfully read metadata of " + this.commandInformation.size + " commands");
102			}
103
104			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
105			await this.deferIfInteraction(message);
106			const commandName = context.isLegacy ? context.parsedNamedArgs.command : context.options.getString("command");
107			const subcommand = context.isLegacy ? context.parsedNamedArgs.subcommand : context.options.getString("subcommand");
108
109			const config = this.client.configManager.config[message.guildId!];
110
111			if (!config) {
112			await this.error(
113			message,
114			"This server isn't configured. Please ask a system administrator to configure this server."
115			);
116			return;
117			}
118
119			if (!commandName) {
120			const pagination = new Pagination([...this.commandInformation.entries()], {
121			channelId: message.channelId!,
122			client: this.client,
123			guildId: message.guildId!,
124			limit: 1,
125			timeout: 200_000,
126			userId: message.member!.user.id,
127			embedBuilder: ({ currentPage, maxPages, data: [[group, commandNames]] }) => {
128			let description: string = `Run \`${config.prefix}help <commandName>\` to get help about a specific command.\n\`<...>\` means required argument, \`[...]\` means optional argument.\n\n`;
129			description += `${group}\n\`${commandNames.join("`, `")}\`\n\n`;
130
131			return new EmbedBuilder({
132			author: {
133			name: "Help",
134			iconURL: this.client.user?.displayAvatarURL() ?? undefined
135			},
136			color: 0x007bff,
137			description,
138			footer: {
139			text: `Page ${currentPage} of ${maxPages}`
140			}
141			}).setTimestamp();
142			},
143			messageOptions: {
144			components: [
145			new ActionRowBuilder<ButtonBuilder>().addComponents(
146			new ButtonBuilder()
147			.setStyle(ButtonStyle.Link)
148			.setEmoji("📘")
149			.setURL(DOCS_URL)
150			.setLabel("Documentation"),
151			new ButtonBuilder()
152			.setStyle(ButtonStyle.Link)
153			.setEmoji(getComponentEmojiResolvable(this.client, "github") ?? "☄️")
154			.setURL(GITHUB_URL)
155			.setLabel("GitHub"),
156			new ButtonBuilder().setStyle(ButtonStyle.Link).setEmoji("🌍").setURL(WEBSITE_URL).setLabel("Website")
157			)
158			]
159			}
160			});
161
162			const reply = await this.deferredReply(message, await pagination.getMessageOptions(1));
163			await pagination.start(reply);
164			} else {
165			const name = subcommand ? `${commandName} ${subcommand}` : commandName;
166			const command = this.client.commands.get(subcommand ? `${commandName}__${subcommand}` : commandName);
167
168			if (!command) {
169			await this.error(
170			message,
171			subcommand
172			? `No command \`${commandName}\` or no subcommand \`${subcommand}\` exists.`
173			: `No command named \`${escapeInlineCode(escapeCodeBlock(commandName))}\` exists!`
174			);
175			return;
176			}
177
178			const options = command.availableOptions ? Object.entries(command.availableOptions) : [];
179
180			await this.deferredReply(message, {
181			embeds: [
182			new EmbedBuilder({
183			title: `${config.prefix}${name}${command.beta ? ` [BETA]` : ""}`,
184			color: 0x007bff,
185			fields: [
186			{
187			name: "Name",
188			value: `\`${subcommand ? name : command.name}\``,
189			inline: true
190			},
191			{
192			name: "Group",
193			value: `\`${command.group}\``,
194			inline: true
195			},
196			...(command.aliases.length > 0
197			? [
198			{
199			name: "Aliases",
200			value: command.aliases.map(c => `\`${c}\``).join("\n")
201			}
202			]
203			: []),
204			{
205			name: "Description",
206			value: command.detailedDescription ?? command.description ?? "No description available"
207			},
208			{
209			name: "Syntax",
210			value: `\`\`\`\n${
211			command.argumentSyntaxes
212			? command.argumentSyntaxes.map(s => `${config.prefix}${name} ${s}`).join("\n")
213			: `${config.prefix}${name}`
214			}\n\`\`\``
215			},
216			...(command.subcommands.length > 0
217			? [
218			{
219			name: "Subcommands",
220			value: `Run \`${config.prefix}help ${
221			command.name
222			} <subcommand>\` to see information about specific subcommands.\n\n* ${command.subcommands
223			.map(s => `\`${s}\``)
224			.join("\n* ")}`
225			}
226			]
227			: []),
228			...(command.botRequiredPermissions.length > 0
229			? [
230			{
231			name: "Required Bot Permissions",
232			value: "`" + forceGetPermissionNames(command.botRequiredPermissions).join("`\n`") + "`",
233			inline: true
234			}
235			]
236			: []),
237			...(command.permissions.length > 0
238			? [
239			{
240			name: "Required User Permissions",
241			value:
242			"`" +
243			forceGetPermissionNames(command.permissions).join(
244			`\`\n${command.permissionMode === "or" ? "or, " : ""}\``
245			) +
246			"`",
247			inline: true
248			}
249			]
250			: []),
251			...(options.length > 0
252			? [
253			{
254			name: "Options",
255			value: options.map(([name, description]) => `* \`${name}\` - ${description}`).join("\n")
256			}
257			]
258			: []),
259			{
260			name: "Mode",
261			value: `${this.emoji(command.supportsLegacy ? "check" : "error")} Legacy\n${this.emoji(
262			command.supportsInteractions ? "check" : "error"
263			)} Interaction-based`
264			},
265			{
266			name: "Other Information",
267			value: `Available since \`${command.since}\`.\n${
268			command.beta ? "This command is under beta testing.\n" : ""
269			}${
270			command.systemAdminOnly
271			? "This command can only be used by the System Administrators of the bot.\n"
272			: ""
273			}`,
274			inline: true
275			}
276			]
277			}).setTimestamp()
278			]
279			});
280			}
281			}
282			}