Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/main/java/com/alttd/AltitudeBot.java

src/main/java/com/alttd/AltitudeBot.java

@@ -1,17 +1,24 @@
 package com.alttd;
 
 import com.alttd.commandManager.CommandManager;
+import com.alttd.commandManager.listeners.JDAListener;
 import com.alttd.config.SettingsConfig;
 import com.alttd.config.MessagesConfig;
+import com.alttd.console.ConsoleCommandManager;
+import com.alttd.database.Database;
+import com.alttd.database.DatabaseTables;
 import com.alttd.permissions.PermissionManager;
 import com.alttd.util.Logger;
+import com.mysql.cj.log.Log;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.JDABuilder;
-import net.dv8tion.jda.api.requests.GatewayIntent;
+import net.dv8tion.jda.api.OnlineStatus;
+import net.dv8tion.jda.api.entities.Activity;
 
 import javax.security.auth.login.LoginException;
 import java.io.File;
 import java.net.URISyntaxException;
+import java.util.Scanner;
 
 import static java.lang.System.exit;
 
@@ -33,29 +40,27 @@ public class AltitudeBot {
         Logger.info("Starting bot...");
         initConfigs();
         try {
-            jda = JDABuilder.createDefault(SettingsConfig.TOKEN,
-                    GatewayIntent.DIRECT_MESSAGE_REACTIONS,
-                    GatewayIntent.DIRECT_MESSAGE_TYPING,
-                    GatewayIntent.DIRECT_MESSAGES,
-                    GatewayIntent.GUILD_BANS,
-                    GatewayIntent.GUILD_EMOJIS,
-                    GatewayIntent.GUILD_MEMBERS,
-                    GatewayIntent.GUILD_MESSAGE_REACTIONS,
-                    GatewayIntent.GUILD_MESSAGE_TYPING,
-                    GatewayIntent.GUILD_MESSAGES,
-                    GatewayIntent.GUILD_PRESENCES,
-                    GatewayIntent.GUILD_WEBHOOKS).build();
+            jda = JDABuilder.createDefault(SettingsConfig.TOKEN).build();
         } catch (LoginException e) {
             Logger.info("Unable to log in, shutting down (check token in settings.yml).");
             exit(1);
             Logger.exception(e);
         }
+        DatabaseTables.createTables(Database.getDatabase().getConnection());
+        ConsoleCommandManager.startConsoleCommands(jda);
+        try {
+            jda.getPresence().setPresence(
+                    OnlineStatus.valueOf(SettingsConfig.STATUS),
+                    Activity.listening(SettingsConfig.ACTIVITY));
+        } catch (IllegalArgumentException e) {
+            Logger.exception(e);
+        }
         initListeners();
         //TODO init permissionManager
     }
 
     private void initListeners() {
-        jda.addEventListener(new CommandManager(jda));
+        jda.addEventListener(new JDAListener(jda));
     }
 
     private void initConfigs() {

src/main/java/com/alttd/commandManager/CommandManager.java

@@ -1,5 +1,6 @@
 package com.alttd.commandManager;
 
+import com.alttd.commandManager.commands.AddCommand.CommandManage;
 import com.alttd.commandManager.commands.CommandHelp;
 import com.alttd.commandManager.commands.PollCommand.CommandPoll;
 import com.alttd.database.Database;
@@ -28,9 +29,10 @@ public class CommandManager extends ListenerAdapter {
     private final HashMap<String, List<ScopeInfo>> commandList = new HashMap<>();
 
     public CommandManager(JDA jda) {
-        commands = List.of(new CommandHelp(jda, this),
-                new CommandPoll(jda, this));
         loadCommands();
+        commands = List.of(new CommandHelp(jda, this),
+                new CommandPoll(jda, this),
+                new CommandManage(jda, this));
     }
 
     @Override
@@ -85,9 +87,10 @@ public class CommandManager extends ListenerAdapter {
 
     private void loadCommands() {
         String sql = "SELECT * FROM commands";
+        PreparedStatement statement = null;
 
         try {
-            PreparedStatement statement = Database.getDatabase().getConnection().prepareStatement(sql);
+            statement = Database.getDatabase().getConnection().prepareStatement(sql);
             ResultSet resultSet = statement.executeQuery();
 
             while (resultSet.next()) {
@@ -100,6 +103,13 @@ public class CommandManager extends ListenerAdapter {
             }
         } catch (SQLException exception) {
             Logger.sql(exception);
+        } finally {
+            try {
+                if (statement != null)
+                    statement.close();
+            } catch (SQLException exception) {
+                Logger.sql(exception);
+            }
         }
     }
 

src/main/java/com/alttd/commandManager/SubCommand.java

@@ -1,27 +1,33 @@
 package com.alttd.commandManager;
 
-import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 
-public abstract class SubCommand {
+public abstract class SubCommand extends SubOption{
 
-    private final DiscordCommand parent;
+    private final SubCommandGroup parentGroup;
+    private final boolean inSubGroup;
 
-    protected SubCommand(DiscordCommand parent) {
-        this.parent = parent;
+    protected SubCommand(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parent);
+        this.parentGroup = parentGroup;
+        this.inSubGroup = parentGroup != null;
     }
 
-    public DiscordCommand getParent() {
-        return parent;
+    public SubCommandGroup getParentGroup() {
+        return parentGroup;
     }
 
-    public abstract String getName();
+    public boolean isInSubGroup() {
+        return inSubGroup;
+    }
 
+    @Override
     public String getPermission() {
-        return getParent().getPermission() + "." +  getName();
+        if (isInSubGroup())
+            return getParentGroup().getPermission() + "." + getName();
+        else
+            return getParent().getPermission() + "." + getName();
     }
 
-    public abstract void execute(SlashCommandInteractionEvent event);
-
-    public abstract String getHelpMessage();
-
+    public abstract void suggest(CommandAutoCompleteInteractionEvent event);
 }

src/main/java/com/alttd/commandManager/SubCommandGroup.java

@@ -0,0 +1,7 @@
+package com.alttd.commandManager;
+
+public abstract class SubCommandGroup extends SubOption{
+    protected SubCommandGroup(DiscordCommand parent) {
+        super(parent);
+    }
+}

src/main/java/com/alttd/commandManager/SubOption.java

@@ -0,0 +1,25 @@
+package com.alttd.commandManager;
+
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public abstract class SubOption {
+    private final DiscordCommand parent;
+
+    protected SubOption(DiscordCommand parent) {
+        this.parent = parent;
+    }
+
+    public DiscordCommand getParent() {
+        return parent;
+    }
+
+    public abstract String getName();
+
+    public String getPermission() {
+        return getParent().getPermission() + "." +  getName();
+    }
+
+    public abstract void execute(SlashCommandInteractionEvent event);
+
+    public abstract String getHelpMessage();
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/CommandManage.java

@@ -0,0 +1,105 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.CommandManager;
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubOption;
+import com.alttd.permissions.PermissionManager;
+import com.alttd.util.Logger;
+import com.alttd.util.Util;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
+import net.dv8tion.jda.api.interactions.commands.build.Commands;
+import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandGroupData;
+
+import java.util.HashMap;
+
+public class CommandManage extends DiscordCommand {
+    private final HashMap<String, SubOption> subOptionsMap = new HashMap<>();
+
+    public CommandManage(JDA jda, CommandManager commandManager) {
+        SlashCommandData slashCommandData = Commands.slash(getName(), "Enable commands and assign permissions")
+                .addSubcommandGroups(
+                        new SubcommandGroupData("set", "Set a permission for a user")
+                                .addSubcommands(
+                                        new SubcommandData("user", "Set a permission for a user")
+                                                .addOption(OptionType.MENTIONABLE, "user", "The user to set the permission for", true)
+                                                .addOption(OptionType.STRING, "permission", "The permission to set for a user", true, true)
+                                                .addOption(OptionType.STRING, "state", "To allow or deny the permission (true/false)", true, true),
+                                        new SubcommandData("group", "Set a permission for a group")
+                                                .addOption(OptionType.MENTIONABLE, "group", "The group to set the permission for", true)
+                                                .addOption(OptionType.STRING, "permission", "The permission to set for a group", true, true)
+                                                .addOption(OptionType.STRING, "state", "To allow or deny the permission (true/false)", true, true)
+                                ),
+                        new SubcommandGroupData("unset", "unset a permission for a user")
+                                .addSubcommands(
+                                        new SubcommandData("user", "Unset a permission for a user")
+                                                .addOption(OptionType.MENTIONABLE, "user", "The user to unset the permission for", true)
+                                                .addOption(OptionType.STRING, "permission", "The permission to unset for a user", true, true),
+                                        new SubcommandData("group", "Unset a permission for a group")
+                                                .addOption(OptionType.MENTIONABLE, "group", "The group to unset the permission for", true)
+                                                .addOption(OptionType.STRING, "permission", "The permission to unset for a group", true, true)
+                                )
+                )
+                .addSubcommands(
+                        new SubcommandData("enable", "Enable a command in a channel")
+                                .addOption(OptionType.CHANNEL, "channel", "Channel to enable this command in", true)
+                                .addOption(OptionType.STRING, "command", "Name of the command to enable", true, true),
+                        new SubcommandData("disable", "Disable a command")
+                                .addOption(OptionType.CHANNEL, "channel", "Channel to disable this command in", true)
+                                .addOption(OptionType.STRING, "command", "Name of the command to disable", true, true)
+                        );
+        slashCommandData.setDefaultEnabled(true);
+        Util.registerSubOptions(subOptionsMap,
+                new SubCommandDisable(commandManager, null, this),
+                new SubCommandEnable(commandManager, null, this));
+        Util.registerCommand(commandManager, jda, slashCommandData, getName());
+    }
+
+    @Override
+    public String getName() {
+        return "manage";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+        if (event.getGuild() == null || event.getMember() == null) {
+            event.replyEmbeds(Util.guildOnlyCommand(getName())).setEphemeral(true).queue();
+            return;
+        }
+        if (PermissionManager.getInstance().hasPermission(event.getTextChannel(), event.getIdLong(), Util.getGroupIds(event.getMember()), getPermission())) {
+            event.replyEmbeds(Util.noPermission(getName())).setEphemeral(true).queue();
+            return;
+        }
+
+        String subcommandName = event.getInteraction().getSubcommandGroup();
+        subcommandName = subcommandName == null ? event.getInteraction().getSubcommandName() : subcommandName;
+        if (subcommandName == null) {
+            Logger.severe("No subcommand found for %", getName());
+            return;
+        }
+
+        SubOption subOption = subOptionsMap.get(subcommandName);
+        if (subOption == null) {
+            event.replyEmbeds(Util.invalidSubcommand(subcommandName))
+                    .setEphemeral(true)
+                    .queue();
+            return;
+        }
+
+        subOption.execute(event);
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandDisable.java

@@ -0,0 +1,38 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.CommandManager;
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public class SubCommandDisable extends SubCommand {
+
+    private final CommandManager commandManager;
+
+    protected SubCommandDisable(CommandManager commandManager, SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
+        this.commandManager = commandManager;
+    }
+
+    @Override
+    public String getName() {
+        return "disable";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandEnable.java

@@ -0,0 +1,38 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.CommandManager;
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public class SubCommandEnable extends SubCommand {
+
+    private final CommandManager commandManager;
+
+    protected SubCommandEnable(CommandManager commandManager, SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
+        this.commandManager = commandManager;
+    }
+
+    @Override
+    public String getName() {
+        return "enable";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandGroupSet.java

@@ -0,0 +1,58 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import com.alttd.commandManager.SubOption;
+import com.alttd.permissions.PermissionManager;
+import com.alttd.util.Logger;
+import com.alttd.util.Util;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.HashMap;
+
+public class SubCommandGroupSet extends SubCommandGroup {
+
+    private final HashMap<String, SubOption> subOptionsMap = new HashMap<>();
+
+    protected SubCommandGroupSet(DiscordCommand parent) {
+        super(parent);
+        Util.registerSubOptions(subOptionsMap,
+                new SubCommandUnsetGroup(this, getParent()),
+                new SubCommandUnsetUser(this, getParent()));
+    }
+
+    @Override
+    public String getName() {
+        return "set";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+        if (PermissionManager.getInstance().hasPermission(event.getTextChannel(), event.getIdLong(), Util.getGroupIds(event.getMember()), getPermission())) {
+            event.replyEmbeds(Util.noPermission(getName())).setEphemeral(true).queue();
+            return;
+        }
+
+        String subcommandName = event.getInteraction().getSubcommandName();
+        if (subcommandName == null) {
+            Logger.severe("No subcommand found for %", getName());
+            return;
+        }
+
+        SubOption subOption = subOptionsMap.get(subcommandName);
+        if (subOption == null) {
+            event.replyEmbeds(Util.invalidSubcommand(subcommandName))
+                    .setEphemeral(true)
+                    .queue();
+            return;
+        }
+
+        subOption.execute(event);
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}
+

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandGroupUnset.java

@@ -0,0 +1,57 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import com.alttd.commandManager.SubOption;
+import com.alttd.permissions.PermissionManager;
+import com.alttd.util.Logger;
+import com.alttd.util.Util;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.HashMap;
+
+public class SubCommandGroupUnset extends SubCommandGroup {
+
+    private final HashMap<String, SubOption> subOptionsMap = new HashMap<>();
+
+    protected SubCommandGroupUnset(DiscordCommand parent) {
+        super(parent);
+        Util.registerSubOptions(subOptionsMap,
+                new SubCommandUnsetGroup(this, getParent()),
+                new SubCommandUnsetUser(this, getParent()));
+    }
+
+    @Override
+    public String getName() {
+        return "unset";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+        if (PermissionManager.getInstance().hasPermission(event.getTextChannel(), event.getIdLong(), Util.getGroupIds(event.getMember()), getPermission())) {
+            event.replyEmbeds(Util.noPermission(getName())).setEphemeral(true).queue();
+            return;
+        }
+
+        String subcommandName = event.getInteraction().getSubcommandName();
+        if (subcommandName == null) {
+            Logger.severe("No subcommand found for %", getName());
+            return;
+        }
+
+        SubOption subOption = subOptionsMap.get(subcommandName);
+        if (subOption == null) {
+            event.replyEmbeds(Util.invalidSubcommand(subcommandName))
+                    .setEphemeral(true)
+                    .queue();
+            return;
+        }
+
+        subOption.execute(event);
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandSetGroup.java

@@ -0,0 +1,34 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public class SubCommandSetGroup extends SubCommand {
+
+    protected SubCommandSetGroup(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
+    }
+
+    @Override
+    public String getName() {
+        return "group";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandSetUser.java

@@ -0,0 +1,34 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public class SubCommandSetUser extends SubCommand {
+
+    protected SubCommandSetUser(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
+    }
+
+    @Override
+    public String getName() {
+        return "user";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandUnsetGroup.java

@@ -0,0 +1,34 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public class SubCommandUnsetGroup extends SubCommand {
+
+    protected SubCommandUnsetGroup(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
+    }
+
+    @Override
+    public String getName() {
+        return "group";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/AddCommand/SubCommandUnsetUser.java

@@ -0,0 +1,34 @@
+package com.alttd.commandManager.commands.AddCommand;
+
+import com.alttd.commandManager.DiscordCommand;
+import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+public class SubCommandUnsetUser extends SubCommand {
+
+    protected SubCommandUnsetUser(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
+    }
+
+    @Override
+    public String getName() {
+        return "user";
+    }
+
+    @Override
+    public void execute(SlashCommandInteractionEvent event) {
+
+    }
+
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return null;
+    }
+}

src/main/java/com/alttd/commandManager/commands/PollCommand/CommandPoll.java

@@ -3,6 +3,7 @@ package com.alttd.commandManager.commands.PollCommand;
 import com.alttd.commandManager.CommandManager;
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubOption;
 import com.alttd.permissions.PermissionManager;
 import com.alttd.util.Logger;
 import com.alttd.util.Util;
@@ -18,7 +19,7 @@ import java.util.HashMap;
 
 public class CommandPoll extends DiscordCommand {
 
-    private final HashMap<String, SubCommand> subCommandMap = new HashMap<>();
+    private final HashMap<String, SubOption> subOptionsMap = new HashMap<>();
 
     public CommandPoll(JDA jda, CommandManager commandManager) {
         SlashCommandData slashCommandData = Commands.slash(getName(), "Create, edit, and manage polls")
@@ -53,15 +54,15 @@ public class CommandPoll extends DiscordCommand {
                                 .addOption(OptionType.CHANNEL, "channel", "Channel this poll is in", true)
                                 .addOption(OptionType.INTEGER, "message_id", "Id of the poll you want the results for", true));
         slashCommandData.setDefaultEnabled(true);
-        Util.registerSubcommands(subCommandMap,
-                new SubCommandAdd(this),
-                new SubCommandAddButton(this),
-                new SubCommandClose(this),
-                new SubCommandEditDescription(this),
-                new SubCommandEditTitle(this),
-                new SubCommandOpen(this),
-                new SubCommandRemoveButton(this),
-                new SubCommandResults(this));
+        Util.registerSubOptions(subOptionsMap,
+                new SubCommandAdd(null,this),
+                new SubCommandAddButton(null, this),
+                new SubCommandClose(null,this),
+                new SubCommandEditDescription(null, this),
+                new SubCommandEditTitle(null, this),
+                new SubCommandOpen(null, this),
+                new SubCommandRemoveButton(null, this),
+                new SubCommandResults(null,this));
         Util.registerCommand(commandManager, jda, slashCommandData, getName());
     }
 
@@ -81,21 +82,22 @@ public class CommandPoll extends DiscordCommand {
             return;
         }
 
-        String subcommandName = event.getInteraction().getSubcommandName();
+        String subcommandName = event.getInteraction().getSubcommandGroup();
+        subcommandName = subcommandName == null ? event.getInteraction().getSubcommandName() : subcommandName;
         if (subcommandName == null) {
             Logger.severe("No subcommand found for %", getName());
             return;
         }
 
-        SubCommand subCommand = subCommandMap.get(subcommandName);
-        if (subCommand == null) {
+        SubOption subOption = subOptionsMap.get(subcommandName);
+        if (subOption == null) {
             event.replyEmbeds(Util.invalidSubcommand(subcommandName))
                     .setEphemeral(true)
                     .queue();
             return;
         }
 
-        subCommand.execute(event);
+        subOption.execute(event);
     }
 
     @Override

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandAdd.java

@@ -2,6 +2,7 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.config.MessagesConfig;
 import com.alttd.templates.Parser;
 import com.alttd.templates.Template;
@@ -10,6 +11,7 @@ import com.alttd.util.OptionMappingParsing;
 import com.alttd.util.Util;
 import net.dv8tion.jda.api.EmbedBuilder;
 import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.InteractionHook;
 
@@ -17,8 +19,8 @@ import java.awt.*;
 
 public class SubCommandAdd extends SubCommand {
 
-    protected SubCommandAdd(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandAdd(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -57,6 +59,11 @@ public class SubCommandAdd extends SubCommand {
                 .queue(result -> createPoll(channel, title, result));
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     private void createPoll(GuildMessageChannel channel, String title, InteractionHook hook) {
         channel.sendMessageEmbeds(new EmbedBuilder()
                 .setTitle(title)

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandAddButton.java

@@ -2,6 +2,7 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.templates.Parser;
 import com.alttd.templates.Template;
 import com.alttd.util.Logger;
@@ -12,12 +13,13 @@ import net.dv8tion.jda.api.entities.ChannelType;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.InteractionHook;
 
 public class SubCommandAddButton extends SubCommand {
-    protected SubCommandAddButton(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandAddButton(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -77,6 +79,11 @@ public class SubCommandAddButton extends SubCommand {
                         throwable -> failedToGetMessage(throwable, hook)));
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     private void failedToGetMessage(Throwable throwable, InteractionHook hook) {
         Logger.warning(throwable.getMessage());
         hook.editOriginalEmbeds(Util.genericErrorEmbed("Failed to get poll message",

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandClose.java

@@ -2,13 +2,15 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.util.OptionMappingParsing;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 
 public class SubCommandClose extends SubCommand {
-    protected SubCommandClose(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandClose(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -26,6 +28,11 @@ public class SubCommandClose extends SubCommand {
             return;
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     @Override
     public String getHelpMessage() {
         return null;

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandEditDescription.java

@@ -2,17 +2,19 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.util.OptionMappingParsing;
 import com.alttd.util.Util;
 import net.dv8tion.jda.api.EmbedBuilder;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.InteractionHook;
 
 public class SubCommandEditDescription extends SubCommand {
-    protected SubCommandEditDescription(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandEditDescription(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -33,6 +35,11 @@ public class SubCommandEditDescription extends SubCommand {
             return;
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     //Copied over while working on add button
     private void updatePoll(GuildMessageChannel channel, int rowId, String buttonName, Message message,
                             InteractionHook hook) {

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandEditTitle.java

@@ -2,13 +2,15 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.util.OptionMappingParsing;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 
 public class SubCommandEditTitle extends SubCommand {
-    protected SubCommandEditTitle(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandEditTitle(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -29,6 +31,11 @@ public class SubCommandEditTitle extends SubCommand {
             return;
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     @Override
     public String getHelpMessage() {
         return null;

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandOpen.java

@@ -2,13 +2,15 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.util.OptionMappingParsing;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 
 public class SubCommandOpen extends SubCommand {
-    protected SubCommandOpen(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandOpen(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -26,6 +28,11 @@ public class SubCommandOpen extends SubCommand {
             return;
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     @Override
     public String getHelpMessage() {
         return null;

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandRemoveButton.java

@@ -2,13 +2,15 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.util.OptionMappingParsing;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 
 public class SubCommandRemoveButton extends SubCommand {
-    protected SubCommandRemoveButton(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandRemoveButton(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -29,6 +31,11 @@ public class SubCommandRemoveButton extends SubCommand {
             return;
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     @Override
     public String getHelpMessage() {
         return null;

src/main/java/com/alttd/commandManager/commands/PollCommand/SubCommandResults.java

@@ -2,13 +2,15 @@ package com.alttd.commandManager.commands.PollCommand;
 
 import com.alttd.commandManager.DiscordCommand;
 import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubCommandGroup;
 import com.alttd.util.OptionMappingParsing;
 import net.dv8tion.jda.api.entities.GuildMessageChannel;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 
 public class SubCommandResults extends SubCommand {
-    protected SubCommandResults(DiscordCommand parent) {
-        super(parent);
+    protected SubCommandResults(SubCommandGroup parentGroup, DiscordCommand parent) {
+        super(parentGroup, parent);
     }
 
     @Override
@@ -26,6 +28,11 @@ public class SubCommandResults extends SubCommand {
             return;
     }
 
+    @Override
+    public void suggest(CommandAutoCompleteInteractionEvent event) {
+
+    }
+
     @Override
     public String getHelpMessage() {
         return null;

src/main/java/com/alttd/commandManager/listeners/JDAListener.java

@@ -0,0 +1,24 @@
+package com.alttd.commandManager.listeners;
+
+import com.alttd.commandManager.CommandManager;
+import com.alttd.util.Logger;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.events.ReadyEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import org.jetbrains.annotations.NotNull;
+
+public class JDAListener extends ListenerAdapter {
+
+    private final JDA jda;
+
+    public JDAListener(JDA jda) {
+        this.jda = jda;
+    }
+
+    @Override
+    public void onReady(@NotNull ReadyEvent event) {
+        Logger.info("JDA ready registering commands.");
+        jda.addEventListener(new CommandManager(jda));
+    }
+
+}

src/main/java/com/alttd/config/SettingsConfig.java

@@ -1,5 +1,7 @@
 package com.alttd.config;
 
+import net.dv8tion.jda.api.entities.Activity;
+
 public class SettingsConfig extends AbstractConfig {
 
     static SettingsConfig settingsConfig;
@@ -36,4 +38,22 @@ public class SettingsConfig extends AbstractConfig {
         DATABASE_PASSWORD = settingsConfig.getString("settings.database_password", DATABASE_PASSWORD);
     }
 
+
+    public static String STATUS = "ONLINE";
+    public static String ACTIVITY = "Testing";
+    private void loadActivity() {
+        STATUS = settingsConfig.getString("settings.status", STATUS);
+        ACTIVITY = settingsConfig.getString("settings.activity", ACTIVITY);
+    }
+
+    public static void setActivity(String newActivity) {
+        ACTIVITY = newActivity;
+        settingsConfig.set("settings.activity", ACTIVITY);
+    }
+
+    public static void setStatus(String status) {
+        STATUS = status;
+        settingsConfig.set("settings.activity", STATUS);
+    }
+
 }

src/main/java/com/alttd/console/ConsoleActivity.java

@@ -0,0 +1,43 @@
+package com.alttd.console;
+
+import com.alttd.config.SettingsConfig;
+import com.alttd.util.Logger;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.Activity;
+
+import java.util.Arrays;
+
+public class ConsoleActivity extends ConsoleCommand {
+    private final JDA jda;
+
+    public ConsoleActivity(JDA jda) {
+        super();
+        this.jda = jda;
+    }
+
+    @Override
+    public String getName() {
+        return "activity";
+    }
+
+    @Override
+    public void execute(String command, String[] args) {
+        if (args.length == 1) {
+            Activity activity = jda.getPresence().getActivity();
+            if (activity == null)
+                Logger.info("No activity found.");
+            else
+                Logger.info("Current activity: Listening to " + activity.getName());
+            return;
+        }
+        String newActivity = String.join(" ", Arrays.copyOfRange(args, 1, args.length));
+        SettingsConfig.setActivity(newActivity);
+        jda.getPresence().setActivity(Activity.listening(newActivity));
+        Logger.info("Set activity to: Listening to " + newActivity);
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return "activity [set] [text] Display the current activity or set it.";
+    }
+}

src/main/java/com/alttd/console/ConsoleCommand.java

@@ -0,0 +1,11 @@
+package com.alttd.console;
+
+public abstract class ConsoleCommand {
+
+    public abstract String getName();
+
+    public abstract void execute(String command, String[] args);
+
+    public abstract String getHelpMessage();
+
+}

src/main/java/com/alttd/console/ConsoleCommandManager.java

@@ -0,0 +1,54 @@
+package com.alttd.console;
+
+import com.alttd.util.Logger;
+import net.dv8tion.jda.api.JDA;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.Scanner;
+
+public class ConsoleCommandManager {
+
+    private final List<ConsoleCommand> commands = new ArrayList<>();
+    private static ConsoleCommandManager instance = null;
+
+    private ConsoleCommandManager(JDA jda) {
+        commands.addAll(List.of(
+                new ConsoleActivity(jda),
+                new ConsoleHelp(this),
+                new ConsoleReload(),
+                new ConsoleStatus(jda),
+                new ConsoleStop()));
+        new Thread(() -> {
+            while (true)
+                instance.readCommand(new Scanner(System.in));
+        }).start();
+    }
+
+    private void readCommand(Scanner scanner) {
+        System.out.print("command: ");
+        String[] args = scanner.nextLine().toLowerCase().split(" +");
+        if (args.length == 0 || args[0].length() == 0)
+            return;
+        String command = args[0];
+        Optional<ConsoleCommand> first = commands.stream()
+                .filter(consoleCommand -> consoleCommand.getName().equalsIgnoreCase(command))
+                .findFirst();
+        if (first.isEmpty()) {
+            Logger.info("Invalid command, see help for more info.");
+            return;
+        }
+        first.get().execute(command, args);
+    }
+
+    protected List<ConsoleCommand> getCommands() {
+        return commands;
+    }
+
+    public static void startConsoleCommands(JDA jda) {
+        Logger.info("Starting console commands");
+        if (instance == null)
+            instance = new ConsoleCommandManager(jda);
+    }
+}

src/main/java/com/alttd/console/ConsoleHelp.java

@@ -0,0 +1,34 @@
+package com.alttd.console;
+
+import com.alttd.templates.Parser;
+import com.alttd.templates.Template;
+import com.alttd.util.Logger;
+
+import java.util.stream.Collectors;
+
+public class ConsoleHelp extends ConsoleCommand {
+    ConsoleCommandManager commandManager;
+
+    public ConsoleHelp(ConsoleCommandManager instance) {
+        super();
+        commandManager = instance;
+    }
+
+    @Override
+    public String getName() {
+        return "help";
+    }
+
+    @Override
+    public void execute(String command, String[] args) {
+        Template template = Template.of("commands", commandManager.getCommands().stream()
+                .map(ConsoleCommand::getHelpMessage)
+                .collect(Collectors.joining("\n")));
+        Logger.info(Parser.parse("Commands:\n<commands>", template));
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return "help - Shows this help menu";
+    }
+}

src/main/java/com/alttd/console/ConsoleReload.java

@@ -0,0 +1,37 @@
+package com.alttd.console;
+
+import com.alttd.config.MessagesConfig;
+import com.alttd.config.SettingsConfig;
+import com.alttd.util.Logger;
+
+public class ConsoleReload extends ConsoleCommand {
+    @Override
+    public String getName() {
+        return "reload";
+    }
+
+    @Override
+    public void execute(String command, String[] args) {
+        if (args.length != 2) {
+            Logger.info("Invalid argument length: " + getHelpMessage());
+            return;
+        }
+        switch (args[1]) {
+            case "config" -> {
+                MessagesConfig.reload();
+                Logger.info("Reloaded Messages config.");
+                SettingsConfig.reload();
+                Logger.info("Reloaded Settings config.");
+            }
+            case "database" -> {
+                Logger.info("NOT IMPLEMENTED YET");
+            }
+            default -> Logger.info("Invalid argument: " + args[1]);
+        }
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return "reload <config/database> - Reload the configs or databases";
+    }
+}

src/main/java/com/alttd/console/ConsoleStatus.java

@@ -0,0 +1,53 @@
+package com.alttd.console;
+
+import com.alttd.config.SettingsConfig;
+import com.alttd.util.Logger;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.OnlineStatus;
+import net.dv8tion.jda.api.entities.Activity;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class ConsoleStatus extends ConsoleCommand{
+
+    private final JDA jda;
+
+    public ConsoleStatus(JDA jda) {
+        this.jda = jda;
+    }
+
+    @Override
+    public String getName() {
+        return "status";
+    }
+
+    @Override
+    public void execute(String command, String[] args) {
+        if (args.length == 1) {
+            OnlineStatus status = jda.getPresence().getStatus();
+            Logger.info("Current status: " + status.getKey());
+            return;
+        }
+        if (args.length != 2) {
+            Logger.info("Invalid argument length.");
+            return;
+        }
+        try {
+            OnlineStatus status = OnlineStatus.fromKey(args[1].toLowerCase());
+            SettingsConfig.setStatus(status.getKey());
+            jda.getPresence().setStatus(status);
+            Logger.info("Set status to: " + SettingsConfig.STATUS);
+        } catch (IllegalArgumentException exception) {
+            Logger.info("Invalid status please use any of the following "
+                    + Arrays.stream(OnlineStatus.values())
+                    .map(OnlineStatus::getKey)
+                    .collect(Collectors.joining(", ")));
+        }
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return "status [set] [status] - Display the current status or set it";
+    }
+}

src/main/java/com/alttd/console/ConsoleStop.java

@@ -0,0 +1,23 @@
+package com.alttd.console;
+
+import com.alttd.AltitudeBot;
+import com.alttd.util.Logger;
+
+public class ConsoleStop extends ConsoleCommand {
+    @Override
+    public String getName() {
+        return "stop";
+    }
+
+    @Override
+    public void execute(String command, String[] args) {
+        Logger.info("Stopping bot...");
+        AltitudeBot.getInstance().getJDA().cancelRequests();
+        System.exit(0);
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return "stop - Stop the bot";
+    }
+}

src/main/java/com/alttd/database/DatabaseTables.java

@@ -10,6 +10,7 @@ import java.sql.SQLException;
 
 public class DatabaseTables {
 
+    private static DatabaseTables instance = null;
     private Connection connection;
 
     protected DatabaseTables (Connection connection) {
@@ -44,7 +45,7 @@ public class DatabaseTables {
                     "active BIT DEFAULT b'0', " +
                     "poll_title VARCHAR(256) NOT NULL, " +
                     "embed_type VARCHAR(32) DEFAULT 'ABSTRACT_EMBED', " +
-                    "PRIMARY KEY (UUID, villager_type)" +
+                    "PRIMARY KEY (poll_id)" +
                     ")";
             connection.prepareStatement(sql).executeUpdate();
         } catch (SQLException e) {
@@ -53,4 +54,24 @@ public class DatabaseTables {
         }
     }
 
+    private void createCommandsTable() {
+        try {
+            String sql = "CREATE TABLE IF NOT EXISTS commands(" +
+                    "command_name VARCHAR(64) NOT NULL, " +
+                    "scope VARCHAR(16) NOT NULL, " +
+                    "location_id BIGINT NOT NULL, " +
+                    "PRIMARY KEY (command_name, scope, location_id)" +
+                    ")";
+            connection.prepareStatement(sql).executeUpdate();
+        } catch (SQLException e) {
+            Logger.sql(e);
+            Logger.severe("Unable to create polls table, shutting down...");
+        }
+    }
+
+    public static void createTables(Connection connection) {
+        if (instance == null)
+            instance = new DatabaseTables(connection);
+    }
+
 }

src/main/java/com/alttd/permissions/PermissionManager.java

@@ -27,6 +27,15 @@ public class PermissionManager {
         instance = this;
     }
 
+    /**
+     * Check if a user has a certain permission and if that permission is enabled in the specified channel
+     *
+     * @param   textChannel Text channel command was executed in
+     * @param   member      Member to check permission for
+     * @param   permission  Permission to check for
+     *
+     * @return  True if the member has permission or is owner, false if not
+     */
     public boolean hasPermission(TextChannel textChannel, Member member, String permission) {
         return hasPermission(textChannel,
                 member.getIdLong(),
@@ -34,12 +43,24 @@ public class PermissionManager {
                 permission);
     }
 
+    /**
+     * Check if a user has a certain permission and if that permission is enabled in the specified channel
+     *
+     * @param   textChannel Text channel command was executed in
+     * @param   userId      ID of the user to check for
+     * @param   groupIds    List of group id's a user has (can be null or empty)
+     * @param   permission  Permission to check for
+     *
+     * @return  True if the user has permission or is owner, false if not
+     */
     public boolean hasPermission(TextChannel textChannel, long userId, List<Long> groupIds, String permission) {
         permission = permission.toLowerCase();
         if (textChannel instanceof PrivateChannel) {
             if (isDisabled(privateEnabledCommands, permission))
                 return false;
         } else {
+            if (textChannel.getGuild().getOwnerIdLong() == userId)
+                return true;
             if (isDisabled(channelEnabledCommands.get(textChannel.getIdLong()), permission.toLowerCase()))
                 return false;
         }
@@ -70,6 +91,11 @@ public class PermissionManager {
         return permissions.contains(permission);
     }
 
+    /**
+     * Get the permission manager instance
+     *
+     * @return  Permission manager instance
+     */
     public static PermissionManager getInstance() {
         return instance;
     }

src/main/java/com/alttd/util/Logger.java

@@ -22,7 +22,7 @@ public class Logger { //TODO make this log to a file
         if (!logDir.exists())
         {
             if (!logDir.mkdir()) {
-                System.out.println("UNABLE TO CREATE LOGGING DIRECTORY");
+                Logger.info("UNABLE TO CREATE LOGGING DIRECTORY");
                 System.exit(1);
             }
         }

src/main/java/com/alttd/util/Util.java

@@ -2,7 +2,7 @@ package com.alttd.util;
 
 import com.alttd.commandManager.CommandManager;
 import com.alttd.commandManager.ScopeInfo;
-import com.alttd.commandManager.SubCommand;
+import com.alttd.commandManager.SubOption;
 import com.alttd.config.MessagesConfig;
 import com.alttd.templates.Parser;
 import com.alttd.templates.Template;
@@ -113,9 +113,9 @@ public class Util {
         }
     }
 
-    public static void registerSubcommands(HashMap<String, SubCommand> subCommandMap, SubCommand... subCommands) {
-        for (SubCommand subCommand : subCommands)
-            subCommandMap.put(subCommand.getName(), subCommand);
+    public static void registerSubOptions(HashMap<String, SubOption> subCommandMap, SubOption... subOptions) {
+        for (SubOption subOption : subOptions)
+            subCommandMap.put(subOption.getName(), subOption);
     }
 
     public static boolean validateGuildMessageChannel(SlashCommandInteraction interaction, GuildMessageChannel channel, ChannelType channelType, @NotNull Member member) {