Stop using !commands start using /commands

add /whitelist whois @discorduser
1.17.1 version update

src/main/java/uk/co/angrybee/joe/AuthorPermissions.java

@@ -1,6 +1,7 @@
 package uk.co.angrybee.joe;
 
 import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 
 import java.util.Arrays;
@@ -13,6 +14,111 @@ public class AuthorPermissions
     private boolean userIsBanned = false;
     private boolean userCanUseClear = false;
 
+    public AuthorPermissions(SlashCommandEvent event) {
+        for (Role role : event.getMember().getRoles())
+        {
+            if(!DiscordWhitelister.useIdForRoles)
+            {
+                if (Arrays.stream(DiscordClient.allowedToAddRemoveRoles).parallel().anyMatch(role.getName()::equalsIgnoreCase))
+                {
+                    userCanAddRemove = true;
+                    break;
+                }
+            }
+            else
+            {
+                if (Arrays.stream(DiscordClient.allowedToAddRemoveRoles).parallel().anyMatch(role.getId()::equalsIgnoreCase))
+                {
+                    userCanAddRemove = true;
+                    break;
+                }
+            }
+        }
+
+        for (Role role : event.getGuild().getMember(event.getUser()).getRoles())
+        {
+            if (!DiscordWhitelister.useIdForRoles)
+            {
+                if (Arrays.stream(DiscordClient.allowedToAddRoles).parallel().anyMatch(role.getName()::equalsIgnoreCase))
+                {
+                    userCanAdd = true;
+                    break;
+                }
+            }
+            else
+            {
+                if (Arrays.stream(DiscordClient.allowedToAddRoles).parallel().anyMatch(role.getId()::equalsIgnoreCase))
+                {
+                    userCanAdd = true;
+                    break;
+                }
+            }
+        }
+
+        for (Role role : event.getGuild().getMember(event.getUser()).getRoles())
+        {
+            if(!DiscordWhitelister.useIdForRoles)
+            {
+                if (Arrays.stream(DiscordClient.allowedToAddLimitedRoles).parallel().anyMatch(role.getName()::equalsIgnoreCase))
+                {
+                    userHasLimitedAdd = true;
+                    break;
+                }
+            }
+            else
+            {
+                if (Arrays.stream(DiscordClient.allowedToAddLimitedRoles).parallel().anyMatch(role.getId()::equalsIgnoreCase))
+                {
+                    userHasLimitedAdd = true;
+                    break;
+                }
+            }
+        }
+
+        if(DiscordWhitelister.useOnBanEvents)
+        {
+            for(Role role : event.getGuild().getMember(event.getUser()).getRoles())
+            {
+                if(!DiscordWhitelister.useIdForRoles)
+                {
+                    if (Arrays.stream(DiscordWhitelister.bannedRoles).parallel().anyMatch(role.getName()::equalsIgnoreCase))
+                    {
+                        userIsBanned = true;
+                        break;
+                    }
+                }
+                else
+                {
+                    if (Arrays.stream(DiscordWhitelister.bannedRoles).parallel().anyMatch(role.getId()::equalsIgnoreCase))
+                    {
+                        userIsBanned = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        for(Role role : event.getGuild().getMember(event.getUser()).getRoles())
+        {
+            if(!DiscordWhitelister.useIdForRoles)
+            {
+                if(Arrays.stream(DiscordClient.allowedToClearNamesRoles).parallel().anyMatch(role.getName()::equalsIgnoreCase))
+                {
+                    userCanUseClear = true;
+                    break;
+                }
+            }
+            else
+            {
+                if(Arrays.stream(DiscordClient.allowedToClearNamesRoles).parallel().anyMatch(role.getId()::equalsIgnoreCase))
+                {
+                    userCanUseClear = true;
+                    break;
+                }
+            }
+        }
+    }
+
     public boolean isUserCanAddRemove() {
         return userCanAddRemove;
     }

src/main/java/uk/co/angrybee/joe/DiscordWhitelister.java

@@ -21,7 +21,10 @@ import uk.co.angrybee.joe.events.EssentialsVanishEvents;
 import uk.co.angrybee.joe.events.SuperVanishEvents;
 import uk.co.angrybee.joe.events.VanishNoPacketEvents;
 
+import java.lang.reflect.Array;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.logging.Logger;
 import java.util.stream.Stream;
 
@@ -138,6 +141,14 @@ public class DiscordWhitelister extends JavaPlugin {
         return thisPlugin.getServer().getOnlinePlayers().size() - vanishedPlayersCount;
     }
 
+
+    static String[] getConfigArray(String path){
+        List<String> list = mainConfig.getFileConfiguration().getStringList(path);
+        String[] array = new String[list.size()];
+        list.toArray(array);
+        return array;
+    }
+
     public static int getMaximumAllowedPlayers() {
         return thisPlugin.getServer().getMaxPlayers();
     }
@@ -205,38 +216,29 @@ public class DiscordWhitelister extends JavaPlugin {
             // TODO: below role section could be moved to DiscordClient class
             useIdForRoles = mainConfig.getFileConfiguration().getBoolean("use-id-for-roles");
 
+
+
+
+
             // set add & remove roles
-            DiscordClient.allowedToAddRemoveRoles = new String[mainConfig.getFileConfiguration().getList("add-remove-roles").size()];
-            for (int roles = 0; roles < DiscordClient.allowedToAddRemoveRoles.length; ++roles) {
-                DiscordClient.allowedToAddRemoveRoles[roles] = mainConfig.getFileConfiguration().getList("add-remove-roles").get(roles).toString();
-            }
+            DiscordClient.allowedToAddRemoveRoles = getConfigArray("add-remove-roles");
+
 
             // set add roles
-            DiscordClient.allowedToAddRoles = new String[mainConfig.getFileConfiguration().getList("add-roles").size()];
-            for (int roles = 0; roles < DiscordClient.allowedToAddRoles.length; ++roles) {
-                DiscordClient.allowedToAddRoles[roles] = mainConfig.getFileConfiguration().getList("add-roles").get(roles).toString();
-            }
+            DiscordClient.allowedToAddRoles = getConfigArray("add-roles");
+
 
             // set limited add roles
-            DiscordClient.allowedToAddLimitedRoles = new String[mainConfig.getFileConfiguration().getList("limited-add-roles").size()];
-            for (int roles = 0; roles < DiscordClient.allowedToAddLimitedRoles.length; ++roles) {
-                DiscordClient.allowedToAddLimitedRoles[roles] = mainConfig.getFileConfiguration().getList("limited-add-roles").get(roles).toString();
-            }
+            DiscordClient.allowedToAddLimitedRoles = getConfigArray("limited-add-roles");
+
 
             // Get banned roles
             if (useOnBanEvents) {
-                List<String> tempBannedRoles = mainConfig.getFileConfiguration().getStringList("banned-roles");
-                bannedRoles = new String[tempBannedRoles.size()];
-                for (int i = 0; i < tempBannedRoles.size(); i++) {
-                    bannedRoles[i] = tempBannedRoles.get(i);
-                }
+                bannedRoles = getConfigArray("banned-roles");
             }
 
             // Allowed to clear name roles
-            DiscordClient.allowedToClearNamesRoles = new String[mainConfig.getFileConfiguration().getStringList("clear-command-roles").size()];
-            for (int roles = 0; roles < DiscordClient.allowedToClearNamesRoles.length; roles++) {
-                DiscordClient.allowedToClearNamesRoles[roles] = mainConfig.getFileConfiguration().getStringList("clear-command-roles").get(roles);
-            }
+            DiscordClient.allowedToClearNamesRoles = getConfigArray("clear-command-roles");
 
             // All roles combined for role check
             DiscordClient.combinedRoles = Stream.of(DiscordClient.allowedToAddRemoveRoles, DiscordClient.allowedToAddRoles,

src/main/java/uk/co/angrybee/joe/commands/discord/CommandClear.java

@@ -0,0 +1,119 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import uk.co.angrybee.joe.AuthorPermissions;
+import uk.co.angrybee.joe.DiscordClient;
+import uk.co.angrybee.joe.DiscordWhitelister;
+import uk.co.angrybee.joe.stores.UserList;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+public class CommandClear {
+    public static void ExecuteCommand(SlashCommandEvent event) {
+        // Clear whitelists for limited-whitelisters
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getTextChannel();
+
+        if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("allow-limited-whitelisters-to-unwhitelist-self")) {
+            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("This Command is disabled",
+                    "If staff members need to clear a name from the whitelist please use `/clearname <mcName>`.", DiscordClient.EmbedMessageType.INFO).build();
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+            return;
+        }
+        // just inform staff, can add custom messages later if really needed
+        if (authorPermissions.isUserCanAddRemove() && !authorPermissions.isUserIsBanned() || authorPermissions.isUserCanAdd() && !authorPermissions.isUserIsBanned()) {
+            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("This Command is Only Available for Limited Whitelister Roles",
+                    "If staff members need to clear a name from the whitelist please use `/clearname <mcName>`.", DiscordClient.EmbedMessageType.INFO).build();
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+            return;
+        }
+
+        if (authorPermissions.isUserHasLimitedAdd() && !authorPermissions.isUserIsBanned()) {
+            List<?> ls = UserList.getRegisteredUsers(author.getId());
+
+            // check for names whitelisted
+            if (ls != null) {
+                for (Object minecraftNameToRemove : ls) {
+                    DiscordClient.UnWhitelist(minecraftNameToRemove.toString());
+                }
+
+                try {
+                    UserList.resetRegisteredUsers(author.getId());
+                } catch (IOException e) {
+                    DiscordWhitelister.getPluginLogger().severe("Failed to remove" + author.getId() + "'s entries.");
+                    e.printStackTrace();
+                    return;
+                }
+
+                DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") triggered whitelist clear. " +
+                        "Successfully removed their whitelisted entries from the user list.");
+
+                // Log in Discord channel
+                if (!DiscordWhitelister.useCustomMessages) {
+                    StringBuilder message = new StringBuilder(author.getAsMention() + " successfully removed the following users from the whitelist: \n");
+                    for (Object minercaftName : ls) {
+                        message.append("- ").append(minercaftName.toString()).append("\n");
+                    }
+                    message.append("\n You now have **").append(DiscordClient.maxWhitelistAmount).append(" whitelist(s) remaining**.");
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(("Successfully Removed " + author.getName() + "'s Whitelisted Entries"),
+                            message.toString(), DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-clear-success-title");
+                    customTitle = customTitle.replaceAll("\\{Sender}", author.getName());
+
+                    StringBuilder removedNames = new StringBuilder();
+                    for (Object minercaftName : ls) {
+                        removedNames.append("- ").append(minercaftName.toString()).append("\n");
+                    }
+
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-clear-success-message");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{RemovedEntries}", removedNames.toString());
+                    customMessage = customMessage.replaceAll("\\{MaxWhitelistAmount}", String.valueOf(DiscordClient.maxWhitelistAmount));
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.SUCCESS).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+
+                if (DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("whitelisted-role-auto-remove")) {
+                    // Find all servers bot is in, remove whitelisted roles
+                    for (int i = 0; i < DiscordClient.javaDiscordAPI.getGuilds().size(); i++) {
+                        // Remove the whitelisted role(s)
+                        DiscordClient.RemoveRolesFromUser(DiscordClient.javaDiscordAPI.getGuilds().get(i), author.getId(), Arrays.asList(DiscordClient.whitelistedRoleNames));
+                    }
+                }
+            } else {
+                DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") triggered whitelist clear. " +
+                        "Could not remove any whitelisted entries as they do not have any.");
+
+                // Log in Discord channel
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("No Entries to Remove",
+                            (author.getAsMention() + ", you do not have any whitelisted entries to remove."), DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-clear-failure-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-clear-failure-message");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+            }
+            return;
+        }
+
+        if (!authorPermissions.isUserCanAddRemove() && !authorPermissions.isUserCanAdd() && !authorPermissions.isUserHasLimitedAdd() || authorPermissions.isUserIsBanned()) {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+        }
+
+    }
+}

src/main/java/uk/co/angrybee/joe/commands/discord/CommandClearban.java

@@ -0,0 +1,101 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import uk.co.angrybee.joe.AuthorPermissions;
+import uk.co.angrybee.joe.DiscordClient;
+import uk.co.angrybee.joe.DiscordWhitelister;
+import uk.co.angrybee.joe.stores.InGameRemovedList;
+import uk.co.angrybee.joe.stores.RemovedList;
+
+public class CommandClearban {
+    public static void ExecuteCommand(SlashCommandEvent event, String mc_user) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getTextChannel();
+
+
+        if (authorPermissions.isUserCanUseClear()) {
+            // Check if empty command
+/*
+                if (!hideInfoCommandReplies) {
+                    return;
+                }
+
+                // Send info message
+                if (!DiscordWhitelister.getUseCustomPrefixes()) {
+                    MessageEmbed messageEmbed = CreateEmbeddedMessage("Clear Ban Command", "Usage: `!clearban <minecraftUsername>`\n", DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    MessageEmbed messageEmbed = CreateEmbeddedMessage("Clear Ban Command", "Usage: `" + customClearBanPrefix + " <minecraftUsername>`\n", DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+
+                return;
+*/
+
+            // If command is not empty check for args
+            // String[] splitMessage = messageContents.toLowerCase().trim().split(" ");
+
+            // Check both removed lists for target name
+            boolean nameFoundInLists = false;
+
+            // Remove name from removed list if found
+            if (RemovedList.CheckStoreForPlayer(mc_user)) {
+                RemovedList.getRemovedPlayers().set(mc_user, null);
+                RemovedList.SaveStore();
+
+                nameFoundInLists = true;
+            }
+
+            if (InGameRemovedList.CheckStoreForPlayer(mc_user)) {
+                InGameRemovedList.RemoveUserFromStore(mc_user);
+
+                nameFoundInLists = true;
+            }
+
+            if (nameFoundInLists) {
+
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(("Successfully Cleared `" + mc_user + "`"),
+                            (author.getAsMention() + " has successfully cleared `" + mc_user + "` from the removed list(s)."), DiscordClient.EmbedMessageType.SUCCESS).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-ban-success-title");
+                    String customMessage = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-ban-success-message");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{MinecraftUsername}", mc_user);
+                    customTitle = customTitle.replaceAll("\\{MinecraftUsername}", mc_user);
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+
+            } else {
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(("Failed to Clear `" + mc_user + "`"),
+                            (author.getAsMention() + ", `" + mc_user + "` cannot be found in any of the removed lists!"), DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-ban-failure-title");
+                    String customMessage = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-ban-failure-message");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{MinecraftUsername}", mc_user);
+                    customTitle = customTitle.replaceAll("\\{MinecraftUsername}", mc_user);
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+
+            }
+        } else {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+        }
+    }
+}
+

src/main/java/uk/co/angrybee/joe/commands/discord/CommandClearname.java

@@ -0,0 +1,120 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import uk.co.angrybee.joe.AuthorPermissions;
+import uk.co.angrybee.joe.DiscordClient;
+import uk.co.angrybee.joe.DiscordWhitelister;
+import uk.co.angrybee.joe.stores.UserList;
+
+import java.util.List;
+import java.util.Set;
+
+public class CommandClearname {
+    public static void ExecuteCommand(SlashCommandEvent event, String mc_name) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+
+        // Clear Whitelists command
+        // /clearname <targetName>
+
+
+        // Check permissions
+        if (!authorPermissions.isUserCanUseClear()) {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+            return;
+        }  // Don't have permission
+
+
+
+        /*
+                if (DiscordClient.hideInfoCommandReplies) {
+            return;
+        }
+        MessageEmbed messageEmbed;
+
+        if (!DiscordWhitelister.getUseCustomPrefixes()) {
+            messageEmbed = DiscordClient.CreateEmbeddedMessage("Clear Name Command", "Usage: `/clearname <minecraftUsername>`\n", DiscordClient.EmbedMessageType.INFO).build();
+        } else {
+            messageEmbed = DiscordClient.CreateEmbeddedMessage("Clear Name Command", "Usage: `" + DiscordClient.customClearNamePrefix + " <minecraftUsername>`\n", DiscordClient.EmbedMessageType.INFO).build();
+        }
+        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+
+        return;
+*/
+
+
+        DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") attempted to clear " + mc_name + " from the whitelist");
+
+        // Search for target name & linked ID
+        boolean nameFound = false;
+        String targetDiscordId = "";
+        Set<String> keys = UserList.getUserList().getKeys(false);
+        // Make sure the user list is not empty
+        if (keys.size() > 0) {
+            for (String userid : keys) {
+                List<?> registeredUsers = UserList.getRegisteredUsers(userid);
+                if (registeredUsers.contains(mc_name)) {
+                    nameFound = true;
+                    targetDiscordId = userid;
+                    if (registeredUsers.size() > 1) {
+                        registeredUsers.remove(mc_name); // Clear name
+                        // Set the updated list in the config
+                        UserList.getUserList().set(userid, registeredUsers);
+                    } else { // Remove entirely
+
+                        UserList.getUserList().set(userid, null);
+                    }
+                    UserList.SaveStore();
+                    if (DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("unwhitelist-and-clear-perms-on-name-clear")) {
+                        // Remove name from the whitelist
+                        DiscordClient.UnWhitelist(mc_name);
+                    }
+                    break;
+                }
+            }
+        }
+        MessageEmbed messageEmbed;
+        if (nameFound) {
+            // Success message
+            if (DiscordWhitelister.useCustomMessages) {
+                String clearNameTitle = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-name-success-title");
+                String clearNameMessage = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-name-success-message");
+
+                clearNameMessage = clearNameMessage.replaceAll("\\{Sender}", author.getAsMention());
+                clearNameMessage = clearNameMessage.replaceAll("\\{MinecraftUsername}", mc_name);
+                clearNameMessage = clearNameMessage.replaceAll("\\{DiscordID}", "<@" + targetDiscordId + ">");
+
+                clearNameTitle = clearNameTitle.replaceAll("\\{MinecraftUsername}", mc_name);
+                messageEmbed = DiscordClient.CreateEmbeddedMessage(clearNameTitle, clearNameMessage, DiscordClient.EmbedMessageType.SUCCESS).build();
+            } else {
+                messageEmbed = DiscordClient.CreateEmbeddedMessage("Successfully Cleared Name", (author.getAsMention() + " successfully cleared username `" + mc_name +
+                        "` from <@" + targetDiscordId + ">'s whitelisted users."), DiscordClient.EmbedMessageType.SUCCESS).build();
+            }
+
+        } else {
+            // Name not found
+            if (!DiscordWhitelister.useCustomMessages) {
+
+                messageEmbed =
+                        DiscordClient.CreateEmbeddedMessage((mc_name + " not Found"),
+                                (author.getAsMention() + ", could not find name " + mc_name + " to clear in user list."), DiscordClient.EmbedMessageType.FAILURE).build();
+            } else {
+                String customTitle = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-name-failure-title");
+                String customMessage = DiscordWhitelister.customMessagesConfig.getFileConfiguration().getString("clear-name-failure-message");
+                customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                customMessage = customMessage.replaceAll("\\{MinecraftUsername}", mc_name);
+                customTitle = customTitle.replaceAll("\\{MinecraftUsername}", mc_name);
+
+                messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE).build();
+            }
+
+        }
+        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+    }
+
+}

