Added legacy execution support to help command

Author: SimonB50

src/Commands/General/help.js

@@ -45,7 +45,257 @@ export default new Command({
     requiredPermissions: { user: [], bot: [] },
   },
   LegacyRun: async (manager, message, args, prefixUsed, commandData) => {
-    const lang = manager.configs.lang;
+    const subCommand = args[0];
+    const lang = manager.configs.lang,
+      commandsConfig = manager.configs.commands;
+    const slashCommands = manager.slashCommands,
+      legacyCommands = manager.commands;
+
+    switch (subCommand) {
+      case "category": {
+        const type = args[1] || "general";
+        const slashCommandsList = [
+            ...(await manager.application.commands.fetch()).toJSON(),
+            ...(await message.guild.commands.fetch()).toJSON(),
+          ],
+          sortedCommands = legacyCommands
+            .filter(
+              (cmd) => cmd.commandData.Type?.toLowerCase() == type.toLowerCase()
+            )
+            ?.toJSON();
+
+        const format = Object.entries(
+          lang.General.Help.AutoCompleteCategory
+        ).find(([key]) => key.toLowerCase() == type.toLowerCase());
+        const valueToUse = format && format[0] ? format[1] : type;
+
+        if (!sortedCommands.length)
+          return message.reply(
+            Utils.setupMessage({
+              configPath: lang.General.Help.NoCommandsInCategory,
+              variables: [
+                ...Utils.userVariables(message.member, "user"),
+                { searchFor: /{type}/g, replaceWith: type },
+              ],
+            })
+          );
+
+        const messages = [],
+          maxPages = Math.ceil(sortedCommands.length / 10),
+          pageIndex = 0;
+        if (maxPages == 1) {
+          message.reply(
+            Utils.setupMessage({
+              configPath: lang.General.Help.CommandList,
+              variables: [
+                ...Utils.userVariables(message.member, "user"),
+                { searchFor: /{max-page}/g, replaceWith: maxPages },
+                { searchFor: /{current-page}/g, replaceWith: 1 },
+                { searchFor: /{category}/g, replaceWith: valueToUse },
+                {
+                  searchFor: /{data}/g,
+                  replaceWith: sortedCommands
+                    .map((cmd, i) => {
+                      const slashCmd = slashCommandsList.find(
+                        (x) => x.name == cmd.commandData.Name
+                      );
+                      return [
+                        `\`${i + 1}]\` **${Utils.capitalizeFirstLetter(
+                          cmd.commandData.Name
+                        )}** - ${cmd.commandData.Description}`,
+                        getOptions(slashCmd),
+                      ]
+                        .filter((x) => x)
+                        .join("\n");
+                    })
+                    .join("\n\n"),
+                },
+              ],
+            })
+          );
+        } else {
+          for (let i = 0; i < maxPages; i++) {
+            const cmds = Utils.paginateArray(sortedCommands, 10, i + 1);
+            messages.push(
+              Utils.setupMessage({
+                configPath: lang.General.Help.CommandList,
+                variables: [
+                  ...Utils.userVariables(message.member, "user"),
+                  { searchFor: /{max-page}/g, replaceWith: maxPages },
+                  { searchFor: /{current-page}/g, replaceWith: i + 1 },
+                  { searchFor: /{category}/g, replaceWith: valueToUse },
+                  {
+                    searchFor: /{data}/g,
+                    replaceWith: cmds
+                      .map((cmd, i) => {
+                        const slashCmd = slashCommandsList.find(
+                          (x) => x.name == cmd.commandData.Name
+                        );
+                        return [
+                          `\`${i + 1}]\` **${Utils.capitalizeFirstLetter(
+                            cmd.commandData.Name
+                          )}** - ${cmd.commandData.Description}`,
+                          getOptions(slashCmd),
+                        ]
+                          .filter((x) => x)
+                          .join("\n");
+                      })
+                      .join("\n\n"),
+                  },
+                ],
+              })
+            );
+          }
+
+          const getRow = (disabled) =>
+            new Discord.ActionRowBuilder().addComponents([
+              new Discord.ButtonBuilder({
+                customId: "bryanbot_help_next",
+                style: 1,
+                emoji: "⏮",
+              }).setDisabled(disabled ? disabled : pageIndex == 0),
+              new Discord.ButtonBuilder({
+                customId: "bryanbot_help_last",
+                style: 1,
+                emoji: "⏭",
+              }).setDisabled(
+                disabled ? disabled : pageIndex == messages.length - 1
+              ),
+            ]);
+          let queueMSG = { ...messages[pageIndex], components: [getRow()] };
+
+          message.reply(queueMSG).then(async (msg) => {
+            const collector = await msg.createMessageComponentCollector({
+              filter: (i) => i.user.id == message.author.id,
+              time: 2 * 60 * 1000,
+              componentType: "BUTTON",
+            });
+            collector.on("collect", async (interaction) => {
+              if (
+                !["bryanbot_help_next", "bryanbot_help_last"].includes(
+                  interaction.customId
+                )
+              )
+                return;
+
+              if (
+                interaction.customId == "bryanbot_help_last" &&
+                pageIndex > 0
+              ) {
+                --pageIndex;
+              } else if (
+                interaction.customId == "bryanbot_help_next" &&
+                pageIndex < maxPages - 1
+              ) {
+                ++pageIndex;
+              }
+
+              interaction.update({
+                ...messages[pageIndex],
+                components: [getRow()],
+              });
+            });
+
+            collector.on("end", async () =>
+              msg.edit({ ...messages[pageIndex], components: [getRow(true)] })
+            );
+          });
+        }
+
+        break;
+      }
+      case "command": {
+        const command = args[1] || "help";
+
+        const legacyCommand = legacyCommands.get(command),
+          slashCommandsList = [
+            ...(await manager.application.commands.fetch()).toJSON(),
+            ...(await message.guild.commands.fetch()).toJSON(),
+          ];
+
+        const slashCommandApplication = slashCommandsList.find(
+          (cmd) => cmd.name === command
+        );
+
+        if (!legacyCommand)
+          return message.reply(
+            Utils.setupMessage({
+              configPath: lang.General.Help.CommandNotFound,
+              variables: Utils.userVariables(message.member, "user"),
+            })
+          );
+
+        const commandData = legacyCommand.commandData;
+        if (!Array.isArray(commandData.Permission))
+          commandData.Permission = [commandData.Permission];
+        const commandVariables = [
+          { searchFor: /{prefixUsed}/g, replaceWith: "/" },
+          { searchFor: /{cmd-name}/g, replaceWith: commandData.Name },
+          { searchFor: /{cmd-type}/g, replaceWith: commandData.Type },
+          { searchFor: /{cmd-usage}/g, replaceWith: commandData.Usage },
+          {
+            searchFor: /{cmd-cooldown}/g,
+            replaceWith: commandData.Cooldown ? ms(commandData.Cooldown) : "❎",
+          },
+          {
+            searchFor: /{cmd-description}/g,
+            replaceWith: commandData.Description,
+          },
+          {
+            searchFor: /{cmd-dmOnly}/g,
+            replaceWith: legacyCommand.commandConfig.dmOnly ? "✅" : "❎",
+          },
+          {
+            searchFor: /{cmd-guildOnly}/g,
+            replaceWith: legacyCommand.commandConfig.guildOnly ? "✅" : "❎",
+          },
+          {
+            searchFor: /{cmd-isSlashCommand}/g,
+            replaceWith: Array.isArray(commandData.Arguments) ? "✅" : "❎",
+          },
+          {
+            searchFor: /{cmd-slashMentions}/g,
+            replaceWith: slashCommandApplication
+              ? getOptions(slashCommandApplication)
+              : "❎",
+          },
+          {
+            searchFor: /{cmd-permission}/g,
+            replaceWith: commandData.Permission.map((role) => {
+              if (role === "@everyone") return `@everyone`;
+
+              const guildRole = Utils.findRole(message.guild, role, true);
+              if (guildRole) return guildRole.toString();
+            }).join(", "),
+          },
+        ];
+
+        message.reply(
+          Utils.setupMessage({
+            configPath: lang.General.Help.CommandInfo,
+            variables: [
+              ...Utils.userVariables(message.member, "user"),
+              ...commandVariables,
+            ],
+          })
+        );
+        break;
+      }
+      default: {
+        message.reply(
+          Utils.setupMessage({
+            configPath: lang.General.Help.InvalidUsage,
+            variables: [
+              ...Utils.botVariables(manager),
+              ...Utils.guildVariables(message.guild),
+              ...Utils.userVariables(message.member),
+              ...Utils.channelVariables(message.channel),
+              { searchFor: /{prefixUsed}/, replaceWith: prefixUsed },
+            ],
+          })
+        );
+      }
+    }
   },
   InteractionRun: async (manager, interaction, commandData) => {
     const subCommand = interaction.options.getSubcommand();

src/Configs/lang.js

@@ -8,7 +8,7 @@ const LangType = {
   TagEmbed: SetupMessage,
   Presets: {
     Error: SetupMessage,
-    CommandError: SetupMessage
+    CommandError: SetupMessage,
   },
   General: {
     Info: {
@@ -18,6 +18,7 @@ const LangType = {
       InvalidUsage: SetupMessage,
     },
     Help: {
+      InvalidUsage: SetupMessage,
       AutoCompleteCategory: {
         [String]: String,
       },
@@ -47,21 +48,22 @@ const defaultConfig = {
           Color: "#ef1e13",
           Footer: "{brand-name} Error Handler",
           FooterIcon: "{brand-logo}",
-          Timestamp: true
-        }
-      ]
+          Timestamp: true,
+        },
+      ],
     },
     CommandError: {
       Embeds: [
         {
-          Description: "### There was a problem executing this command.\n{error}",
+          Description:
+            "### There was a problem executing this command.\n{error}",
           Color: "#ef1e13",
           Footer: "{brand-name} Error Handler",
           FooterIcon: "{brand-logo}",
-          Timestamp: true
-        }
-      ]
-    }
+          Timestamp: true,
+        },
+      ],
+    },
   },
   TagEmbed: {
     Embeds: [
@@ -106,21 +108,20 @@ const defaultConfig = {
             {
               Name: "📥 Input",
               Value: "```js\n{input}```",
-              Inline: false
+              Inline: false,
             },
             {
               Name: "📤 Output",
               Value: "```js\n{output}```",
-              Inline: false
-            }
+              Inline: false,
+            },
           ],
           Footer: "{brand-name} | Secure Execution",
           FooterIcon: "{brand-logo}",
-          Timestamp: true
-        }
-      ]
-      
-    }
+          Timestamp: true,
+        },
+      ],
+    },
   },
   General: {
     Info: {
@@ -278,6 +279,25 @@ const defaultConfig = {
       },
     },
     Help: {
+      InvalidUsage: {
+        Embeds: [
+          {
+            Author: "{brand-name} | Invalid Usage",
+            AuthorIcon: "{brand-logo}",
+            Description:
+              "> {user-mention}, you have to specify a valid type of information to show. Valid types are: `category` and `command`.",
+            Fields: [
+              {
+                Name: "• Usage",
+                Value: "> `{prefixUsed}help <category/command> [parameter]`",
+              },
+            ],
+            FooterIcon: "{user-pfp}",
+            Footer: "{user-tag}",
+            Timestamp: true,
+          },
+        ],
+      },
       AutoCompleteCategory: {
         General: "General Commands 🌏",
       },