Merge branch 'master' of gitlab.libraryofcode.org:engineering/cloudservices-rewrite

src/class/Command.ts

@@ -18,6 +18,8 @@ export default class Command {
 
     guildOnly?: boolean
 
+    subcommands: Map<string, Command>
+
     public run(message: Message, args: string[]) {} // eslint-disable-line
 
     constructor(client: Client) {
@@ -28,6 +30,7 @@ export default class Command {
       this.aliases = [];
       this.guildOnly = true;
       this.client = client;
+      this.subcommands = new Map();
       this.permissions = {};
     }
 }

src/class/Util.ts

@@ -36,15 +36,47 @@ export default class Util {
     return result;
   }
 
-  public resolveCommand(command: string): Command {
+  public resolveCommand(command: string, args: string[]): { command: Command, args: string[]} {
-    if (this.client.commands.has(command)) return this.client.commands.get(command);
+    let Cmd: Command;
-    for (const cmd of this.client.commands.values()) {
+    if (this.client.commands.has(command)) Cmd = this.client.commands.get(command);
-      if (!cmd.aliases) continue;// eslint-disable-line no-continue
+    else {
-      for (const alias of cmd.aliases) {
+      for (const cmd of this.client.commands.values()) {
-        if (command === alias.toLowerCase()) return cmd;
+        if (!cmd.aliases) continue;// eslint-disable-line no-continue
+        for (const alias of cmd.aliases) {
+          if (command.toLowerCase() === alias.toLowerCase()) {
+            Cmd = cmd;
+          } else {
+            return undefined;
+          }
+        }
       }
     }
-    return undefined;
+    if (!Cmd) return undefined;
+    let hasSubcmd = true;
+    while (hasSubcmd) {
+      if (!Cmd.subcommands.size) {
+        hasSubcmd = false; break;
+      }
+      if (Cmd.subcommands.has(args[0])) {
+        Cmd = Cmd.subcommands.get(args[0]);
+        args.shift();
+      } else {
+        for (const cmd of Cmd.subcommands.values()) {
+          if (!cmd.aliases) continue; // eslint-disable-line
+          for (const alias of cmd.aliases) {
+            if (args[0].toLowerCase() === alias.toLowerCase()) {
+              Cmd = cmd; args.shift(); break;
+            }
+          }
+          break;
+        }
+      }
+    }
+    return { command: Cmd, args };
+  }
+
+  public resolveSubcommand(parentCmd: Command, args?: string[]) {
+
   }
 
   public async handleError(error: Error, message?: Message, command?: Command): Promise<void> {

src/commands/exec.ts

@@ -18,7 +18,12 @@ export default class Exec extends Command {
       if (!args.length) return this.client.commands.get('help').run(message, [this.name]);
 
       const response = await message.channel.createMessage(`${this.client.stores.emojis.loading} ***Executing \`${args.join(' ')}\`***`);
-      const result = await this.client.util.exec(args.join(' '));
+      let result: string;
+      try {
+        result = await this.client.util.exec(args.join(' '));
+      } catch (error) {
+        result = error.message;
+      }
 
       if (result.length <= 1975) return response.edit(`\`\`\`bash\n${result}\n\`\`\``);
       const splitResult = this.client.util.splitString(result, 1975);

src/commands/modlogs.ts

@@ -54,7 +54,7 @@ export default class Modlogs extends Command {
 
       if (embeds.length === 1) {
         // @ts-ignore
-        message.channel.createMessage({ embed: embeds[0] });
+        msg.edit({ content: '', embed: embeds[0] });
       } else {
         createPaginationEmbed(message, this.client, embeds, {}, msg);
       }

src/events/messageCreate.ts

@@ -15,30 +15,30 @@ export default class {
         if (message.content.indexOf(this.client.config.prefix) !== 0) return;
         const noPrefix: string[] = message.content.slice(this.client.config.prefix.length).trim().split(/ +/g);
         const command: string = noPrefix[0].toLowerCase();
-        const resolved: Command = this.client.util.resolveCommand(command);
+        const Args = noPrefix.slice(1);
+        const resolved: { command: Command, args: string[] } = this.client.util.resolveCommand(command, Args);
         if (!resolved) return;
-        if (resolved.guildOnly && !(message.channel instanceof TextChannel)) return;
+        if (resolved.command.guildOnly && !(message.channel instanceof TextChannel)) return;
         let hasUserPerms: boolean;
-        if (resolved.permissions.users) {
+        if (resolved.command.permissions.users) {
-          hasUserPerms = resolved.permissions.users.includes(message.author.id);
+          hasUserPerms = resolved.command.permissions.users.includes(message.author.id);
         }
         let hasRolePerms: boolean = false;
-        if (resolved.permissions.roles) {
+        if (resolved.command.permissions.roles) {
-          for (const role of resolved.permissions.roles) {
+          for (const role of resolved.command.permissions.roles) {
             if (message.member && message.member.roles.includes(role)) {
               // this.client.signale.debug(message.member.roles.includes(role));
               hasRolePerms = true; break;
             }
           }
         }
-        if (!resolved.permissions.users && !resolved.permissions.roles) {
+        if (!resolved.command.permissions.users && !resolved.command.permissions.roles) {
           hasUserPerms = true;
           hasRolePerms = true;
         }
         if (!hasRolePerms && !hasUserPerms) return;
-        if (!resolved.enabled) { message.channel.createMessage(`***${this.client.stores.emojis.error} This command has been disabled***`); return; }
+        if (!resolved.command.enabled) { message.channel.createMessage(`***${this.client.stores.emojis.error} This command has been disabled***`); return; }
-        const args: string[] = noPrefix.slice(1);
+        resolved.command.run(message, resolved.args);
-        resolved.run(message, args);
       } catch (error) {
         this.client.util.handleError(error, message);
       }