src/main/java/uk/co/angrybee/joe/commands/discord/CommandInfo.java

@@ -2,25 +2,26 @@ package uk.co.angrybee.joe.commands.discord;
 
 import net.dv8tion.jda.api.entities.TextChannel;
 import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import uk.co.angrybee.joe.AuthorPermissions;
 import uk.co.angrybee.joe.DiscordClient;
 
 public class CommandInfo
 {
-    public static void ExecuteCommand(MessageReceivedEvent messageReceivedEvent)
+    public static void ExecuteCommand(SlashCommandEvent event)
     {
-        AuthorPermissions authorPermissions = new AuthorPermissions(messageReceivedEvent);
-        User author = messageReceivedEvent.getAuthor();
-        TextChannel channel = messageReceivedEvent.getTextChannel();
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
 
         if (authorPermissions.isUserCanUseCommand())
         {
-            DiscordClient.QueueAndRemoveAfterSeconds(channel, DiscordClient.botInfo);
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.botInfo);
         }
         else
         {
-            DiscordClient.QueueAndRemoveAfterSeconds(channel, DiscordClient.CreateInsufficientPermsMessage(author));
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
         }
+        
     }
 }

src/main/java/uk/co/angrybee/joe/commands/discord/CommandRemove.java

@@ -1,6 +1,200 @@
 package uk.co.angrybee.joe.commands.discord;
 
-public class CommandRemove
-{
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import uk.co.angrybee.joe.AuthorPermissions;
+import uk.co.angrybee.joe.DiscordClient;
+import uk.co.angrybee.joe.DiscordWhitelister;
+import uk.co.angrybee.joe.stores.RemovedList;
+import uk.co.angrybee.joe.stores.UserList;
+import uk.co.angrybee.joe.stores.WhitelistedPlayers;
 
-}
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+public class CommandRemove {
+
+    public static void ExecuteCommand(SlashCommandEvent event, String mc_name) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getTextChannel();
+        Member member = event.getMember();
+
+        // Remove Command
+        if (authorPermissions.isUserCanAddRemove()) {
+
+
+            final String finalNameToRemove = mc_name.replaceAll(" .*", ""); // The name is everything up to the first space
+
+            if (finalNameToRemove.isEmpty()) {
+                if (!DiscordClient.hideInfoCommandReplies)
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.removeCommandInfo);
+                return;
+            } else {
+                DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") attempted to remove " + finalNameToRemove + " from the whitelist");
+
+                boolean notOnWhitelist = false;
+
+                if (WhitelistedPlayers.usingEasyWhitelist && !WhitelistedPlayers.CheckForPlayerEasyWhitelist(finalNameToRemove) || !WhitelistedPlayers.usingEasyWhitelist && !WhitelistedPlayers.CheckForPlayer(finalNameToRemove)) {
+                    notOnWhitelist = true;
+
+                    if (!DiscordWhitelister.useCustomMessages) {
+                        MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("This user is not on the whitelist",
+                                (author.getAsMention() + ", cannot remove user as `" + finalNameToRemove + "` is not on the whitelist!"), DiscordClient.EmbedMessageType.INFO).build();
+                        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                        // Return below
+                    } else {
+                        String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("user-not-on-whitelist-title");
+                        String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("user-not-on-whitelist");
+                        customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                        customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToRemove);
+
+                        MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO).build();
+                        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                    }
+                }
+
+                // not not on whitelist, nice
+                if (!notOnWhitelist) // aka on the whitelist
+                {
+                    DiscordClient.UnWhitelist(finalNameToRemove);
+                    // Configure message here instead of on the main thread - this means this will run even if the message is never sent, but is a good trade off (I think)
+                    EmbedBuilder embedBuilderSuccess;
+
+                    if (!DiscordWhitelister.useCustomMessages) {
+                        if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("set-removed-message-colour-to-red"))
+                            embedBuilderSuccess = DiscordClient.CreateEmbeddedMessage((finalNameToRemove + " has been removed"), (author.getAsMention() + " has removed `" + finalNameToRemove + "` from the whitelist."), DiscordClient.EmbedMessageType.SUCCESS);
+                        else
+                            embedBuilderSuccess = DiscordClient.CreateEmbeddedMessage((finalNameToRemove + " has been removed"), (author.getAsMention() + " has removed `" + finalNameToRemove + "` from the whitelist."), DiscordClient.EmbedMessageType.FAILURE);
+                    } else {
+                        String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("remove-success-title");
+                        customTitle = customTitle.replaceAll("\\{MinecraftUsername}", finalNameToRemove);
+
+                        String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("remove-success");
+                        customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                        customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToRemove);
+
+                        if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("set-removed-message-colour-to-red"))
+                            embedBuilderSuccess = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.SUCCESS);
+                        else
+                            embedBuilderSuccess = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                    }
+
+                    if (DiscordWhitelister.showPlayerSkin) {
+                        String playerUUID = DiscordClient.minecraftUsernameToUUID(finalNameToRemove);
+
+                        if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-crafatar-for-avatars"))
+                            embedBuilderSuccess.setThumbnail("https://minotar.net/armor/bust/" + playerUUID + "/100.png");
+                        else
+                            embedBuilderSuccess.setThumbnail("https://crafatar.com/avatars/" + playerUUID + "?size=100&default=MHF_Steve&overlay.png");
+                    }
+
+                    EmbedBuilder embedBuilderFailure;
+
+                    // No custom message needed
+                    embedBuilderFailure = DiscordClient.CreateEmbeddedMessage(("Failed to remove " + finalNameToRemove + " from the whitelist"), (author.getAsMention() + ", failed to remove `" + finalNameToRemove + "` from the whitelist. " +
+                            "This should never happen, you may have to remove the player manually and report the issue."), DiscordClient.EmbedMessageType.FAILURE);
+
+                    DiscordWhitelister.getPlugin().getServer().getScheduler().callSyncMethod(DiscordWhitelister.getPlugin(), () ->
+                    {
+                        if (WhitelistedPlayers.usingEasyWhitelist && !WhitelistedPlayers.CheckForPlayerEasyWhitelist(finalNameToRemove)
+                                || !WhitelistedPlayers.usingEasyWhitelist && !WhitelistedPlayers.CheckForPlayer(finalNameToRemove)) {
+                            event.replyEmbeds(embedBuilderSuccess.build()).queue();
+
+                            if (DiscordClient.whitelistedRoleAutoRemove) {
+                                List<String> whitelistRoles = new LinkedList<>();
+
+                                Collections.addAll(whitelistRoles, DiscordClient.whitelistedRoleNames);
+
+                                // Find the Discord Id linked to the removed name
+                                boolean idFound = false;
+                                String targetDiscordId = "";
+                                Set<String> keys = UserList.getUserList().getKeys(false);
+                                for (String userId : keys) {
+                                    List<?> registeredUsers = UserList.getRegisteredUsers(userId);
+                                    for (Object wUser : registeredUsers) {
+                                        if (wUser.equals(finalNameToRemove)) {
+                                            // Found the ban target, assign the corresponding Discord id
+                                            targetDiscordId = userId;
+                                            boolean namesRemainingAfterRemoval = false;
+
+                                            if ((registeredUsers.size() - 1) > 0) {
+                                                namesRemainingAfterRemoval = true;
+                                                DiscordWhitelister.getPluginLogger().info("The Discord ID (" + targetDiscordId + ") linked to " + finalNameToRemove + " contains "
+                                                        + (registeredUsers.size() - 1) + " more whitelisted user(s), not removing whitelisted roles...");
+                                            }
+
+                                            // Find all servers bot is in, remove whitelisted roles
+                                            if (!whitelistRoles.isEmpty() && !namesRemainingAfterRemoval) {
+                                                for (Guild guild : DiscordClient.javaDiscordAPI.getGuilds()) {
+                                                    // Remove the whitelisted role(s)
+                                                    DiscordClient.RemoveRolesFromUser(guild, targetDiscordId, whitelistRoles);
+                                                    DiscordWhitelister.getPluginLogger().info("Successfully removed whitelisted roles from "
+                                                            + targetDiscordId + "(" + finalNameToRemove + ") in guild: " + guild.getName());
+                                                }
+                                            } else if (whitelistRoles.isEmpty()) {
+                                                DiscordWhitelister.getPluginLogger().warning("Cannot remove any whitelisted roles from: " + targetDiscordId + "(" + finalNameToRemove + ") as there are none specified in the config");
+                                            }
+                                            idFound = true;
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                if (!idFound) {
+                                    DiscordWhitelister.getPluginLogger().warning("Could not find any Discord id linked to Minecraft name: " + finalNameToRemove + ", therefore cannot remove any roles");
+                                }
+                                DiscordClient.ClearPlayerFromUserList(finalNameToRemove);
+                            }
+
+                            // if the name is not on the removed list
+                            if (!RemovedList.CheckStoreForPlayer(finalNameToRemove)) {
+                                RemovedList.getRemovedPlayers().set(finalNameToRemove, author.getId());
+                                RemovedList.SaveStore();
+                            }
+                        } else {
+                            DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderFailure.build());
+                        }
+
+                        return null;
+                    });
+                    return;
+                }
+                return;
+            }
+
+        }
+
+        if (authorPermissions.isUserCanAdd() && !authorPermissions.isUserCanAddRemove()) {
+            String higherPermRoles = DiscordWhitelister.mainConfig.getFileConfiguration().getList("add-remove-roles").toString();
+            higherPermRoles = higherPermRoles.replaceAll("\\[", "");
+            higherPermRoles = higherPermRoles.replaceAll("]", "");
+
+            EmbedBuilder embedBuilderInfo;
+
+            if (!DiscordWhitelister.useCustomMessages) {
+                embedBuilderInfo = DiscordClient.CreateEmbeddedMessage("Insufficient Permissions", (author.getAsMention() + ", you only have permission to add people to the whitelist. To remove people from the whitelist you must be moved to the following roles: "
+                        + higherPermRoles + "; or get the owner to move your role to 'add-remove-roles' in the config."), DiscordClient.EmbedMessageType.INFO);
+            } else {
+                String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("insufficient-permissions-remove-title");
+                String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("insufficient-permissions-remove");
+                customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                customMessage = customMessage.replaceAll("\\{AddRemoveRoles}", higherPermRoles);
+
+                embedBuilderInfo = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO);
+            }
+
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderInfo.build());
+            return;
+        }
+
+        // if the user doesn't have any allowed roles
+        DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+        //TempRemoveOriginalMessageAfterSeconds(messageReceivedEvent);
+    }
+
+}

src/main/java/uk/co/angrybee/joe/commands/discord/CommandWhoIs.java

@@ -1,8 +1,8 @@
 package uk.co.angrybee.joe.commands.discord;
 
-import com.sun.org.apache.xpath.internal.operations.Bool;
 import net.dv8tion.jda.api.EmbedBuilder;
 import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import net.dv8tion.jda.api.exceptions.AccountTypeException;
 import org.yaml.snakeyaml.Yaml;
@@ -19,68 +19,45 @@ import java.util.*;
 import java.util.concurrent.TimeUnit;
 
 public class CommandWhoIs {
-    public static void ExecuteCommand(MessageReceivedEvent messageReceivedEvent, String[] splitMessage) {
-        AuthorPermissions authorPermissions = new AuthorPermissions(messageReceivedEvent);
-        User author = messageReceivedEvent.getAuthor();
-        TextChannel channel = messageReceivedEvent.getTextChannel();
+    public static void ExecuteCommand(SlashCommandEvent event, String mc_name) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getTextChannel();
 
         if (!authorPermissions.isUserCanAddRemove() && !authorPermissions.isUserCanAdd()) {
-            DiscordClient.QueueAndRemoveAfterSeconds(channel, DiscordClient.CreateInsufficientPermsMessage(author));
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
             return;
         }
-
-        // TODO make 1 function like this that multiple commands can call on
-        if (DiscordWhitelister.getUseCustomPrefixes() && splitMessage.length > (DiscordClient.customWhoIsPrefix.length + 1)
-                || !DiscordWhitelister.getUseCustomPrefixes() && splitMessage.length > (DiscordClient.whitelistWhoIsPrefix.length + 1)) {
-            int amountOfArgs = 0;
-            if (DiscordWhitelister.getUseCustomPrefixes())
-                amountOfArgs = splitMessage.length - (DiscordClient.customWhoIsPrefix.length);
-            else
-                amountOfArgs = splitMessage.length - (DiscordClient.whitelistWhoIsPrefix.length);
-
-            StringBuilder exampleCommand = new StringBuilder();
-            if (DiscordWhitelister.getUseCustomPrefixes()) {
-                for (int i = 0; i < DiscordClient.customWhoIsPrefix.length; i++) {
-                    exampleCommand.append(DiscordClient.customWhoIsPrefix[i]).append(" ");
-                }
-            } else {
-                for (int i = 0; i < DiscordClient.whitelistWhoIsPrefix.length; i++) {
-                    exampleCommand.append(DiscordClient.whitelistWhoIsPrefix[i]).append(" ");
-                }
+/*
+        int amountOfArgs = 0;
+        StringBuilder exampleCommand = new StringBuilder();
+        if (DiscordWhitelister.getUseCustomPrefixes()) {
+            for (int i = 0; i < DiscordClient.customWhoIsPrefix.length; i++) {
+                exampleCommand.append(DiscordClient.customWhoIsPrefix[i]).append(" ");
+            }
+        } else {
+            for (int i = 0; i < DiscordClient.whitelistWhoIsPrefix.length; i++) {
+                exampleCommand.append(DiscordClient.whitelistWhoIsPrefix[i]).append(" ");
             }
-            exampleCommand.append("<minecraftUsername>");
-
-            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("Too many arguments",
-                    (author.getAsMention() + ", expected 1 argument but found " + amountOfArgs + ".\n" +
-                            "Example: " + exampleCommand.toString()), DiscordClient.EmbedMessageType.FAILURE).build();
-
-            DiscordClient.QueueAndRemoveAfterSeconds(channel, messageEmbed);
-            return;
         }
+        exampleCommand.append("<minecraftUsername>");
 
-        String nameToCheck = "";
-        if (DiscordWhitelister.getUseCustomPrefixes() && splitMessage.length >= DiscordClient.customWhoIsPrefix.length + 1)
-            nameToCheck = splitMessage[DiscordClient.customWhoIsPrefix.length];
+        MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("Too many arguments",
+                (author.getAsMention() + ", expected 1 argument but found " + amountOfArgs + ".\n" +
+                        "Example: " + exampleCommand.toString()), DiscordClient.EmbedMessageType.FAILURE).build();
 
-        if (!DiscordWhitelister.getUseCustomPrefixes() && splitMessage.length >= DiscordClient.whitelistWhoIsPrefix.length + 1)
-            nameToCheck = splitMessage[DiscordClient.whitelistWhoIsPrefix.length];
-
-        if (DiscordWhitelister.getUseCustomPrefixes() && splitMessage.length == DiscordClient.customWhoIsPrefix.length
-                || !DiscordWhitelister.getUseCustomPrefixes() && splitMessage.length == DiscordClient.whitelistWhoIsPrefix.length || nameToCheck.isEmpty()) {
-            if (!DiscordClient.hideInfoCommandReplies)
-                return;
-
-            DiscordClient.QueueAndRemoveAfterSeconds(channel, DiscordClient.whoIsInfo);
-            return;
-        }
+        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+*/
 
         boolean idFound = false;
         // Find the Discord Id linked to the whitelisted player
         Set<String> keys = UserList.getUserList().getKeys(false);
-        for (String discordId : keys) {
+        for (
+                String discordId : keys) {
             List<?> registeredUsers = UserList.getRegisteredUsers(discordId);
-            for (Object mc_name : registeredUsers) {
-                if (mc_name.equals(nameToCheck)) {
+            for (Object name : registeredUsers) {
+                if (name.equals(mc_name)) {
                     String userAsMention = "<@!" + discordId + ">"; // use this in-case the user has left the discord ? over using fetched member
                     StringBuilder usersWhitelistedPlayers = new StringBuilder();
                     for (Object targetWhitelistedPlayer : registeredUsers) {
@@ -88,8 +65,8 @@ public class CommandWhoIs {
                             usersWhitelistedPlayers.append("- ").append((String) targetWhitelistedPlayer).append("\n");
                     }
 
-                    EmbedBuilder idFoundMessage = DiscordClient.CreateEmbeddedMessage(("Found account linked to `" + nameToCheck + "`"),
-                            (author.getAsMention() + ", the Minecraft username: `" + nameToCheck + "` is linked to " + userAsMention +
+                    EmbedBuilder idFoundMessage = DiscordClient.CreateEmbeddedMessage(("Found account linked to `" + mc_name + "`"),
+                            (author.getAsMention() + ", the Minecraft username: `" + mc_name + "` is linked to " + userAsMention +
                                     ".\n\n Here is a list of their whitelisted players:\n" + usersWhitelistedPlayers),
                             DiscordClient.EmbedMessageType.SUCCESS);
 
@@ -100,19 +77,19 @@ public class CommandWhoIs {
                     else
                         DiscordWhitelister.getPluginLogger().warning("Failed to fetch avatar linked to Discord ID: " + discordId);
 
-                    DiscordClient.QueueAndRemoveAfterSeconds(channel, idFoundMessage.build());
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, idFoundMessage.build());
                     idFound = true;
                     break;
                 }
             }
         }
         if (!idFound) {
-            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(("Could not find an account linked to `" + nameToCheck + "`"),
-                    (author.getAsMention() + ", the name: `" + nameToCheck +
+            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(("Could not find an account linked to `" + mc_name + "`"),
+                    (author.getAsMention() + ", the name: `" + mc_name +
                             "` could not be found in the users list. Please make sure that the Minecraft name is valid and whitelisted + linked to an ID before."),
                     DiscordClient.EmbedMessageType.FAILURE).build();
 
-            DiscordClient.QueueAndRemoveAfterSeconds(channel, messageEmbed);
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
         }
     }
 }

src/main/java/uk/co/angrybee/joe/commands/discord/CommandWhoIsDiscord.java

@@ -0,0 +1,79 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import uk.co.angrybee.joe.AuthorPermissions;
+import uk.co.angrybee.joe.DiscordClient;
+import uk.co.angrybee.joe.DiscordWhitelister;
+import uk.co.angrybee.joe.stores.UserList;
+
+import java.util.List;
+import java.util.Set;
+
+public class CommandWhoIsDiscord {
+    public static void ExecuteCommand(SlashCommandEvent event, Member target) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+
+        if (!authorPermissions.isUserCanAddRemove() && !authorPermissions.isUserCanAdd()) {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+            return;
+        }
+/*
+        int amountOfArgs = 0;
+        StringBuilder exampleCommand = new StringBuilder();
+        if (DiscordWhitelister.getUseCustomPrefixes()) {
+            for (int i = 0; i < DiscordClient.customWhoIsPrefix.length; i++) {
+                exampleCommand.append(DiscordClient.customWhoIsPrefix[i]).append(" ");
+            }
+        } else {
+            for (int i = 0; i < DiscordClient.whitelistWhoIsPrefix.length; i++) {
+                exampleCommand.append(DiscordClient.whitelistWhoIsPrefix[i]).append(" ");
+            }
+        }
+        exampleCommand.append("<minecraftUsername>");
+
+        MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("Too many arguments",
+                (author.getAsMention() + ", expected 1 argument but found " + amountOfArgs + ".\n" +
+                        "Example: " + exampleCommand.toString()), DiscordClient.EmbedMessageType.FAILURE).build();
+
+        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+*/
+
+        boolean idFound = false;
+        // Find the Discord Id linked to the whitelisted player
+        Set<String> keys = UserList.getUserList().getKeys(false);
+        String userAsMention = "<@!" + target.getId() + ">"; // use this in-case the user has left the discord ? over using fetched member
+        for (String discordId : keys) {
+            if (discordId.equals(target.getId())) {
+                List<?> registeredUsers = UserList.getRegisteredUsers(discordId);
+                StringBuilder usersWhitelistedPlayers = new StringBuilder();
+                for (Object targetWhitelistedPlayer : registeredUsers) {
+                    if (targetWhitelistedPlayer instanceof String)
+                        usersWhitelistedPlayers.append("- ").append((String) targetWhitelistedPlayer).append("\n");
+                }
+
+                EmbedBuilder idFoundMessage = DiscordClient.CreateEmbeddedMessage(("Found usernames linked to " + userAsMention),
+                        (author.getAsMention() + ", the user " + userAsMention + " has the following usernames linked to their account:\n" + usersWhitelistedPlayers),
+                        DiscordClient.EmbedMessageType.SUCCESS);
+
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, idFoundMessage.build());
+                return;
+
+
+            }
+        }
+        MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(("Could not find an usernames linked to " + target.getEffectiveName()),
+                (author.getAsMention() + ", the user " + userAsMention +
+                        " could not be found in the users list."),
+                DiscordClient.EmbedMessageType.FAILURE).build();
+
+        DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+
+    }
+}

src/main/java/uk/co/angrybee/joe/configs/CustomMessagesConfig.java

@@ -89,7 +89,7 @@ public class CustomMessagesConfig extends Config
             CheckEntry("clear-ban-failure-message", "{Sender}, `{MinecraftUsername}` cannot be found in any of the removed lists!");
 
             CheckEntry("instructional-message-title", "How to Whitelist");
-            CheckEntry("instructional-message", "Use `!whitelist add <minecraftUsername>` to whitelist yourself. In the case of whitelisting an incorrect name, please contact a staff member to clear it from the whitelist.");
+            CheckEntry("instructional-message", "Use `/whitelist add <minecraftUsername>` to whitelist yourself. In the case of whitelisting an incorrect name, please contact a staff member to clear it from the whitelist.");
 
             CheckEntry("whitelist-clear-success-title",  "Successfully Removed {Sender}'s Whitelisted Entries");
             CheckEntry("whitelist-clear-success-message", "{Sender} successfully removed the following users from the whitelist: \n{RemovedEntries}\nYou now have **{MaxWhitelistAmount} whitelist(s) remaining**.");

src/main/java/uk/co/angrybee/joe/configs/CustomPrefixConfig.java

@@ -31,17 +31,17 @@ public class CustomPrefixConfig extends Config
     {
         if(file.exists())
         {
-            CheckEntry("whitelist-add-prefix", "!whitelist add");
+            CheckEntry("whitelist-add-prefix", "/whitelist add");
 
-            CheckEntry("whitelist-remove-prefix", "!whitelist remove");
+            CheckEntry("whitelist-remove-prefix", "/whitelist remove");
 
-            CheckEntry("clear-name-prefix", "!clearname");
+            CheckEntry("clear-name-prefix", "/clearname");
 
-            CheckEntry("limited-whitelist-clear-prefix", "!whitelist clear");
+            CheckEntry("limited-whitelist-clear-prefix", "/whitelist clear");
 
             CheckEntry("clear-ban-prefix", "!clearban");
 
-            CheckEntry("whitelist-whois-prefix", "!whitelist whois");
+            CheckEntry("whitelist-whois-prefix", "/whitelist whois");
         }
     }
 }