Notify user to enable MESSAGE_CONTENT intent

Add support for target-text-channels for Slash Commands

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '38 6 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Joe Shimell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -15,9 +15,9 @@ A simple spigot plugin which allows whitelisting through a discord text channel.
 	- Can be disabled in the config (enabled by default)
 
 - Discord commands:
-    - Use `!whitelist add "minecraftUsername"` in a valid channel to whitelist people on your minecraft server
-    - Use `!whitelist remove "minecraftUsername"` in a valid channel to remove people from the whitelist on your minecraft server
-    - Use `!whitelist` in a valid channel to get info about the bot and how to use it
+    - Use `/whitelist add "minecraftUsername"` in a valid channel to whitelist people on your minecraft server
+    - Use `/whitelist remove "minecraftUsername"` in a valid channel to remove people from the whitelist on your minecraft server
+    - Use `/whitelist` in a valid channel to get info about the bot and how to use it
     
 - Custom Message Support:
     - Allows editing of server response messages (file is located at `(server-root)/plugins/DiscordWhitelister/custom-messages.yml)`

pom.xml

@@ -6,15 +6,13 @@
 
   <groupId>uk.co.angrybee.joe</groupId>
   <artifactId>discord-whitelister</artifactId>
-  <version>1.4.2</version>
+  <version>1.5.1</version>
 
   <name>discord-whitelister</name>
   <url>https://github.com/JoeShimell/DiscordWhitelisterSpigot</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>1.8</maven.compiler.source>
-    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
 
   <repositories>
@@ -24,13 +22,22 @@
     </repository>
 
     <repository>
-      <snapshots>
-        <enabled>false</enabled>
-      </snapshots>
-      <id>bintray-dv8fromtheworld-maven</id>
-      <name>bintray</name>
-      <url>https://dl.bintray.com/dv8fromtheworld/maven</url>
+      <id>dv8tion</id>
+      <name>m2-dv8tion</name>
+      <url>https://m2.dv8tion.net/releases</url>
     </repository>
+
+    <!-- JitPack - for Github repos -->
+    <repository>
+      <id>jitpack.io</id>
+      <url>https://jitpack.io</url>
+    </repository>
+
+    <repository>
+      <id>essentials-releases</id>
+      <url>https://repo.essentialsx.net/releases/</url>
+    </repository>
+
   </repositories>
 
 
@@ -38,14 +45,14 @@
     <dependency>
       <groupId>org.spigotmc</groupId>
       <artifactId>spigot-api</artifactId>
-      <version>1.16.3-R0.1-SNAPSHOT</version>
+      <version>1.20.4-R0.1-SNAPSHOT</version>
       <scope>provided</scope>
     </dependency>
 
     <dependency>
       <groupId>net.dv8tion</groupId>
       <artifactId>JDA</artifactId>
-      <version>4.2.0_211</version>
+      <version>5.0.0-beta.19</version>
       <exclusions>
         <exclusion>
           <groupId>club.minnced</groupId>
@@ -54,30 +61,80 @@
       </exclusions>
     </dependency>
 
-    <dependency>
-      <groupId>com.googlecode.json-simple</groupId>
-      <artifactId>json-simple</artifactId>
-      <version>1.1.1</version>
-    </dependency>
+<!--    <dependency>-->
+<!--      <groupId>com.googlecode.json-simple</groupId>-->
+<!--      <artifactId>json-simple</artifactId>-->
+<!--      <version>1.1.1</version>-->
+<!--    </dependency>-->
+
+<!--    <dependency>-->
+<!--      <groupId>ch.qos.logback</groupId>-->
+<!--      <artifactId>logback-classic</artifactId>-->
+<!--      <version>1.4.14</version>-->
+<!--    </dependency>-->
 
     <dependency>
       <groupId>ch.qos.logback</groupId>
-      <artifactId>logback-classic</artifactId>
-      <version>1.2.3</version>
+      <artifactId>logback-core</artifactId>
+      <version>1.4.14</version>
     </dependency>
 
+<!--    <dependency>-->
+<!--      <groupId>org.slf4j</groupId>-->
+<!--      <artifactId>slf4j-api</artifactId>-->
+<!--      <version>2.0.10</version>-->
+<!--    </dependency>-->
+
     <dependency>
       <groupId>org.yaml</groupId>
       <artifactId>snakeyaml</artifactId>
-      <version>1.26</version>
+      <version>2.2</version>
     </dependency>
 
     <dependency>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-shade-plugin</artifactId>
-      <version>3.2.4</version>
+      <version>3.5.1</version>
       <type>maven-plugin</type>
     </dependency>
+
+    <!-- SuperVanish -->
+    <dependency>
+      <groupId>com.github.LeonMangler</groupId>
+      <artifactId>SuperVanish</artifactId>
+      <!-- POM is invalid with java compiler ver > 8 (maven-compiler-plugin source & target version is set to 8) -->
+      <version>fbc303bbee6e129e56b3e89c5e83e98ee2127ff2</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <!-- EssX-->
+    <dependency>
+      <groupId>net.essentialsx</groupId>
+      <artifactId>EssentialsX</artifactId>
+      <version>2.20.1</version>
+      <scope>provided</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>org.bstats</groupId>
+          <artifactId>bstats-bukkit</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+
+    <!-- VanishNoPacket -->
+    <dependency>
+      <groupId>com.github.mbax</groupId>
+      <artifactId>VanishNoPacket</artifactId>
+      <version>341a9a9710848d85813f7dfdab0b606d46ab264a</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>com.google.code.gson</groupId>
+      <artifactId>gson</artifactId>
+      <version>2.10.1</version>
+    </dependency>
+
   </dependencies>
 
   <build>
@@ -85,54 +142,54 @@
       <plugins>
         <plugin>
           <artifactId>maven-clean-plugin</artifactId>
-          <version>3.1.0</version>
+          <version>3.3.2</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-resources-plugin</artifactId>
-          <version>3.0.2</version>
+          <version>3.3.1</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
-          <version>3.8.0</version>
+          <version>3.12.1</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-surefire-plugin</artifactId>
-          <version>2.22.1</version>
+          <version>3.2.5</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-jar-plugin</artifactId>
-          <version>3.0.2</version>
+          <version>3.3.0</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-install-plugin</artifactId>
-          <version>2.5.2</version>
+          <version>3.1.1</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-deploy-plugin</artifactId>
-          <version>2.8.2</version>
+          <version>3.1.1</version>
         </plugin>
 
 
         <plugin>
           <artifactId>maven-site-plugin</artifactId>
-          <version>3.7.1</version>
+          <version>4.0.0-M13</version>
         </plugin>
 
         <plugin>
           <artifactId>maven-project-info-reports-plugin</artifactId>
-          <version>3.0.0</version>
+          <version>3.5.0</version>
         </plugin>
 
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-shade-plugin</artifactId>
-          <version>3.2.4</version>
+          <version>3.5.1</version>
           <executions>
             <execution>
               <phase>package</phase>
@@ -165,21 +222,16 @@
                 <shadedPattern>uk.co.angrybee.joe.shaded.javax.annotation</shadedPattern>
               </relocation>
 
-              <relocation>
-                <pattern>org.slf4j</pattern>
-                <shadedPattern>uk.co.angrybee.joe.shaded.org.slf4j</shadedPattern>
-              </relocation>
+<!--              <relocation>-->
+<!--                <pattern>org.slf4j</pattern>-->
+<!--                <shadedPattern>uk.co.angrybee.joe.shaded.org.slf4j</shadedPattern>-->
+<!--              </relocation>-->
 
               <relocation>
                 <pattern>org.yaml.snakeyaml</pattern>
                 <shadedPattern>uk.co.angrybee.joe.shaded.org.yaml.snakeyaml</shadedPattern>
               </relocation>
 
-              <relocation>
-                <pattern>org.json.simple</pattern>
-                <shadedPattern>uk.co.angrybee.joe.shaded.org.json.simple</shadedPattern>
-              </relocation>
-
               <relocation>
                 <pattern>org.jetbrains.annotations</pattern>
                 <shadedPattern>uk.co.angrybee.joe.shaded.org.jetbrains.annotations</shadedPattern>
@@ -239,6 +291,11 @@
                 <pattern>ch.qos.logback</pattern>
                 <shadedPattern>uk.co.angrybee.joe.shaded.ch.qos.logback</shadedPattern>
               </relocation>
+
+              <relocation>
+                <pattern>com.google.code.gson</pattern>
+                <shadedPattern>uk.co.angrybee.joe.shaded.com.google.code.gson</shadedPattern>
+              </relocation>
             </relocations>
           </configuration>
         </plugin>
@@ -246,7 +303,7 @@
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-antrun-plugin</artifactId>
-          <version>1.8</version>
+          <version>3.1.0</version>
           <executions>
             <execution>
               <phase>test</phase>
@@ -269,15 +326,15 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
-          <source>8</source>
-          <target>8</target>
+          <source>19</source>
+          <target>19</target>
         </configuration>
       </plugin>
 
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-shade-plugin</artifactId>
-        <version>3.2.4</version>
+        <version>3.5.1</version>
       </plugin>
     </plugins>
 

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

@@ -1,6 +1,9 @@
 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.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 
 import java.util.Arrays;
@@ -13,6 +16,111 @@ public class AuthorPermissions
     private boolean userIsBanned = false;
     private boolean userCanUseClear = false;
 
+    public AuthorPermissions(SlashCommandInteractionEvent 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/Configs/CustomPrefixConfig.java

@@ -1,99 +0,0 @@
-package uk.co.angrybee.joe.Configs;
-
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import uk.co.angrybee.joe.DiscordWhitelister;
-
-import java.io.File;
-import java.io.IOException;
-
-// custom-prefixes.yml
-public class CustomPrefixConfig
-{
-    private static File customPrefixesFile;
-    private static FileConfiguration customPrefixesConfig;
-
-    public static FileConfiguration getCustomPrefixesConfig() { return customPrefixesConfig; }
-
-    private static boolean customPrefixesFileCreated = false;
-
-    public static void ConfigSetup()
-    {
-        customPrefixesFile = new File(DiscordWhitelister.getPlugin().getDataFolder(), "custom-prefixes.yml");
-        customPrefixesConfig = new YamlConfiguration();
-
-        if(!customPrefixesFile.exists())
-            CreateConfig();
-
-        LoadConfigFile();
-        CheckEntries();
-        SaveConfig();
-    }
-
-    private static void CreateConfig()
-    {
-        try
-        {
-            customPrefixesFile.createNewFile();
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-
-        DiscordWhitelister.getPluginLogger().info("Custom Prefixes file created at: " + customPrefixesFile.getPath());
-        customPrefixesFileCreated = true;
-    }
-
-    private static void LoadConfigFile()
-    {
-        try
-        {
-            customPrefixesConfig.load(customPrefixesFile);
-        }
-        catch (IOException | InvalidConfigurationException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntries()
-    {
-        if(customPrefixesFile.exists())
-        {
-            CheckEntry("whitelist-add-prefix", "!whitelist add");
-
-            CheckEntry("whitelist-remove-prefix", "!whitelist remove");
-
-            CheckEntry("clear-name-prefix", "!clearname");
-
-            CheckEntry("limited-whitelist-clear-prefix", "!whitelist clear");
-
-            CheckEntry("clear-ban-prefix", "!clearban");
-        }
-    }
-
-    private static void SaveConfig()
-    {
-        try
-        {
-            customPrefixesConfig.save(customPrefixesFile.getPath());
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntry(String entryName, Object passedValue)
-    {
-        if(customPrefixesConfig.get(entryName) == null)
-        {
-            customPrefixesConfig.set(entryName, passedValue);
-
-            if(!customPrefixesFileCreated)
-                DiscordWhitelister.getPluginLogger().warning("Entry '" + entryName + "' was not found, adding it to custom-prefixes.yml...");
-        }
-    }
-}

src/main/java/uk/co/angrybee/joe/Configs/OnWhitelistCommandsConfig.java

@@ -1,114 +0,0 @@
-package uk.co.angrybee.joe.Configs;
-
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import uk.co.angrybee.joe.DiscordWhitelister;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collections;
-
-public class OnWhitelistCommandsConfig
-{
-    private static File onWhitelistCommandsConfigFile;
-    private static FileConfiguration onWhitelistCommandsConfig;
-
-    public static FileConfiguration getPermissionsConfig() { return onWhitelistCommandsConfig; }
-
-    private static boolean onWhitelistCommandsFileCreated = false;
-
-    public static void ConfigSetup()
-    {
-        onWhitelistCommandsConfigFile = new File(DiscordWhitelister.getPlugin().getDataFolder(), "on-whitelist-commands.yml");
-        onWhitelistCommandsConfig = new YamlConfiguration();
-
-        if(!onWhitelistCommandsConfigFile.exists())
-            CreateConfig();
-
-        LoadConfigFile();
-        CheckEntries();
-        SaveConfig();
-    }
-
-    private static void CreateConfig()
-    {
-        try
-        {
-            onWhitelistCommandsConfigFile.createNewFile();
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-
-        DiscordWhitelister.getPluginLogger().info("on whitelist commands file created at: " + onWhitelistCommandsConfigFile.getPath());
-        onWhitelistCommandsFileCreated = true;
-    }
-
-    private static void LoadConfigFile()
-    {
-        try
-        {
-            onWhitelistCommandsConfig.load(onWhitelistCommandsConfigFile);
-        }
-        catch (IOException | InvalidConfigurationException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntries()
-    {
-        if(onWhitelistCommandsConfigFile.exists())
-        {
-            // Write comments
-            if(onWhitelistCommandsFileCreated)
-            {
-                SaveConfig(); // save and load again
-                try
-                {
-                    FileWriter fileWriter = new FileWriter(onWhitelistCommandsConfigFile);
-                    fileWriter.write("# The list of commands that will be dispatched when a player gets whitelisted. (Use the following syntax: \n"
-                    + "# \"%TYPE%:%COMMAND%\", being %TYPE% whether 'CONSOLE' or 'PLAYER' and the command without the slash (/)\n"
-                    + "# placeholder %PLAYER% is supported here).\n"
-                    + "# NOTE: The 'PLAYER' type will only work if the target whitelisted player is in the server at the time of command dispatch.");
-
-                    fileWriter.close();
-                }
-                catch (IOException e)
-                {
-                    e.printStackTrace();
-                }
-                LoadConfigFile();
-            }
-
-            CheckEntry("on-whitelist-commands", Arrays.asList("CONSOLE:gamemode adventure %PLAYER%", "CONSOLE:say hello testing"));
-        }
-    }
-
-    private static void SaveConfig()
-    {
-        try
-        {
-            onWhitelistCommandsConfig.save(onWhitelistCommandsConfigFile.getPath());
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntry(String entryName, Object passedValue)
-    {
-        if(onWhitelistCommandsConfig.get(entryName) == null)
-        {
-            onWhitelistCommandsConfig.set(entryName, passedValue);
-
-            if(!onWhitelistCommandsFileCreated)
-                DiscordWhitelister.getPluginLogger().warning("Entry '" + entryName + "' was not found, adding it to on-whitelist-permissions.yml...");
-        }
-    }
-}

src/main/java/uk/co/angrybee/joe/Configs/PermissionsConfig.java

@@ -1,92 +0,0 @@
-package uk.co.angrybee.joe.Configs;
-
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import uk.co.angrybee.joe.DiscordWhitelister;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Collections;
-
-public class PermissionsConfig
-{
-    private static File permissionsConfigFile;
-    private static FileConfiguration permissionsConfig;
-
-    public static FileConfiguration getPermissionsConfig() { return permissionsConfig; }
-
-    private static boolean permissionsFileCreated = false;
-
-    public static void ConfigSetup()
-    {
-        permissionsConfigFile = new File(DiscordWhitelister.getPlugin().getDataFolder(), "on-whitelist-permissions.yml");
-        permissionsConfig = new YamlConfiguration();
-
-        if(!permissionsConfigFile.exists())
-            CreateConfig();
-
-        LoadConfigFile();
-        CheckEntries();
-        SaveConfig();
-    }
-
-    private static void CreateConfig()
-    {
-        try
-        {
-            permissionsConfigFile.createNewFile();
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-
-        DiscordWhitelister.getPluginLogger().info("on whitelist permissions file created at: " + permissionsConfigFile.getPath());
-        permissionsFileCreated = true;
-    }
-
-    private static void LoadConfigFile()
-    {
-        try
-        {
-            permissionsConfig.load(permissionsConfigFile);
-        }
-        catch (IOException | InvalidConfigurationException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntries()
-    {
-        if(permissionsConfigFile.exists())
-        {
-            // test permission
-            CheckEntry("perms-on-whitelist", Collections.singletonList("bukkit.command.tps"));
-        }
-    }
-
-    private static void SaveConfig()
-    {
-        try
-        {
-            permissionsConfig.save(permissionsConfigFile.getPath());
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntry(String entryName, Object passedValue)
-    {
-        if(permissionsConfig.get(entryName) == null)
-        {
-            permissionsConfig.set(entryName, passedValue);
-
-            if(!permissionsFileCreated)
-                DiscordWhitelister.getPluginLogger().warning("Entry '" + entryName + "' was not found, adding it to on-whitelist-permissions.yml...");
-        }
-    }
-}

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

@@ -1,34 +1,36 @@
 package uk.co.angrybee.joe;
 
 import org.bukkit.Server;
-import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.java.JavaPlugin;
-import uk.co.angrybee.joe.Commands.CommandAbout;
-import uk.co.angrybee.joe.Commands.CommandReload;
-import uk.co.angrybee.joe.Commands.CommandStatus;
-import uk.co.angrybee.joe.Configs.*;
-import uk.co.angrybee.joe.Events.JoinLeaveEvents;
-import uk.co.angrybee.joe.Events.OnBanEvent;
-import uk.co.angrybee.joe.Events.OnWhitelistEvents;
-import uk.co.angrybee.joe.Stores.InGameRemovedList;
-import uk.co.angrybee.joe.Stores.RemovedList;
-import uk.co.angrybee.joe.Stores.UserList;
-import uk.co.angrybee.joe.Stores.WhitelistedPlayers;
+import com.earth2me.essentials.Essentials;
+import org.kitteh.vanish.VanishPlugin;
+import org.bukkit.plugin.PluginManager;
+import uk.co.angrybee.joe.commands.minecraft.CommandAbout;
+import uk.co.angrybee.joe.commands.minecraft.CommandReload;
+import uk.co.angrybee.joe.commands.minecraft.CommandStatus;
+import uk.co.angrybee.joe.configs.*;
+import uk.co.angrybee.joe.events.JoinLeaveEvents;
+import uk.co.angrybee.joe.events.OnBanEvent;
+import uk.co.angrybee.joe.events.OnWhitelistEvents;
+import uk.co.angrybee.joe.stores.InGameRemovedList;
+import uk.co.angrybee.joe.stores.RemovedList;
+import uk.co.angrybee.joe.stores.UserList;
+import uk.co.angrybee.joe.stores.WhitelistedPlayers;
+import uk.co.angrybee.joe.events.EssentialsVanishEvents;
+import uk.co.angrybee.joe.events.SuperVanishEvents;
+import uk.co.angrybee.joe.events.VanishNoPacketEvents;
 
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.*;
+import java.util.List;
 import java.util.logging.Logger;
+import java.util.stream.Stream;
 
-public class DiscordWhitelister extends JavaPlugin
-{
+public class DiscordWhitelister extends JavaPlugin {
     public static String botToken;
 
     private static boolean configCreated = false;
 
+    public static boolean initialized = false;
     public static boolean useCustomMessages = false;
     public static boolean useIdForRoles = false;
     public static boolean useCustomPrefixes = false;
@@ -37,7 +39,9 @@ public class DiscordWhitelister extends JavaPlugin
     public static boolean useInGameAddRemoves = true;
     public static boolean useOnBanEvents = true;
     public static boolean useUltraPerms = false;
+    public static boolean useLuckPerms = false;
     public static boolean useOnWhitelistCommands = false;
+    public static boolean removeUnnecessaryMessages = false;
 
     public static boolean botEnabled;
 
@@ -47,38 +51,51 @@ public class DiscordWhitelister extends JavaPlugin
     private static Server thisServer;
     private static Logger pluginLogger;
 
+    // Plugins
+    public static Essentials essentialsPlugin;
+    public static VanishPlugin vanishNoPacketPlugin;
+    public static boolean hasSuperVanishOrPremiumVanish;
+
     // For not counting vanished players when other players join/leave
     private static int vanishedPlayersCount;
 
+    public static int removeMessageWaitTime = 5;
+
+    public static MainConfig mainConfig;
+
+    public static CustomPrefixConfig customPrefixConfig;
+    public static CustomMessagesConfig customMessagesConfig;
+    public static PermissionsConfig permissionsConfig;
+    public static OnWhitelistCommandsConfig onWhitelistCommandsConfig;
+
+
     @Override
-    public void onEnable()
-    {
+    public void onEnable() {
         thisPlugin = this;
         thisServer = thisPlugin.getServer();
         pluginLogger = thisPlugin.getLogger();
 
+        // Get/check for plugin
+        PluginManager pluginManager = getServer().getPluginManager();
+        essentialsPlugin = (Essentials) pluginManager.getPlugin("Essentials");
+        vanishNoPacketPlugin = (VanishPlugin) pluginManager.getPlugin("VanishNoPacket");
+        hasSuperVanishOrPremiumVanish = pluginManager.isPluginEnabled("SuperVanish") || pluginManager.isPluginEnabled("PremiumVanish");
+
         int initSuccess = InitBot(true);
 
-        if(initSuccess == 0)
-        {
+        if (initSuccess == 0) {
             pluginLogger.info("Successfully initialized Discord client");
-        }
-        else if(initSuccess == 1)
-        {
+            initialized = true;
+        } else if (initSuccess == 1) {
             pluginLogger.severe("Discord Client failed to initialize, please check if your config file is valid");
+            initialized = false;
+            return;
         }
 
         // Check for leavers if enabled
-        if(MainConfig.getMainConfig().getBoolean("un-whitelist-on-server-leave"))
-        {
-            try
-            {
-                DiscordClient.StartUpMemberCheck();
-            }
-            catch (IOException e)
-            {
-                e.printStackTrace();
-            }
+        if (botEnabled) {
+            DiscordClient.ServerLeaveStartupCheck();
+            DiscordClient.RequiredRoleStartupCheck();
         }
 
         this.getCommand("discordwhitelister").setExecutor(new CommandStatus());
@@ -87,167 +104,206 @@ public class DiscordWhitelister extends JavaPlugin
     }
 
     @Override
-    public void onDisable()
-    {
-        DiscordClient.javaDiscordAPI.shutdownNow();
+    public void onDisable() {
+        if (initialized ) {
+            DiscordClient.javaDiscordAPI.shutdownNow();
+        }
     }
 
-    public static JavaPlugin getPlugin()
-    {
+    public static JavaPlugin getPlugin() {
         return thisPlugin;
     }
 
-    public static FileConfiguration getCustomMessagesConfig() { return CustomMessagesConfig.getCustomMessagesConfig(); }
+    public static FileConfiguration getCustomMessagesConfig() {
+        return customMessagesConfig.getFileConfiguration();
+    }
 
-    public static Logger getPluginLogger() { return pluginLogger; }
+    public static Logger getPluginLogger() {
+        return pluginLogger;
+    }
 
-    public static boolean getUseCustomPrefixes() { return useCustomPrefixes; }
+    public static boolean getUseCustomPrefixes() {
+        return useCustomPrefixes;
+    }
 
-    public static void addVanishedPlayer() { vanishedPlayersCount++; }
+    public static void addVanishedPlayer() {
+        vanishedPlayersCount++;
+    }
 
-    public static void removeVanishedPlayer() { vanishedPlayersCount--; }
+    public static void removeVanishedPlayer() {
+        vanishedPlayersCount--;
+    }
 
-    public static int getOnlineUsers() { return thisPlugin.getServer().getOnlinePlayers().size() - vanishedPlayersCount; }
+    public static int getOnlineUsers() {
+        return thisPlugin.getServer().getOnlinePlayers().size() - vanishedPlayersCount;
+    }
 
-    public static int getMaximumAllowedPlayers() { return thisPlugin.getServer().getMaxPlayers(); }
 
-    public static int InitBot(boolean firstInit)
-    {
-        if(firstInit)
+    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();
+    }
+
+    public static int InitBot(boolean firstInit) {
+        if (firstInit)
             vanishedPlayersCount = 0;
 
         ConfigSetup();
 
-        botToken = MainConfig.getMainConfig().getString("discord-bot-token");
-        botEnabled = MainConfig.getMainConfig().getBoolean("bot-enabled");
-        showPlayerSkin = MainConfig.getMainConfig().getBoolean("show-player-skin-on-whitelist");
-        configCreated = MainConfig.configCreated;
-        showVanishedPlayersInCount = MainConfig.getMainConfig().getBoolean("show-vanished-players-in-player-count");
-        useInGameAddRemoves = MainConfig.getMainConfig().getBoolean("add-in-game-adds-and-removes-to-list");
-        useOnBanEvents = MainConfig.getMainConfig().getBoolean("use-on-ban-events");
+        botToken = mainConfig.getFileConfiguration().getString("discord-bot-token");
+        botEnabled = mainConfig.getFileConfiguration().getBoolean("bot-enabled");
+        showPlayerSkin = mainConfig.getFileConfiguration().getBoolean("show-player-skin-on-whitelist");
+        configCreated = mainConfig.fileCreated;
+        showVanishedPlayersInCount = mainConfig.getFileConfiguration().getBoolean("show-vanished-players-in-player-count");
+        useInGameAddRemoves = mainConfig.getFileConfiguration().getBoolean("add-in-game-adds-and-removes-to-list");
+        useOnBanEvents = mainConfig.getFileConfiguration().getBoolean("use-on-ban-events");
+        removeUnnecessaryMessages = mainConfig.getFileConfiguration().getBoolean("remove-unnecessary-messages-from-whitelist-channel");
+        removeMessageWaitTime = mainConfig.getFileConfiguration().getInt("seconds-to-remove-message-from-whitelist-channel");
+        useOnWhitelistCommands = mainConfig.getFileConfiguration().getBoolean("use-on-whitelist-commands");
 
-        // Check for UltraPerms first
-        if(MainConfig.getMainConfig().getBoolean("assign-perms-with-ultra-perms"))
-        {
-            if(DiscordWhitelister.getPlugin().getServer().getPluginManager().getPlugin("UltraPermissions") != null)
-            {
-                useUltraPerms = true;
-                DiscordWhitelister.getPluginLogger().info("Ultra Permissions found!");
-            }
-            else
-            {
-                DiscordWhitelister.getPluginLogger().warning("Ultra Permissions was not found but is enabled in the config. Doing nothing...");
-                useUltraPerms = false;
-            }
-        }
-
-        if(MainConfig.getMainConfig().getBoolean("use-on-whitelist-commands"))
-            useOnWhitelistCommands = true;
-
-        DiscordClient.whitelistAddPrefix = CustomPrefixConfig.getCustomPrefixesConfig().getString("whitelist-add-prefix").toLowerCase();
-        DiscordClient.whitelistRemovePrefix = CustomPrefixConfig.getCustomPrefixesConfig().getString("whitelist-remove-prefix").toLowerCase();
-        DiscordClient.clearNamePrefix = CustomPrefixConfig.getCustomPrefixesConfig().getString("clear-name-prefix").toLowerCase();
-        DiscordClient.limitedWhitelistClearPrefix = CustomPrefixConfig.getCustomPrefixesConfig().getString("limited-whitelist-clear-prefix").toLowerCase();
-        DiscordClient.clearBanPrefix = CustomPrefixConfig.getCustomPrefixesConfig().getString("clear-ban-prefix").toLowerCase();
-
-        if(!botEnabled)
-        {
+        if (!botEnabled) {
             pluginLogger.info("Bot is disabled as per the config, doing nothing");
-        }
-        else if(configCreated)
-        {
-            pluginLogger.info("Config newly created, please paste your bot token into the config file, doing nothing until next server start");
-        }
-        else
-        {
-            pluginLogger.info("Initializing Discord client...");
-
-            // TODO: below role section could be moved to DiscordClient class
-            useIdForRoles = MainConfig.getMainConfig().getBoolean("use-id-for-roles");
-
-            // set add & remove roles
-            DiscordClient.allowedToAddRemoveRoles = new String[MainConfig.getMainConfig().getList("add-remove-roles").size()];
-            for(int roles = 0; roles < DiscordClient.allowedToAddRemoveRoles.length; ++roles)
-            {
-                DiscordClient.allowedToAddRemoveRoles[roles] = MainConfig.getMainConfig().getList("add-remove-roles").get(roles).toString();
+        } else if (configCreated || botToken.equals(MainConfig.default_token)) {
+            pluginLogger.warning("Config newly created. Please paste your bot token into the config file, doing nothing until next server start");
+        } else {
+            // Check for LuckPerms first
+            if (mainConfig.getFileConfiguration().getBoolean("assign-perms-with-luck-perms")) {
+                if (getPlugin().getServer().getPluginManager().getPlugin("LuckPerms") != null) {
+                    useLuckPerms = true;
+                    getPluginLogger().info("LuckPerms found!");
+                } else {
+                    getPluginLogger().warning("LuckPerms was not found but is enabled in the config. Doing nothing...");
+                    useLuckPerms = false;
+                }
             }
-
-            // set add roles
-            DiscordClient.allowedToAddRoles = new String[MainConfig.getMainConfig().getList("add-roles").size()];
-            for(int roles = 0; roles < DiscordClient.allowedToAddRoles.length; ++roles)
-            {
-                DiscordClient.allowedToAddRoles[roles] = MainConfig.getMainConfig().getList("add-roles").get(roles).toString();
-            }
-
-            // set limited add roles
-            DiscordClient.allowedToAddLimitedRoles = new String[MainConfig.getMainConfig().getList("limited-add-roles").size()];
-            for(int roles = 0; roles < DiscordClient.allowedToAddLimitedRoles.length; ++roles)
-            {
-                DiscordClient.allowedToAddLimitedRoles[roles] = MainConfig.getMainConfig().getList("limited-add-roles").get(roles).toString();
-            }
-
-            // Get banned roles
-            if(useOnBanEvents)
-            {
-                List<String> tempBannedRoles = MainConfig.getMainConfig().getStringList("banned-roles");
-                bannedRoles = new String[tempBannedRoles.size()];
-                for(int i = 0; i < tempBannedRoles.size(); i++)
-                {
-                    bannedRoles[i] = tempBannedRoles.get(i);
+            if (mainConfig.getFileConfiguration().getBoolean("assign-perms-with-ultra-perms")) {
+                if (getPlugin().getServer().getPluginManager().getPlugin("UltraPermissions") != null) {
+                    useUltraPerms = true;
+                    getPluginLogger().info("Ultra Permissions found!");
+                } else {
+                    getPluginLogger().warning("Ultra Permissions was not found but is enabled in the config. Doing nothing...");
+                    useUltraPerms = false;
                 }
             }
 
-            // Allowed to clear name roles
-            DiscordClient.allowedToClearNamesRoles = new String[MainConfig.getMainConfig().getStringList("clear-command-roles").size()];
-            for(int roles = 0; roles < DiscordClient.allowedToClearNamesRoles.length; roles++)
-            {
-                DiscordClient.allowedToClearNamesRoles[roles] = MainConfig.getMainConfig().getStringList("clear-command-roles").get(roles);
+            // TODO: remove in favour of split versions
+            DiscordClient.customWhitelistAddPrefix = customPrefixConfig.getFileConfiguration().getString("whitelist-add-prefix").toLowerCase();
+            DiscordClient.customWhitelistRemovePrefix = customPrefixConfig.getFileConfiguration().getString("whitelist-remove-prefix").toLowerCase();
+            DiscordClient.customClearNamePrefix = customPrefixConfig.getFileConfiguration().getString("clear-name-prefix").toLowerCase();
+            DiscordClient.customLimitedWhitelistClearPrefix = customPrefixConfig.getFileConfiguration().getString("limited-whitelist-clear-prefix").toLowerCase();
+            DiscordClient.customClearBanPrefix = customPrefixConfig.getFileConfiguration().getString("clear-ban-prefix").toLowerCase();
+
+            // Split versions
+            DiscordClient.customWhitelistAddPrefixSplit = customPrefixConfig.getFileConfiguration().getString("whitelist-add-prefix").toLowerCase().trim().split(" ");
+            DiscordClient.customWhitelistRemovePrefixSplit = customPrefixConfig.getFileConfiguration().getString("whitelist-remove-prefix").toLowerCase().trim().split(" ");
+            DiscordClient.customClearNamePrefixSplit = customPrefixConfig.getFileConfiguration().getString("clear-name-prefix").toLowerCase().trim().split(" ");
+            DiscordClient.customLimitedWhitelistClearPrefixSplit = customPrefixConfig.getFileConfiguration().getString("limited-whitelist-clear-prefix").toLowerCase().trim().split(" ");
+            DiscordClient.customClearBanPrefixSplit = customPrefixConfig.getFileConfiguration().getString("clear-ban-prefix").toLowerCase().trim().split(" ");
+            DiscordClient.customWhoIsPrefix = customPrefixConfig.getFileConfiguration().getString("whitelist-whois-prefix").toLowerCase().trim().split(" ");
+
+
+            pluginLogger.info("Initializing Discord client...");
+
+            // TODO: below role section could be moved to DiscordClient class
+            useIdForRoles = mainConfig.getFileConfiguration().getBoolean("use-id-for-roles");
+
+
+
+
+
+            // set add & remove roles
+            DiscordClient.allowedToAddRemoveRoles = getConfigArray("add-remove-roles");
+
+
+            // set add roles
+            DiscordClient.allowedToAddRoles = getConfigArray("add-roles");
+
+
+            // set limited add roles
+            DiscordClient.allowedToAddLimitedRoles = getConfigArray("limited-add-roles");
+
+
+            // Get banned roles
+            if (useOnBanEvents) {
+                bannedRoles = getConfigArray("banned-roles");
             }
 
+            // Allowed to clear name roles
+            DiscordClient.allowedToClearNamesRoles = getConfigArray("clear-command-roles");
+
+            // All roles combined for role check
+            DiscordClient.combinedRoles = Stream.of(DiscordClient.allowedToAddRemoveRoles, DiscordClient.allowedToAddRoles,
+                    DiscordClient.allowedToAddLimitedRoles, DiscordClient.allowedToClearNamesRoles)
+                    .flatMap(Stream::of).toArray(String[]::new);
+
             // Custom messages check
-            useCustomMessages = MainConfig.getMainConfig().getBoolean("use-custom-messages");
-            useCustomPrefixes = MainConfig.getMainConfig().getBoolean("use-custom-prefixes");
+            useCustomMessages = mainConfig.getFileConfiguration().getBoolean("use-custom-messages");
+            useCustomPrefixes = mainConfig.getFileConfiguration().getBoolean("use-custom-prefixes");
 
             int initSuccess = DiscordClient.InitializeClient(botToken);
 
-            if(initSuccess == 1)
+            if (initSuccess == 1)
                 return 1;
 
 
             // No need for an if here statement anymore as this code will not run if the client has not been initialized
             // Only attempt to set player count if the bot successfully initialized
-            if(MainConfig.getMainConfig().getBoolean("show-player-count"))
-            {
-                // Register events if enabled
-                thisServer.getPluginManager().registerEvents(new JoinLeaveEvents(), thisPlugin);
+            if (mainConfig.getFileConfiguration().getBoolean("show-player-count")) {
+                if (firstInit) {
+                    // Register events if enabled
+                    thisServer.getPluginManager().registerEvents(new JoinLeaveEvents(), thisPlugin);
+                    //pluginLogger.info("Registered join/leave events!");
+                    if (hasSuperVanishOrPremiumVanish) {
+                        thisServer.getPluginManager().registerEvents(new SuperVanishEvents(), thisPlugin);
+                        //pluginLogger.info("Registered SuperVanish events!");
+                    }
+                    if (vanishNoPacketPlugin != null) {
+                        thisServer.getPluginManager().registerEvents(new VanishNoPacketEvents(), thisPlugin);
+                        //pluginLogger.info("Registered VanishNoPacket events!");
+                    }
+                    if (essentialsPlugin != null) {
+                        thisServer.getPluginManager().registerEvents(new EssentialsVanishEvents(), thisPlugin);
+                        //pluginLogger.info("Registered Essentials vanish events!");
+                    }
+                }
 
                 // Set initial player count
                 DiscordClient.SetPlayerCountStatus(getOnlineUsers());
             }
 
             // Register whitelist events if enabled
-            if(useInGameAddRemoves)
+            if (useInGameAddRemoves)
                 thisServer.getPluginManager().registerEvents(new OnWhitelistEvents(), thisPlugin);
 
             // Register ban events if enabled
-            if(useOnBanEvents)
+            if (useOnBanEvents)
                 thisServer.getPluginManager().registerEvents(new OnBanEvent(), thisPlugin);
 
             return 0;
         }
 
-        return 0;
+        return 1;
     }
 
-    public static void ConfigSetup()
-    {
-        // Run this first, as it creates the root folder if it does not exist
-        MainConfig.ConfigSetup();
+    public static void ConfigSetup() {
+        mainConfig = new MainConfig();
+        customPrefixConfig = new CustomPrefixConfig();
+        customMessagesConfig = new CustomMessagesConfig();
+        permissionsConfig = new PermissionsConfig();
+        onWhitelistCommandsConfig = new OnWhitelistCommandsConfig();
 
-        CustomPrefixConfig.ConfigSetup();
-        CustomMessagesConfig.ConfigSetup();
-        PermissionsConfig.ConfigSetup();
-        OnWhitelistCommandsConfig.ConfigSetup();
+        // Run this first, as it creates the root folder if it does not exist
+        mainConfig.ConfigSetup();
+        customPrefixConfig.ConfigSetup();
+        customMessagesConfig.ConfigSetup();
+        permissionsConfig.ConfigSetup();
+        onWhitelistCommandsConfig.ConfigSetup();
 
         // Init Stores
         UserList.StoreSetup();

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

@@ -0,0 +1,46 @@
+package uk.co.angrybee.joe;
+
+import de.myzelyam.api.vanish.VanishAPI;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.MetadataValue;
+
+import static uk.co.angrybee.joe.DiscordWhitelister.*;
+
+public class Utils {
+
+    // Check if player is vanished
+    public static boolean isVanished(Player player) {
+
+        // For Essentials
+        if(essentialsPlugin != null) {
+            //getPluginLogger().info("Checking via EssX if " + player.getDisplayName() + " is vanished: " + essentialsPlugin.getUser(player).isVanished());
+            //getPluginLogger().info("Checking via EssX for list of vanished players: " + essentialsPlugin.getVanishedPlayers());
+            if(essentialsPlugin.getUser(player).isVanished()) return true;
+        }
+
+        // For SuperVanish / PremiumVanish
+        if(hasSuperVanishOrPremiumVanish) {
+            //getPluginLogger().info("Checking via SV if " + player.getDisplayName() + " is vanished: " + VanishAPI.isInvisible(player));
+            //getPluginLogger().info("Checking via SV for list of vanished players: " + VanishAPI.getAllInvisiblePlayers());
+            if(VanishAPI.isInvisible(player)) return true;
+        }
+
+        // For VanishNoPacket
+        if(vanishNoPacketPlugin != null) {
+            //getPluginLogger().info("Checking via VNP if " + player.getDisplayName() + " is vanished: " + vanishNoPacketPlugin.getManager().isVanished(player));
+            //getPluginLogger().info("Checking via VNP for list of vanished players: " + vanishNoPacketPlugin.getManager().getVanishedPlayers());
+            if(vanishNoPacketPlugin.getManager().isVanished(player)) return true;
+        }
+
+        // For others (maybe)
+        for (MetadataValue meta : player.getMetadata("vanished")) {
+            if (meta.asBoolean()) return true;
+        }
+
+        // Otherwise, player is not vanished
+        return false;
+
+    }
+
+}
+

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

@@ -10,5 +10,5 @@ public class VersionInfo
         return "v." + getVersion();
     }
 
-    private static String version = "1.4.2";
+    private static String version = "1.5.1";
 }

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

@@ -0,0 +1,825 @@
+package uk.co.angrybee.joe.commands.discord;
+
+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.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+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;
+import uk.co.angrybee.joe.stores.UserList;
+import uk.co.angrybee.joe.stores.WhitelistedPlayers;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class CommandAdd {
+    public static void ExecuteCommand(SlashCommandInteractionEvent event, String mc_user, Member target) {
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getChannel().asTextChannel();
+        Member member = event.getMember();
+
+        int timesWhitelisted =0;
+        final String finalNameToAdd = mc_user;
+        final char[] finalNameToWhitelistChar = finalNameToAdd.toLowerCase().toCharArray(); // Lower case for char check
+        final Member suppliedMember = target;
+        boolean onlyHasLimitedAdd = false;
+        if (DiscordClient.usernameValidation) {
+            // Invalid char check
+            for (char c : finalNameToWhitelistChar) {
+                if (new String(DiscordClient.validCharacters).indexOf(c) == -1) {
+                    EmbedBuilder embedBuilderInvalidChar;
+
+                    if (!DiscordWhitelister.useCustomMessages) {
+                        embedBuilderInvalidChar = DiscordClient.CreateEmbeddedMessage("Invalid Username", (author.getAsMention() + ", the username you have specified contains invalid characters. **Only letters, numbers and underscores are allowed**."), DiscordClient.EmbedMessageType.FAILURE);
+                    } else {
+                        String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-characters-warning-title");
+                        String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-characters-warning");
+                        customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+
+                        embedBuilderInvalidChar = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                    }
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderInvalidChar.build());
+                    return;
+                }
+            }
+
+            // Length check
+            if (finalNameToAdd.length() < 3 || finalNameToAdd.length() > 16) {
+                EmbedBuilder embedBuilderLengthInvalid;
+
+                if (!DiscordWhitelister.useCustomMessages) {
+                    embedBuilderLengthInvalid = DiscordClient.CreateEmbeddedMessage("Invalid Username", (author.getAsMention() + ", the username you have specified either contains too few or too many characters. **Usernames can only consist of 3-16 characters**."), DiscordClient.EmbedMessageType.FAILURE);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-length-warning-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-length-warning");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+
+                    embedBuilderLengthInvalid = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                }
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderLengthInvalid.build());
+                return;
+            }
+        }
+
+        if (authorPermissions.isUserCanAddRemove() || authorPermissions.isUserCanAdd()) {
+
+
+            // runs after member null check
+            // Create a entry in the user list if needed for supplied id
+            if (UserList.getUserList().getString(suppliedMember.getId()) == null) {
+                UserList.getUserList().set(suppliedMember.getId(), new ArrayList<String>());
+                UserList.SaveStore();
+            }
+
+            DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") attempted to whitelist: " + finalNameToAdd);
+
+        } else if (authorPermissions.isUserHasLimitedAdd() && DiscordClient.limitedWhitelistEnabled) {
+            onlyHasLimitedAdd = true;
+            if (DiscordWhitelister.useOnBanEvents && authorPermissions.isUserIsBanned()) {
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed =
+                            DiscordClient.CreateEmbeddedMessage("You have been banned!", (author.getAsMention() + ", you cannot use this bot as you have been banned!"), DiscordClient.EmbedMessageType.FAILURE).build();
+
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("banned-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("banned-message");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention()); // Only checking for {Sender}
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+                return;
+            }
+                /* if limited whitelist is enabled, check if the user is in the limited whitelister group and add the user to the list
+                which records how many times the user has successfully used the whitelist command */
+            if (UserList.getUserList().getString(author.getId()) == null) {
+                UserList.getUserList().set(author.getId(), new ArrayList<String>());
+                UserList.SaveStore();
+            }
+            boolean usedAllWhitelists = false;
+            try {
+                usedAllWhitelists = UserList.getRegisteredUsersCount(author.getId()) >= DiscordClient.maxWhitelistAmount &&
+                        !authorPermissions.isUserCanAddRemove() && !authorPermissions.isUserCanAdd();
+            } catch (NullPointerException exception) {
+                exception.printStackTrace();
+            }
+            /*
+            todo:add this
+            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("Insufficient Permissions",
+                        (author.getAsMention() + ", only staff members can manually link Discord IDs. Please only enter your Minecraft name."), DiscordClient.EmbedMessageType.FAILURE).build();
+
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                return;
+
+                if (onlyHasLimitedAdd) {
+                    DiscordClient.AddWhitelistRemainingCount(embedBuilderInvalidChar, timesWhitelisted);
+                }
+                if (onlyHasLimitedAdd) {
+                    DiscordClient.AddWhitelistRemainingCount(embedBuilderLengthInvalid, timesWhitelisted);
+                }
+
+             */
+
+            timesWhitelisted = UserList.getRegisteredUsersCount(author.getId());
+
+            // set to current max in case the max whitelist amount was changed
+            if (timesWhitelisted > DiscordClient.maxWhitelistAmount) {
+                timesWhitelisted = DiscordClient.maxWhitelistAmount;
+            }
+
+            if (usedAllWhitelists) {
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("No Whitelists Remaining", (author.getAsMention() + ", unable to whitelist. You have **" + (DiscordClient.maxWhitelistAmount - timesWhitelisted)
+                            + " out of " + DiscordClient.maxWhitelistAmount + "** whitelists remaining."), DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("no-whitelists-remaining-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("no-whitelists-remaining");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{RemainingWhitelists}", String.valueOf((DiscordClient.maxWhitelistAmount - timesWhitelisted)));
+                    customMessage = customMessage.replaceAll("\\{MaxWhitelistAmount}", String.valueOf(DiscordClient.maxWhitelistAmount));
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+
+                return;
+            }
+
+            DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") attempted to whitelist: " + finalNameToAdd + ", " + (DiscordClient.maxWhitelistAmount - timesWhitelisted) + " whitelists remaining");
+
+
+        } else {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+            return;
+        }
+
+
+
+
+        boolean alreadyOnWhitelist = false;
+
+        if (WhitelistedPlayers.usingEasyWhitelist) {
+            if (WhitelistedPlayers.CheckForPlayerEasyWhitelist(finalNameToAdd)) {
+                alreadyOnWhitelist = true;
+            }
+        } else if (WhitelistedPlayers.CheckForPlayer(finalNameToAdd)) {
+            alreadyOnWhitelist = true;
+        }
+
+        if (alreadyOnWhitelist) {
+            if (!DiscordWhitelister.useCustomMessages) {
+                MessageEmbed messageEmbed =
+                        DiscordClient.CreateEmbeddedMessage("User already on the whitelist",
+                                (author.getAsMention() + ", cannot add user as `" + finalNameToAdd + "` is already on the whitelist!"), DiscordClient.EmbedMessageType.INFO).build();
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+            } else {
+                String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("already-on-whitelist-title");
+                String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("already-on-whitelist");
+                customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+                MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO).build();
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+            }
+            return;
+        }
+
+        if (RemovedList.CheckStoreForPlayer(finalNameToAdd)) // If the user has been removed before
+        {
+            if (onlyHasLimitedAdd) {
+                EmbedBuilder embedBuilderRemovedByStaff;
+
+                if (!DiscordWhitelister.useCustomMessages) {
+                    embedBuilderRemovedByStaff = DiscordClient.CreateEmbeddedMessage("This user was previously removed by a staff member",
+                            (author.getAsMention() + ", this user was previously removed by a staff member (<@" + RemovedList.getRemovedPlayers().get(finalNameToAdd.toLowerCase()) + ">).\n" +
+                                    "Please ask a user with higher permissions to add this user.\n"), DiscordClient.EmbedMessageType.FAILURE);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed");
+                    String staffMemberMention = "<@" + RemovedList.getRemovedPlayers().get(finalNameToAdd.toLowerCase()) + ">";
+
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{StaffMember}", staffMemberMention);
+
+                    embedBuilderRemovedByStaff = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                }
+
+                DiscordClient.AddWhitelistRemainingCount(embedBuilderRemovedByStaff, timesWhitelisted);
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderRemovedByStaff.build());
+                return;
+            } else {
+                RemovedList.getRemovedPlayers().set(finalNameToAdd.toLowerCase(), null);
+                RemovedList.SaveStore();
+
+                DiscordWhitelister.getPlugin().getLogger().info(finalNameToAdd + " has been removed from the removed list by " + author.getName() + "(" + author.getId() + ")");
+            }
+        }
+
+        // In-game list check
+        if (DiscordWhitelister.useInGameAddRemoves) {
+            if (InGameRemovedList.CheckStoreForPlayer(finalNameToAdd.toLowerCase())) {
+                if (onlyHasLimitedAdd) {
+                    EmbedBuilder embedBuilderRemovedByInGameStaff;
+
+                    if (!DiscordWhitelister.useCustomMessages) {
+                        embedBuilderRemovedByInGameStaff = DiscordClient.CreateEmbeddedMessage("This user was previously removed by a staff member",
+                                (author.getAsMention() + ", this user was previously removed by a staff member in-game (" + InGameRemovedList.getRemovedPlayers().get(finalNameToAdd.toLowerCase()) + ").\n" +
+                                        "Please ask a user with higher permissions to add this user.\n"), DiscordClient.EmbedMessageType.FAILURE);
+                    } else {
+                        String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed-in-game-title");
+                        String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed-in-game");
+                        String inGameStaffMember = InGameRemovedList.getRemovedPlayers().getString(finalNameToAdd.toLowerCase());
+
+                        customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                        customMessage = customMessage.replaceAll("\\{StaffMember}", inGameStaffMember);
+
+                        embedBuilderRemovedByInGameStaff = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                    }
+
+                    DiscordClient.AddWhitelistRemainingCount(embedBuilderRemovedByInGameStaff, timesWhitelisted);
+
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderRemovedByInGameStaff.build());
+                    return;
+                } else {
+                    InGameRemovedList.RemoveUserFromStore(finalNameToAdd.toLowerCase());
+
+                    DiscordWhitelister.getPlugin().getLogger().info(finalNameToAdd + " has been removed from in-game-removed-list.yml by " + author.getName() + "(" + author.getId() + ")");
+                }
+            }
+        }
+
+                /* Do as much as possible off the main server thread.
+                convert username into UUID to avoid depreciation and rate limits (according to https://minotar.net/) */
+        String playerUUID = DiscordClient.minecraftUsernameToUUID(finalNameToAdd);
+
+        final boolean invalidMinecraftName = playerUUID == null;
+
+                /* Configure success & failure messages here instead of on the main server thread -
+                this will run even if the message is never sent, but is a good trade off */
+        EmbedBuilder embedBuilderWhitelistSuccess;
+
+        if (!DiscordWhitelister.useCustomMessages) {
+            embedBuilderWhitelistSuccess = DiscordClient.CreateEmbeddedMessage((finalNameToAdd + " is now whitelisted!"), (author.getAsMention() + " has added `" + finalNameToAdd + "` to the whitelist."), DiscordClient.EmbedMessageType.SUCCESS);
+        } else {
+            String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-success-title");
+            customTitle = customTitle.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+            String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-success");
+            customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+            customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+            embedBuilderWhitelistSuccess = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.SUCCESS);
+        }
+
+        if (onlyHasLimitedAdd)
+            DiscordClient.AddWhitelistRemainingCount(embedBuilderWhitelistSuccess, (timesWhitelisted + 1));
+
+        if (DiscordWhitelister.showPlayerSkin) {
+            if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-crafatar-for-avatars"))
+                embedBuilderWhitelistSuccess.setThumbnail("https://minotar.net/armor/bust/" + playerUUID + "/100.png");
+            else
+                embedBuilderWhitelistSuccess.setThumbnail("https://crafatar.com/avatars/" + playerUUID + "?size=100&default=MHF_Steve&overlay.png");
+        }
+
+        EmbedBuilder embedBuilderWhitelistFailure;
+
+        if (!DiscordWhitelister.useCustomMessages) {
+            embedBuilderWhitelistFailure = DiscordClient.CreateEmbeddedMessage("Failed to whitelist",
+                    (author.getAsMention() + ", failed to add `" + finalNameToAdd + "` to the whitelist. This is most likely due to an invalid Minecraft username."), DiscordClient.EmbedMessageType.FAILURE);
+        } else {
+            String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-failure-title");
+
+            String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-failure");
+            customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+            customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+            embedBuilderWhitelistFailure = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+        }
+
+        if (onlyHasLimitedAdd)
+            DiscordClient.AddWhitelistRemainingCount(embedBuilderWhitelistFailure, timesWhitelisted); // was timesWhitelisted + 1 for some reason, change back if it doesn't work correctly
+
+        int tempTimesWhitelisted = timesWhitelisted;
+        if (onlyHasLimitedAdd && tempTimesWhitelisted < DiscordClient.maxWhitelistAmount)
+            tempTimesWhitelisted = timesWhitelisted + 1;
+        final int finalTimesWhitelisted = tempTimesWhitelisted; // if successful
+
+        AtomicBoolean successfulWhitelist = new AtomicBoolean(false);
+
+        if (!WhitelistedPlayers.usingEasyWhitelist && authorPermissions.isUserCanUseCommand())
+            DiscordClient.ExecuteServerCommand("whitelist add " + finalNameToAdd);
+        if (DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-geyser/floodgate-compatibility")) {
+            addBedrockUser(finalNameToAdd);
+        }
+
+        // have to use !invalidMinecraftName else the easy whitelist plugin will add the name regardless of whether it is valid on not
+        if (WhitelistedPlayers.usingEasyWhitelist && !invalidMinecraftName && authorPermissions.isUserCanUseCommand())
+            DiscordClient.ExecuteServerCommand("easywl add " + finalNameToAdd);
+
+        DiscordWhitelister.getPlugin().getServer().getScheduler().callSyncMethod(DiscordWhitelister.getPlugin(), () ->
+        {
+            if (WhitelistedPlayers.usingEasyWhitelist && !invalidMinecraftName && WhitelistedPlayers.CheckForPlayerEasyWhitelist(finalNameToAdd)
+                    || !WhitelistedPlayers.usingEasyWhitelist && WhitelistedPlayers.CheckForPlayer(finalNameToAdd)) {
+                event.replyEmbeds(embedBuilderWhitelistSuccess.build()).queue();
+
+                // For instructional message
+                successfulWhitelist.set(true);
+
+                //Assign perms:
+                DiscordClient.AssignPerms(finalNameToAdd);
+
+                if (DiscordWhitelister.useOnWhitelistCommands) {
+                    List<String> commandsToExecute = DiscordWhitelister.onWhitelistCommandsConfig.getFileConfiguration().getStringList("on-whitelist-commands");
+                    for (String command : commandsToExecute) {
+                        DiscordClient.CheckAndExecuteCommand(command, finalNameToAdd);
+                    }
+                }
+
+                if (DiscordClient.whitelistedRoleAutoAdd) {
+                    List<Role> whitelistRoles = new LinkedList<>();
+                    try {
+                        if (!DiscordWhitelister.useIdForRoles) {
+                            for (String whitelistedRoleName : DiscordClient.whitelistedRoleNames) {
+                                // Use channel, get guild instead of JDA so that it is guild specific
+                                List<Role> rolesFoundWithName = channel.getGuild().getRolesByName(whitelistedRoleName, false);
+                                whitelistRoles.addAll(rolesFoundWithName);
+                            }
+                        } else {
+                            for (String whitelistedRoleName : DiscordClient.whitelistedRoleNames) {
+                                if (channel.getGuild().getRoleById(whitelistedRoleName) != null)
+                                    whitelistRoles.add(channel.getGuild().getRoleById(whitelistedRoleName));
+                            }
+                        }
+
+                        if (!whitelistRoles.isEmpty()) {
+                            whitelistRoles.forEach(role ->
+                            {
+                                member.getGuild().addRoleToMember(suppliedMember, role).queue();
+                            });
+                        }
+                    } catch (Exception e) {
+                        DiscordWhitelister.getPlugin().getLogger().severe("Could not add role with name/id to " + suppliedMember.getEffectiveName() + ", check the config and that the bot has the Manage Roles permission");
+
+                        e.printStackTrace();
+                    }
+
+                    // Instructional message
+                    if (successfulWhitelist.get()) {
+                        if (DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("send-instructional-message-on-whitelist")) {
+                            if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-timer-for-instructional-message")) {
+                                event.replyEmbeds(DiscordClient.CreateInstructionalMessage()).queue();
+                            } else {
+                                int waitTime = DiscordWhitelister.mainConfig.getFileConfiguration().getInt("timer-wait-time-in-seconds");
+
+                                // Run on a new thread to not block main thread
+                                Thread whitelisterTimerThread = new Thread(() ->
+                                {
+                                    try {
+                                        TimeUnit.SECONDS.sleep(waitTime);
+                                        event.replyEmbeds(DiscordClient.CreateInstructionalMessage()).queue();
+                                    } catch (InterruptedException e) {
+                                        e.printStackTrace();
+                                    }
+                                });
+
+                                whitelisterTimerThread.start();
+                            }
+                        }
+                    }
+                }
+
+                UserList.addRegisteredUser(suppliedMember.getId(), finalNameToAdd.toLowerCase());
+
+                DiscordWhitelister.getPluginLogger().info(author.getName() + "(" + author.getId() + ") successfully added " + finalNameToAdd
+                        + " to the whitelist and linked " + finalNameToAdd + " to " + suppliedMember.getEffectiveName() + "(" + suppliedMember.getId() + ").");
+            } else {
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderWhitelistFailure.build());
+            }
+            return null;
+        });
+    }
+
+    public static void ExecuteCommand(SlashCommandInteractionEvent event, String mc_user) {
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getChannel().asTextChannel();
+        Member member = event.getMember();
+
+        int timesWhitelisted =0;
+        final String finalNameToAdd = mc_user;
+        final char[] finalNameToWhitelistChar = finalNameToAdd.toLowerCase().toCharArray(); // Lower case for char check
+        boolean onlyHasLimitedAdd = false;
+        if (DiscordClient.usernameValidation) {
+            // Invalid char check
+            for (char c : finalNameToWhitelistChar) {
+                if (new String(DiscordClient.validCharacters).indexOf(c) == -1) {
+                    EmbedBuilder embedBuilderInvalidChar;
+
+                    if (!DiscordWhitelister.useCustomMessages) {
+                        embedBuilderInvalidChar = DiscordClient.CreateEmbeddedMessage("Invalid Username", (author.getAsMention() + ", the username you have specified contains invalid characters. **Only letters, numbers and underscores are allowed**."), DiscordClient.EmbedMessageType.FAILURE);
+                    } else {
+                        String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-characters-warning-title");
+                        String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-characters-warning");
+                        customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+
+                        embedBuilderInvalidChar = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                    }
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderInvalidChar.build());
+                    return;
+                }
+            }
+
+            // Length check
+            if (finalNameToAdd.length() < 3 || finalNameToAdd.length() > 16) {
+                EmbedBuilder embedBuilderLengthInvalid;
+
+                if (!DiscordWhitelister.useCustomMessages) {
+                    embedBuilderLengthInvalid = DiscordClient.CreateEmbeddedMessage("Invalid Username", (author.getAsMention() + ", the username you have specified either contains too few or too many characters. **Usernames can only consist of 3-16 characters**."), DiscordClient.EmbedMessageType.FAILURE);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-length-warning-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("invalid-length-warning");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+
+                    embedBuilderLengthInvalid = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                }
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderLengthInvalid.build());
+                return;
+            }
+        }
+
+        if (authorPermissions.isUserCanAddRemove() || authorPermissions.isUserCanAdd()) {
+
+
+            // runs after member null check
+
+            DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") attempted to whitelist: " + finalNameToAdd);
+
+        } else if (authorPermissions.isUserHasLimitedAdd() && DiscordClient.limitedWhitelistEnabled) {
+            onlyHasLimitedAdd = true;
+            if (DiscordWhitelister.useOnBanEvents && authorPermissions.isUserIsBanned()) {
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed =
+                            DiscordClient.CreateEmbeddedMessage("You have been banned!", (author.getAsMention() + ", you cannot use this bot as you have been banned!"), DiscordClient.EmbedMessageType.FAILURE).build();
+
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("banned-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("banned-message");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention()); // Only checking for {Sender}
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+                return;
+            }
+                /* if limited whitelist is enabled, check if the user is in the limited whitelister group and add the user to the list
+                which records how many times the user has successfully used the whitelist command */
+            if (UserList.getUserList().getString(author.getId()) == null) {
+                UserList.getUserList().set(author.getId(), new ArrayList<String>());
+                UserList.SaveStore();
+            }
+            boolean usedAllWhitelists = false;
+            try {
+                usedAllWhitelists = UserList.getRegisteredUsersCount(author.getId()) >= DiscordClient.maxWhitelistAmount &&
+                        !authorPermissions.isUserCanAddRemove() && !authorPermissions.isUserCanAdd();
+            } catch (NullPointerException exception) {
+                exception.printStackTrace();
+            }
+            /*
+            todo:add this
+            MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("Insufficient Permissions",
+                        (author.getAsMention() + ", only staff members can manually link Discord IDs. Please only enter your Minecraft name."), DiscordClient.EmbedMessageType.FAILURE).build();
+
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                return;
+
+                if (onlyHasLimitedAdd) {
+                    DiscordClient.AddWhitelistRemainingCount(embedBuilderInvalidChar, timesWhitelisted);
+                }
+                if (onlyHasLimitedAdd) {
+                    DiscordClient.AddWhitelistRemainingCount(embedBuilderLengthInvalid, timesWhitelisted);
+                }
+
+             */
+
+            timesWhitelisted = UserList.getRegisteredUsersCount(author.getId());
+
+            // set to current max in case the max whitelist amount was changed
+            if (timesWhitelisted > DiscordClient.maxWhitelistAmount) {
+                timesWhitelisted = DiscordClient.maxWhitelistAmount;
+            }
+
+            if (usedAllWhitelists) {
+                if (!DiscordWhitelister.useCustomMessages) {
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage("No Whitelists Remaining", (author.getAsMention() + ", unable to whitelist. You have **" + (DiscordClient.maxWhitelistAmount - timesWhitelisted)
+                            + " out of " + DiscordClient.maxWhitelistAmount + "** whitelists remaining."), DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("no-whitelists-remaining-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("no-whitelists-remaining");
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{RemainingWhitelists}", String.valueOf((DiscordClient.maxWhitelistAmount - timesWhitelisted)));
+                    customMessage = customMessage.replaceAll("\\{MaxWhitelistAmount}", String.valueOf(DiscordClient.maxWhitelistAmount));
+
+                    MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO).build();
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+                }
+
+                return;
+            }
+
+            DiscordWhitelister.getPlugin().getLogger().info(author.getName() + "(" + author.getId() + ") attempted to whitelist: " + finalNameToAdd + ", " + (DiscordClient.maxWhitelistAmount - timesWhitelisted) + " whitelists remaining");
+
+
+        } else {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+            return;
+        }
+
+
+
+
+        boolean alreadyOnWhitelist = false;
+
+        if (WhitelistedPlayers.usingEasyWhitelist) {
+            if (WhitelistedPlayers.CheckForPlayerEasyWhitelist(finalNameToAdd)) {
+                alreadyOnWhitelist = true;
+            }
+        } else if (WhitelistedPlayers.CheckForPlayer(finalNameToAdd)) {
+            alreadyOnWhitelist = true;
+        }
+
+        if (alreadyOnWhitelist) {
+            if (!DiscordWhitelister.useCustomMessages) {
+                MessageEmbed messageEmbed =
+                        DiscordClient.CreateEmbeddedMessage("User already on the whitelist",
+                                (author.getAsMention() + ", cannot add user as `" + finalNameToAdd + "` is already on the whitelist!"), DiscordClient.EmbedMessageType.INFO).build();
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+            } else {
+                String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("already-on-whitelist-title");
+                String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("already-on-whitelist");
+                customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+                MessageEmbed messageEmbed = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.INFO).build();
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+            }
+            return;
+        }
+
+        if (RemovedList.CheckStoreForPlayer(finalNameToAdd)) // If the user has been removed before
+        {
+            if (onlyHasLimitedAdd) {
+                EmbedBuilder embedBuilderRemovedByStaff;
+
+                if (!DiscordWhitelister.useCustomMessages) {
+                    embedBuilderRemovedByStaff = DiscordClient.CreateEmbeddedMessage("This user was previously removed by a staff member",
+                            (author.getAsMention() + ", this user was previously removed by a staff member (<@" + RemovedList.getRemovedPlayers().get(finalNameToAdd.toLowerCase()) + ">).\n" +
+                                    "Please ask a user with higher permissions to add this user.\n"), DiscordClient.EmbedMessageType.FAILURE);
+                } else {
+                    String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed-title");
+                    String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed");
+                    String staffMemberMention = "<@" + RemovedList.getRemovedPlayers().get(finalNameToAdd.toLowerCase()) + ">";
+
+                    customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                    customMessage = customMessage.replaceAll("\\{StaffMember}", staffMemberMention);
+
+                    embedBuilderRemovedByStaff = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                }
+
+                DiscordClient.AddWhitelistRemainingCount(embedBuilderRemovedByStaff, timesWhitelisted);
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderRemovedByStaff.build());
+                return;
+            } else {
+                RemovedList.getRemovedPlayers().set(finalNameToAdd.toLowerCase(), null);
+                RemovedList.SaveStore();
+
+                DiscordWhitelister.getPlugin().getLogger().info(finalNameToAdd + " has been removed from the removed list by " + author.getName() + "(" + author.getId() + ")");
+            }
+        }
+
+        // In-game list check
+        if (DiscordWhitelister.useInGameAddRemoves) {
+            if (InGameRemovedList.CheckStoreForPlayer(finalNameToAdd.toLowerCase())) {
+                if (onlyHasLimitedAdd) {
+                    EmbedBuilder embedBuilderRemovedByInGameStaff;
+
+                    if (!DiscordWhitelister.useCustomMessages) {
+                        embedBuilderRemovedByInGameStaff = DiscordClient.CreateEmbeddedMessage("This user was previously removed by a staff member",
+                                (author.getAsMention() + ", this user was previously removed by a staff member in-game (" + InGameRemovedList.getRemovedPlayers().get(finalNameToAdd.toLowerCase()) + ").\n" +
+                                        "Please ask a user with higher permissions to add this user.\n"), DiscordClient.EmbedMessageType.FAILURE);
+                    } else {
+                        String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed-in-game-title");
+                        String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("user-was-removed-in-game");
+                        String inGameStaffMember = InGameRemovedList.getRemovedPlayers().getString(finalNameToAdd.toLowerCase());
+
+                        customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+                        customMessage = customMessage.replaceAll("\\{StaffMember}", inGameStaffMember);
+
+                        embedBuilderRemovedByInGameStaff = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+                    }
+
+                    DiscordClient.AddWhitelistRemainingCount(embedBuilderRemovedByInGameStaff, timesWhitelisted);
+
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderRemovedByInGameStaff.build());
+                    return;
+                } else {
+                    InGameRemovedList.RemoveUserFromStore(finalNameToAdd.toLowerCase());
+
+                    DiscordWhitelister.getPlugin().getLogger().info(finalNameToAdd + " has been removed from in-game-removed-list.yml by " + author.getName() + "(" + author.getId() + ")");
+                }
+            }
+        }
+
+                /* Do as much as possible off the main server thread.
+                convert username into UUID to avoid depreciation and rate limits (according to https://minotar.net/) */
+        String playerUUID = DiscordClient.minecraftUsernameToUUID(finalNameToAdd);
+        final boolean invalidMinecraftName = playerUUID == null;
+
+                /* Configure success & failure messages here instead of on the main server thread -
+                this will run even if the message is never sent, but is a good trade off */
+        EmbedBuilder embedBuilderWhitelistSuccess;
+
+        if (!DiscordWhitelister.useCustomMessages) {
+            embedBuilderWhitelistSuccess = DiscordClient.CreateEmbeddedMessage((finalNameToAdd + " is now whitelisted!"), (author.getAsMention() + " has added `" + finalNameToAdd + "` to the whitelist."), DiscordClient.EmbedMessageType.SUCCESS);
+        } else {
+            String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-success-title");
+            customTitle = customTitle.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+            String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-success");
+            customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+            customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+            embedBuilderWhitelistSuccess = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.SUCCESS);
+        }
+
+        if (onlyHasLimitedAdd)
+            DiscordClient.AddWhitelistRemainingCount(embedBuilderWhitelistSuccess, (timesWhitelisted + 1));
+
+        if (DiscordWhitelister.showPlayerSkin) {
+            if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-crafatar-for-avatars"))
+                embedBuilderWhitelistSuccess.setThumbnail("https://minotar.net/armor/bust/" + playerUUID + "/100.png");
+            else
+                embedBuilderWhitelistSuccess.setThumbnail("https://crafatar.com/avatars/" + playerUUID + "?size=100&default=MHF_Steve&overlay.png");
+        }
+
+        EmbedBuilder embedBuilderWhitelistFailure;
+
+        if (!DiscordWhitelister.useCustomMessages) {
+            embedBuilderWhitelistFailure = DiscordClient.CreateEmbeddedMessage("Failed to whitelist",
+                    (author.getAsMention() + ", failed to add `" + finalNameToAdd + "` to the whitelist. This is most likely due to an invalid Minecraft username."), DiscordClient.EmbedMessageType.FAILURE);
+        } else {
+            String customTitle = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-failure-title");
+
+            String customMessage = DiscordWhitelister.getCustomMessagesConfig().getString("whitelist-failure");
+            customMessage = customMessage.replaceAll("\\{Sender}", author.getAsMention());
+            customMessage = customMessage.replaceAll("\\{MinecraftUsername}", finalNameToAdd);
+
+            embedBuilderWhitelistFailure = DiscordClient.CreateEmbeddedMessage(customTitle, customMessage, DiscordClient.EmbedMessageType.FAILURE);
+        }
+
+        if (onlyHasLimitedAdd)
+            DiscordClient.AddWhitelistRemainingCount(embedBuilderWhitelistFailure, timesWhitelisted); // was timesWhitelisted + 1 for some reason, change back if it doesn't work correctly
+
+        int tempTimesWhitelisted = timesWhitelisted;
+        if (onlyHasLimitedAdd && tempTimesWhitelisted < DiscordClient.maxWhitelistAmount)
+            tempTimesWhitelisted = timesWhitelisted + 1;
+        final int finalTimesWhitelisted = tempTimesWhitelisted; // if successful
+
+        AtomicBoolean successfulWhitelist = new AtomicBoolean(false);
+
+        if (!WhitelistedPlayers.usingEasyWhitelist && authorPermissions.isUserCanUseCommand())
+            DiscordClient.ExecuteServerCommand("whitelist add " + finalNameToAdd);
+        if (DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-geyser/floodgate-compatibility")) {
+            addBedrockUser(finalNameToAdd);
+        }
+
+        // have to use !invalidMinecraftName else the easy whitelist plugin will add the name regardless of whether it is valid on not
+        if (WhitelistedPlayers.usingEasyWhitelist && !invalidMinecraftName && authorPermissions.isUserCanUseCommand())
+            DiscordClient.ExecuteServerCommand("easywl add " + finalNameToAdd);
+
+        boolean finalOnlyHasLimitedAdd = onlyHasLimitedAdd;
+        DiscordWhitelister.getPlugin().getServer().getScheduler().callSyncMethod(DiscordWhitelister.getPlugin(), () ->
+        {
+            if (WhitelistedPlayers.usingEasyWhitelist && !invalidMinecraftName && WhitelistedPlayers.CheckForPlayerEasyWhitelist(finalNameToAdd)
+                    || !WhitelistedPlayers.usingEasyWhitelist && WhitelistedPlayers.CheckForPlayer(finalNameToAdd)) {
+                event.replyEmbeds(embedBuilderWhitelistSuccess.build()).queue();
+
+                // For instructional message
+                successfulWhitelist.set(true);
+
+                //Assign perms:
+                DiscordClient.AssignPerms(finalNameToAdd);
+
+                if (DiscordWhitelister.useOnWhitelistCommands) {
+                    List<String> commandsToExecute = DiscordWhitelister.onWhitelistCommandsConfig.getFileConfiguration().getStringList("on-whitelist-commands");
+                    for (String command : commandsToExecute) {
+                        DiscordClient.CheckAndExecuteCommand(command, finalNameToAdd);
+                    }
+                }
+
+                if (DiscordClient.whitelistedRoleAutoAdd) {
+                    List<Role> whitelistRoles = new LinkedList<>();
+                    try {
+                        if (!DiscordWhitelister.useIdForRoles) {
+                            for (String whitelistedRoleName : DiscordClient.whitelistedRoleNames) {
+                                // Use channel, get guild instead of JDA so that it is guild specific
+                                List<Role> rolesFoundWithName = channel.getGuild().getRolesByName(whitelistedRoleName, false);
+                                whitelistRoles.addAll(rolesFoundWithName);
+                            }
+                        } else {
+                            for (String whitelistedRoleName : DiscordClient.whitelistedRoleNames) {
+                                if (channel.getGuild().getRoleById(whitelistedRoleName) != null)
+                                    whitelistRoles.add(channel.getGuild().getRoleById(whitelistedRoleName));
+                            }
+                        }
+
+                        if (!whitelistRoles.isEmpty()) {
+                            whitelistRoles.forEach(role ->
+                            {
+                                member.getGuild().addRoleToMember(member, role).queue();
+                            });
+                        }
+                    } catch (Exception e) {
+                        DiscordWhitelister.getPlugin().getLogger().severe("Could not add role with name/id to " + author.getName() + ", check the config and that the bot has the Manage Roles permission");
+
+                        e.printStackTrace();
+                    }
+
+                    // Instructional message
+                    if (successfulWhitelist.get()) {
+                        if (DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("send-instructional-message-on-whitelist")) {
+                            if (!DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-timer-for-instructional-message")) {
+                                channel.sendMessageEmbeds(DiscordClient.CreateInstructionalMessage()).queue();
+                            } else {
+                                int waitTime = DiscordWhitelister.mainConfig.getFileConfiguration().getInt("timer-wait-time-in-seconds");
+
+                                // Run on a new thread to not block main thread
+                                Thread whitelisterTimerThread = new Thread(() ->
+                                {
+                                    try {
+                                        TimeUnit.SECONDS.sleep(waitTime);
+                                        channel.sendMessageEmbeds(DiscordClient.CreateInstructionalMessage()).queue();
+                                    } catch (InterruptedException e) {
+                                        e.printStackTrace();
+                                    }
+                                });
+
+                                whitelisterTimerThread.start();
+                            }
+                        }
+                    }
+                }
+
+                if (finalOnlyHasLimitedAdd) {
+                    UserList.addRegisteredUser(author.getId(), finalNameToAdd.toLowerCase()); // convert to lower case for remove & clearname commands
+
+                    DiscordWhitelister.getPluginLogger().info(author.getName() + "(" + author.getId() + ") successfully added " + finalNameToAdd
+                            + " to the whitelist, " + (DiscordClient.maxWhitelistAmount - finalTimesWhitelisted) + " whitelists remaining.");
+                }
+            } else {
+                DiscordClient.ReplyAndRemoveAfterSeconds(event, embedBuilderWhitelistFailure.build());
+            }
+            return null;
+        });
+    }
+
+    private static void addBedrockUser(String finalNameToAdd) {
+        String bedrockPrefix = DiscordWhitelister.mainConfig.getFileConfiguration().getString("geyser/floodgate prefix");
+        String bedrockName = bedrockPrefix + finalNameToAdd;
+        if (bedrockName.length() > 16) {
+            bedrockName = bedrockName.substring(0, 16);
+        }
+        //check if we actually NEED to add
+        if (finalNameToAdd.length() < bedrockPrefix.length() || !finalNameToAdd.substring(0, bedrockPrefix.length() - 1).equals(bedrockPrefix)) {
+            DiscordClient.ExecuteServerCommand("whitelist add " + bedrockName);
+        }
+    }
+
+    private static boolean checkMcUsername(String nameToCheck) {
+        if (DiscordClient.usernameValidation) {
+            // Length check
+            if (nameToCheck.length() < 3 || nameToCheck.length() > 16) {
+                return false;
+            }
+            // Invalid char check
+            for (char c : nameToCheck.toCharArray()) {
+                if (new String(DiscordClient.validCharacters).indexOf(c) == -1) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,121 @@
+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 net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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(SlashCommandInteractionEvent event) {
+        // Clear whitelists for limited-whitelisters
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getChannel().asTextChannel();
+
+        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.User;
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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(SlashCommandInteractionEvent event, String mc_user) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getChannel().asTextChannel();
+
+
+        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,119 @@
+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.User;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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(SlashCommandInteractionEvent 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

@@ -0,0 +1,26 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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(SlashCommandInteractionEvent event)
+    {
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+
+        if (authorPermissions.isUserCanUseCommand())
+        {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.botInfo);
+        }
+        else
+        {
+            DiscordClient.ReplyAndRemoveAfterSeconds(event, DiscordClient.CreateInsufficientPermsMessage(author));
+        }
+        
+    }
+}

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

@@ -0,0 +1,201 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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(SlashCommandInteractionEvent event, String mc_name) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getChannel().asTextChannel();
+        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

@@ -0,0 +1,87 @@
+package uk.co.angrybee.joe.commands.discord;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+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 net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import java.util.*;
+public class CommandWhoIs {
+    public static void ExecuteCommand(SlashCommandInteractionEvent event, String mc_name) {
+
+        AuthorPermissions authorPermissions = new AuthorPermissions(event);
+        User author = event.getUser();
+        TextChannel channel = event.getChannel().asTextChannel();
+
+        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);
+        for (
+                String discordId : keys) {
+            List<?> registeredUsers = UserList.getRegisteredUsers(discordId);
+            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) {
+                        if (targetWhitelistedPlayer instanceof String)
+                            usersWhitelistedPlayers.append("- ").append((String) targetWhitelistedPlayer).append("\n");
+                    }
+
+                    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);
+
+                    User fetchedUser = DiscordClient.javaDiscordAPI.getUserById(discordId);
+
+                    if (fetchedUser != null)
+                        idFoundMessage.setThumbnail(fetchedUser.getAvatarUrl());
+                    else
+                        DiscordWhitelister.getPluginLogger().warning("Failed to fetch avatar linked to Discord ID: " + discordId);
+
+                    DiscordClient.ReplyAndRemoveAfterSeconds(event, idFoundMessage.build());
+                    idFound = true;
+                    break;
+                }
+            }
+        }
+        if (!idFound) {
+            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.ReplyAndRemoveAfterSeconds(event, messageEmbed);
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+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 net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+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(SlashCommandInteractionEvent 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/commands/minecraft/CommandAbout.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Commands;
+package uk.co.angrybee.joe.commands.minecraft;
 
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;

src/main/java/uk/co/angrybee/joe/commands/minecraft/CommandReload.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Commands;
+package uk.co.angrybee.joe.commands.minecraft;
 
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
@@ -39,8 +39,10 @@ public class CommandReload implements CommandExecutor
         {
             pluginLogger.info("Failed to re-initialize client");
             sender.sendMessage("[DW] Failed to reload Discord client (Reason: Failed to re-initialize client)");
+            DiscordWhitelister.initialized = false;
             return false;
         }
+        DiscordWhitelister.initialized = true;
 
         if(!DiscordWhitelister.botEnabled)
         {

src/main/java/uk/co/angrybee/joe/commands/minecraft/CommandStatus.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Commands;
+package uk.co.angrybee.joe.commands.minecraft;
 
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;

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

@@ -0,0 +1,70 @@
+package uk.co.angrybee.joe.configs;
+
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import uk.co.angrybee.joe.DiscordWhitelister;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Config {
+
+    protected String fileName;
+    protected File file;
+    protected FileConfiguration fileConfiguration;
+    protected boolean fileCreated = false;
+
+    public FileConfiguration getFileConfiguration() { return fileConfiguration; }
+
+
+    protected void CreateConfig()
+    {
+        try
+        {
+            file.createNewFile();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+
+        DiscordWhitelister.getPluginLogger().info("Created file " + fileName);
+        fileCreated = true;
+    }
+
+    protected void LoadConfigFile()
+    {
+        try
+        {
+            fileConfiguration.load(file);
+        }
+        catch (IOException | InvalidConfigurationException e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    protected void SaveConfig()
+    {
+        try
+        {
+            fileConfiguration.save(file.getPath());
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    public void CheckEntry(String entryName, Object passedValue)
+    {
+        if(fileConfiguration.get(entryName) == null)
+        {
+            fileConfiguration.set(entryName, passedValue);
+
+            if(!fileCreated)
+                DiscordWhitelister.getPluginLogger().warning("Entry '" + entryName + "' was not found, adding it to "+fileName);
+        }
+    }
+
+}

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

@@ -1,29 +1,22 @@
-package uk.co.angrybee.joe.Configs;
+package uk.co.angrybee.joe.configs;
 
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import uk.co.angrybee.joe.DiscordWhitelister;
 
 import java.io.File;
-import java.io.IOException;
 
 // custom-messages.yml
-public class CustomMessagesConfig
+public class CustomMessagesConfig extends Config
 {
-    private static File customMessagesFile;
-    private static FileConfiguration customMessagesConfig;
+    public CustomMessagesConfig(){
+        fileName = "custom-messages.yml";
+        file = new File(DiscordWhitelister.getPlugin().getDataFolder(), fileName);
+        fileConfiguration = new YamlConfiguration();
+    }
 
-    public static FileConfiguration getCustomMessagesConfig() { return customMessagesConfig; }
-
-    private static boolean customMessagesFileCreated = false;
-
-    public static void ConfigSetup()
+    public void ConfigSetup()
     {
-        customMessagesFile = new File(DiscordWhitelister.getPlugin().getDataFolder(), "custom-messages.yml");
-        customMessagesConfig = new YamlConfiguration();
-
-        if(!customMessagesFile.exists())
+        if(!file.exists())
             CreateConfig();
 
         LoadConfigFile();
@@ -31,34 +24,7 @@ public class CustomMessagesConfig
         SaveConfig();
     }
 
-    private static void CreateConfig()
-    {
-        try
-        {
-            customMessagesFile.createNewFile();
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-
-        DiscordWhitelister.getPluginLogger().info("Custom messages file created at: " + customMessagesFile.getPath());
-        customMessagesFileCreated = true;
-    }
-
-    private static void LoadConfigFile()
-    {
-        try
-        {
-            customMessagesConfig.load(customMessagesFile);
-        }
-        catch (IOException | InvalidConfigurationException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntries()
+    private void CheckEntries()
     {
         /* TODO: add a YAML comment (#) explaining the config file params
         NOTE: only {params} in the original messages will be evaluated. For example: using {MaxWhitelistAmount} in the "insufficient-permissions" String will not work as it was never in the original message.
@@ -66,7 +32,7 @@ public class CustomMessagesConfig
         {MinecraftUsername} == finalNameToAdd/Remove, {StaffMember} == DiscordWhitelister.getRemovedList().get(finalNameToAdd), {AddRemoveRoles} = DiscordWhitelister.getWhitelisterBotConfig().getList("add-remove-roles")
         Internal error messages & info messages will remain uneditable. No need to add custom remove failure messages as it should never happen */
 
-        if(customMessagesFile.exists())
+        if(file.exists())
         {
             CheckEntry("insufficient-permissions-title", "Insufficient Permissions");
             CheckEntry("insufficient-permissions", "{Sender}, you do not have permission to use this command.");
@@ -123,36 +89,16 @@ public class CustomMessagesConfig
             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**.");
 
             CheckEntry("whitelist-clear-failure-title",  "No Entries to Remove");
             CheckEntry("whitelist-clear-failure-message", "{Sender}, you do not have any whitelisted entries to remove. ");
-        }
-    }
 
-    private static void SaveConfig()
-    {
-        try
-        {
-            customMessagesConfig.save(customMessagesFile.getPath());
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntry(String entryName, Object passedValue)
-    {
-        if(customMessagesConfig.get(entryName) == null)
-        {
-            customMessagesConfig.set(entryName, passedValue);
-
-            if(!customMessagesFileCreated)
-                DiscordWhitelister.getPluginLogger().warning("Entry '" + entryName + "' was not found, adding it to custom-messages.yml...");
+            CheckEntry("command-channel-title", "This Channel is for Commands Only");
+            CheckEntry("command-channel-message", "{Sender}, this channel is for commands only, please use another channel.");
         }
     }
 }

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

@@ -0,0 +1,47 @@
+package uk.co.angrybee.joe.configs;
+
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import uk.co.angrybee.joe.DiscordWhitelister;
+
+import java.io.File;
+import java.io.IOException;
+
+// custom-prefixes.yml
+public class CustomPrefixConfig extends Config
+{
+    public CustomPrefixConfig() {
+        file = new File(DiscordWhitelister.getPlugin().getDataFolder(), "custom-prefixes.yml");
+        fileConfiguration = new YamlConfiguration();
+    }
+
+    public void ConfigSetup()
+    {
+
+
+        if(!file.exists())
+            CreateConfig();
+
+        LoadConfigFile();
+        CheckEntries();
+        SaveConfig();
+    }
+
+    private void CheckEntries()
+    {
+        if(file.exists())
+        {
+            CheckEntry("whitelist-add-prefix", "/whitelist add");
+
+            CheckEntry("whitelist-remove-prefix", "/whitelist remove");
+
+            CheckEntry("clear-name-prefix", "/clearname");
+
+            CheckEntry("limited-whitelist-clear-prefix", "/whitelist clear");
+
+            CheckEntry("clear-ban-prefix", "!clearban");
+
+            CheckEntry("whitelist-whois-prefix", "/whitelist whois");
+        }
+    }
+}

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

@@ -1,6 +1,5 @@
-package uk.co.angrybee.joe.Configs;
+package uk.co.angrybee.joe.configs;
 
-import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import uk.co.angrybee.joe.DiscordWhitelister;
@@ -10,67 +9,45 @@ import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;
 
+
 // discord-whitelister.yml
-public class MainConfig
-{
-    private static File whitelisterBotConfigFile;
-    private static FileConfiguration whitelisterBotConfig;
+public class MainConfig extends Config {
+    public static String default_token = "Discord bot token goes here, you can find it here: https://discordapp.com/developers/applications/";
+    public MainConfig() {
+        fileName = "discord-whitelister.yml";
+        file = new File(DiscordWhitelister.getPlugin().getDataFolder(), fileName);
+        fileConfiguration = new YamlConfiguration();
+    }
 
-    public static FileConfiguration getMainConfig() { return whitelisterBotConfig; }
+    public FileConfiguration getFileConfiguration() {
+        return fileConfiguration;
+    }
 
-    public static boolean configCreated = false;
+    public boolean fileCreated = false;
+
+    public void ConfigSetup() {
 
-    public static void ConfigSetup()
-    {
-        whitelisterBotConfigFile = new File(DiscordWhitelister.getPlugin().getDataFolder(), "discord-whitelister.yml");
-        whitelisterBotConfig = new YamlConfiguration();
 
         // Create root folder for configs if it does not exist
-        if(!whitelisterBotConfigFile.getParentFile().exists())
-            whitelisterBotConfigFile.getParentFile().mkdirs();
+        if (!file.getParentFile().exists())
+            file.getParentFile().mkdirs();
 
-        if(!whitelisterBotConfigFile.exists())
+        if (!file.exists()) {
             CreateConfig();
-
+            DiscordWhitelister.getPluginLogger().warning("Configuration file created at: " + file.getPath() +
+                    ", please edit this else the plugin will not work!");
+        }
         LoadConfigFile();
         CheckEntries();
         SaveConfig();
     }
 
-    private static void CreateConfig()
-    {
-        try
-        {
-            whitelisterBotConfigFile.createNewFile();
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
 
-        DiscordWhitelister.getPluginLogger().info("Configuration file created at: " + whitelisterBotConfigFile.getPath() +
-                ", please edit this else the plugin will not work!");
-        configCreated = true;
-    }
-
-    private static void LoadConfigFile()
-    {
-        try
-        {
-            whitelisterBotConfig.load(whitelisterBotConfigFile);
-        }
-        catch (IOException | InvalidConfigurationException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntries()
-    {
+    private void CheckEntries() {
         CheckEntry("bot-enabled", true);
 
         CheckEntry("discord-bot-token",
-                "Discord bot token goes here, you can find it here: https://discordapp.com/developers/applications/" );
+                default_token);
 
         CheckEntry("use-id-for-roles", false);
 
@@ -133,6 +110,8 @@ public class MainConfig
 
         CheckEntry("assign-perms-with-ultra-perms", false);
 
+        CheckEntry("assign-perms-with-luck-perms", false);
+
         CheckEntry("use-on-whitelist-commands", false);
 
         CheckEntry("send-instructional-message-on-whitelist", false);
@@ -143,46 +122,43 @@ public class MainConfig
 
         CheckEntry("un-whitelist-on-server-leave", true);
 
+        CheckEntry("remove-unnecessary-messages-from-whitelist-channel", false);
+
+        CheckEntry("seconds-to-remove-message-from-whitelist-channel", 5);
+
+        CheckEntry("set-removed-message-colour-to-red", false);
+
+        CheckEntry("show-warning-in-command-channel", false);
+
+        CheckEntry("hide-info-command-replies", false);
+
+        CheckEntry("use-crafatar-for-avatars", false);
+
+        CheckEntry("use-geyser/floodgate-compatibility", false);
+
+        CheckEntry("geyser/floodgate prefix", "SetThisToWhateverPrefixYouUse");
+
+        CheckEntry("un-whitelist-if-missing-role", false);
+
+        CheckEntry("check-all-roles", false);
+
+        CheckEntry("role-to-check-for", "Twitch Subscriber");
+
         // Remove old role entry if found, move role to new array (for people with v1.3.6 or below)
-        if(whitelisterBotConfig.get("whitelisted-role") != null)
-        {
+        if (fileConfiguration.get("whitelisted-role") != null) {
             DiscordWhitelister.getPluginLogger().warning("Found whitelisted-role entry, moving over to whitelisted-roles. Please check your config to make sure the change is correct");
             // Get the role from the old entry
-            String whitelistedRoleTemp = whitelisterBotConfig.getString("whitelisted-role");
+            String whitelistedRoleTemp = fileConfiguration.getString("whitelisted-role");
             // Assign role from old entry to new entry as a list
-            whitelisterBotConfig.set("whitelisted-roles", Collections.singletonList(whitelistedRoleTemp));
+            fileConfiguration.set("whitelisted-roles", Collections.singletonList(whitelistedRoleTemp));
 
             // Remove now un-used entry
-            whitelisterBotConfig.set("whitelisted-role", null);
+            fileConfiguration.set("whitelisted-role", null);
 
             // Note to users that id for roles now affects the new entry
-            if(whitelisterBotConfig.getBoolean("use-id-for-roles"))
-            {
+            if (fileConfiguration.getBoolean("use-id-for-roles")) {
                 DiscordWhitelister.getPluginLogger().severe("You have 'use-id-for-roles' enabled please change the whitelisted-roles to ids as they now follow this setting");
             }
         }
     }
-
-    private static void SaveConfig()
-    {
-        try
-        {
-            whitelisterBotConfig.save(whitelisterBotConfigFile.getPath());
-        }
-        catch (IOException e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    private static void CheckEntry(String entryName, Object passedValue)
-    {
-        if(whitelisterBotConfig.get(entryName) == null)
-        {
-            whitelisterBotConfig.set(entryName, passedValue);
-
-            if(!configCreated)
-                DiscordWhitelister.getPluginLogger().warning("Entry '" + entryName + "' was not found, adding it to the config...");
-        }
-    }
 }

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

@@ -0,0 +1,48 @@
+package uk.co.angrybee.joe.configs;
+import org.bukkit.configuration.file.YamlConfiguration;
+import uk.co.angrybee.joe.DiscordWhitelister;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class OnWhitelistCommandsConfig extends Config {
+    public OnWhitelistCommandsConfig() {
+        fileName = "on-whitelist-commands.yml";
+        file = new File(DiscordWhitelister.getPlugin().getDataFolder(), fileName);
+        fileConfiguration = new YamlConfiguration();
+    }
+
+    public void ConfigSetup() {
+        if (!file.exists())
+            CreateConfig();
+
+        LoadConfigFile();
+        CheckEntries();
+        SaveConfig();
+    }
+
+    private void CheckEntries() {
+        if (file.exists()) {
+            // Write comments
+            if (fileCreated) {
+                SaveConfig(); // save and load again
+                try {
+                    FileWriter fileWriter = new FileWriter(file);
+                    fileWriter.write("# The list of commands that will be dispatched when a player gets whitelisted. (Use the following syntax: \n"
+                            + "# \"%TYPE%:%COMMAND%\", being %TYPE% whether 'CONSOLE' or 'PLAYER' and the command without the slash (/)\n"
+                            + "# placeholder %PLAYER% is supported here).\n"
+                            + "# NOTE: The 'PLAYER' type will only work if the target whitelisted player is in the server at the time of command dispatch.");
+
+                    fileWriter.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                LoadConfigFile();
+            }
+
+            CheckEntry("on-whitelist-commands", Arrays.asList("CONSOLE:gamemode adventure %PLAYER%", "CONSOLE:say hello testing"));
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+package uk.co.angrybee.joe.configs;
+import org.bukkit.configuration.file.YamlConfiguration;
+import uk.co.angrybee.joe.DiscordWhitelister;
+
+import java.io.File;
+import java.util.Collections;
+
+public class PermissionsConfig extends Config {
+    public PermissionsConfig() {
+        fileName = "on-whitelist-permissions.yml";
+        file = new File(DiscordWhitelister.getPlugin().getDataFolder(), fileName);
+        fileConfiguration = new YamlConfiguration();
+    }
+
+    public void ConfigSetup() {
+        if (!file.exists())
+            CreateConfig();
+
+        LoadConfigFile();
+        CheckEntries();
+        SaveConfig();
+    }
+
+    private void CheckEntries() {
+        if (file.exists()) {
+            // test permission
+            CheckEntry("perms-on-whitelist", Collections.singletonList("bukkit.command.tps"));
+        }
+    }
+}

src/main/java/uk/co/angrybee/joe/events/EssentialsVanishEvents.java

@@ -0,0 +1,21 @@
+package uk.co.angrybee.joe.events;
+
+import net.ess3.api.events.VanishStatusChangeEvent;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+public class EssentialsVanishEvents implements Listener {
+
+    @EventHandler
+    public void onVanishStatusChangeEvent(VanishStatusChangeEvent event){
+        // If value is true (player just vanished)
+        if(event.getValue()) {
+            VanishEvents.onPlayerHide(event.getAffected().getDisplayName());
+        }
+        // If value is false (player just un-vanished)
+        else {
+            VanishEvents.onPlayerShow(event.getAffected().getDisplayName());
+        }
+    }
+
+}

src/main/java/uk/co/angrybee/joe/events/JoinLeaveEvents.java

@@ -1,5 +1,7 @@
-package uk.co.angrybee.joe.Events;
+package uk.co.angrybee.joe.events;
 
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventPriority;
 import uk.co.angrybee.joe.DiscordWhitelister;
 import uk.co.angrybee.joe.DiscordClient;
 
@@ -7,20 +9,20 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
+import uk.co.angrybee.joe.Utils;
 
 // Used for showing player count in the discord bots status
 public class JoinLeaveEvents implements Listener
 {
-    @EventHandler
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPlayerJoin(PlayerJoinEvent event)
     {
+        Player player = event.getPlayer();
         if(!DiscordWhitelister.showVanishedPlayersInCount)
         {
-            if(event.getPlayer().hasPermission("discordsrv.silentjoin")
-                    || event.getPlayer().hasPermission("discordsrv.silentquit")
-                    || event.getPlayer().hasPermission("sv.joinvanished"))
+            if(Utils.isVanished(player))
             {
-                DiscordWhitelister.getPlugin().getLogger().info("Player " + event.getPlayer().getDisplayName() + " joined with silent joining/quitting permission, not incrementing player count");
+                DiscordWhitelister.getPlugin().getLogger().info("Player " + player.getDisplayName() + " joined while vanished, not incrementing player count");
                 DiscordWhitelister.addVanishedPlayer();
                 return;
             }
@@ -28,16 +30,15 @@ public class JoinLeaveEvents implements Listener
         DiscordClient.SetPlayerCountStatus(DiscordWhitelister.getOnlineUsers());
     }
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void onPlayerLeave(PlayerQuitEvent event)
     {
+        Player player = event.getPlayer();
         if(!DiscordWhitelister.showVanishedPlayersInCount)
         {
-            if(event.getPlayer().hasPermission("discordsrv.silentjoin")
-                    || event.getPlayer().hasPermission("discordsrv.silentquit")
-                    || event.getPlayer().hasPermission("sv.joinvanished"))
+            if(Utils.isVanished(player))
             {
-                DiscordWhitelister.getPlugin().getLogger().info("Player " + event.getPlayer().getDisplayName() + " quit with silent joining/quitting permission, not decrementing player count");
+                DiscordWhitelister.getPlugin().getLogger().info("Player " + player.getDisplayName() + " quit while vanished, not decrementing player count");
                 DiscordWhitelister.removeVanishedPlayer();
                 return;
             }

src/main/java/uk/co/angrybee/joe/events/OnBanEvent.java

@@ -1,27 +1,21 @@
-package uk.co.angrybee.joe.Events;
+package uk.co.angrybee.joe.events;
 
+import net.dv8tion.jda.api.entities.Guild;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.yaml.snakeyaml.Yaml;
-import uk.co.angrybee.joe.Configs.MainConfig;
-import uk.co.angrybee.joe.Configs.PermissionsConfig;
+import uk.co.angrybee.joe.configs.MainConfig;
 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.UserList;
-import uk.co.angrybee.joe.Stores.WhitelistedPlayers;
+import uk.co.angrybee.joe.stores.InGameRemovedList;
+import uk.co.angrybee.joe.stores.UserList;
+import uk.co.angrybee.joe.stores.WhitelistedPlayers;
 
-import java.io.FileInputStream;
 import java.io.IOException;
-import java.io.InputStream;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 
 public class OnBanEvent implements Listener
@@ -94,72 +88,46 @@ public class OnBanEvent implements Listener
         if(!WhitelistedPlayers.usingEasyWhitelist && WhitelistedPlayers.CheckForPlayer(banTarget)
                 || WhitelistedPlayers.usingEasyWhitelist && WhitelistedPlayers.CheckForPlayerEasyWhitelist(banTarget))
         {
-            Boolean idFound = false;
-            String targetDiscordId = "";
-            List<String> targetWhitelistedPlayers = Collections.emptyList();
+            boolean idFound = false;
 
             // Find the Discord Id linked to the whitelisted player
-            Yaml userYaml = new Yaml();
-
-            InputStream inputStream = new FileInputStream(UserList.getUserListFile());
-
-            Map<String, List<String>> testObject = userYaml.load(inputStream);
-
-            for(Map.Entry<String, List<String>> entry : testObject.entrySet())
-            {
-                for(int i = 0; i < entry.getValue().size(); i++)
-                {
-                    if(entry.getValue().get(i).equals(banTarget))
+            Set<String> keys = UserList.getUserList().getKeys(false);
+            for (String discordId : keys) {
+                List<?> registeredUsers = UserList.getRegisteredUsers(discordId);
+                for (Object mc_name : registeredUsers) {
+                if(mc_name instanceof String && mc_name.equals(banTarget))
                     {
                         // Found the ban target, assign the corresponding Discord id
-                        targetDiscordId = entry.getKey();
-                        targetWhitelistedPlayers = entry.getValue();
+                        // Remove whitelisted players associated with the discord id
+                        for (Object targetWhitelistedPlayer : registeredUsers) {
+                            if (targetWhitelistedPlayer instanceof String){
+                                DiscordClient.UnWhitelist((String) mc_name);
+                                DiscordWhitelister.getPluginLogger().info("Removed " + targetWhitelistedPlayer
+                                        + " from the whitelist as they were added by Discord Id: " + discordId);
+
+                                // Add username to the in-game removed list
+                                InGameRemovedList.AddUserToStore((String) targetWhitelistedPlayer, commandCaller.getDisplayName());
+                            }
+                        }
+                        // Remove the users whitelisted players from the list
+                        UserList.getUserList().set(discordId, null);
+
+                        UserList.SaveStore();
+
+                        // Find all servers bot is in, assign & remove roles
+                        for(Guild guild: DiscordClient.javaDiscordAPI.getGuilds())
+                        {
+                            // Remove the whitelisted role(s)
+                            DiscordClient.RemoveRolesFromUser(guild, discordId, Arrays.asList(DiscordClient.whitelistedRoleNames));
+                            // Add the banned role(s)
+                            DiscordClient.AssignRolesToUser(guild, discordId, (List<String>) DiscordWhitelister.mainConfig.getFileConfiguration().get("banned-roles"));
+                        }
                         idFound = true;
+                        break;
                     }
                 }
             }
-
-            if(idFound)
-            {
-                // Remove whitelisted players associated with the discord id
-                for(int i = 0; i < targetWhitelistedPlayers.size(); i++)
-                {
-                    if(!WhitelistedPlayers.usingEasyWhitelist)
-                    {
-                        DiscordClient.ExecuteServerCommand("whitelist remove " + targetWhitelistedPlayers.get(i));
-                    }
-                    else
-                    {
-                        DiscordClient.ExecuteServerCommand("easywl remove " + targetWhitelistedPlayers.get(i));
-                    }
-
-                    DiscordWhitelister.getPluginLogger().info("Removed " + targetWhitelistedPlayers.get(i)
-                            + " from the whitelist as they were added by Discord Id: " + targetDiscordId);
-
-                    // Add username to the in-game removed list
-                    InGameRemovedList.AddUserToStore(targetWhitelistedPlayers.get(i), commandCaller.getDisplayName());
-                }
-
-                // Remove the users whitelisted players from the list
-                UserList.getUserList().set(targetDiscordId, null);
-
-                // Remove perms on ban if enabled
-                if(DiscordWhitelister.useUltraPerms)
-                    DiscordClient.RemovePermsFromUser(banTarget, PermissionsConfig.getPermissionsConfig().getStringList("perms-on-whitelist"));
-
-                UserList.SaveStore();
-
-                // Find all servers bot is in, assign & remove roles
-                for(int i = 0; i < DiscordClient.javaDiscordAPI.getGuilds().size(); i++)
-                {
-                    // Remove the whitelisted role(s)
-                    DiscordClient.RemoveRolesFromUser(DiscordClient.javaDiscordAPI.getGuilds().get(i), targetDiscordId, Arrays.asList(DiscordClient.whitelistedRoleNames));
-                    // Add the banned role(s)
-                    DiscordClient.AssignRolesToUser(DiscordClient.javaDiscordAPI.getGuilds().get(i), targetDiscordId, (List<String>) MainConfig.getMainConfig().get("banned-roles"));
-                }
-            }
-            else
-            {
+            if (!idFound) {
                 DiscordWhitelister.getPluginLogger().warning(banTarget + " does not have a linked Discord Id; cannot assign roles!");
             }
         }

src/main/java/uk/co/angrybee/joe/events/OnWhitelistEvents.java

@@ -1,13 +1,13 @@
-package uk.co.angrybee.joe.Events;
+package uk.co.angrybee.joe.events;
 
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import uk.co.angrybee.joe.DiscordWhitelister;
-import uk.co.angrybee.joe.Stores.InGameRemovedList;
-import uk.co.angrybee.joe.Stores.RemovedList;
-import uk.co.angrybee.joe.Stores.WhitelistedPlayers;
+import uk.co.angrybee.joe.stores.InGameRemovedList;
+import uk.co.angrybee.joe.stores.RemovedList;
+import uk.co.angrybee.joe.stores.WhitelistedPlayers;
 
 import java.io.File;
 

src/main/java/uk/co/angrybee/joe/events/ShutdownEvents.java

@@ -1,9 +1,8 @@
-package uk.co.angrybee.joe.Events;
+package uk.co.angrybee.joe.events;
 
-import net.dv8tion.jda.api.events.ShutdownEvent;
+import net.dv8tion.jda.api.events.session.ShutdownEvent;
 import net.dv8tion.jda.api.hooks.ListenerAdapter;
 import net.dv8tion.jda.api.requests.CloseCode;
-import uk.co.angrybee.joe.DiscordClient;
 import uk.co.angrybee.joe.DiscordWhitelister;
 
 public class ShutdownEvents extends ListenerAdapter
@@ -14,7 +13,7 @@ public class ShutdownEvents extends ListenerAdapter
         CheckIntents(shutdownEvent.getCloseCode());
     }
 
-    // Check for the 'SERVER MEMBERS INTENT' and inform users if not enabled
+    // Check for the 'SERVER MEMBERS INTENT' & 'MESSAGE_CONTENT' and inform users if not enabled
     private void CheckIntents(CloseCode closeCode)
     {
         if(closeCode == null)
@@ -23,7 +22,7 @@ public class ShutdownEvents extends ListenerAdapter
         if(closeCode == CloseCode.DISALLOWED_INTENTS)
         {
             DiscordWhitelister.getPluginLogger().severe("\u001B[31m" + "Cannot connect as this bot is not eligible to request the privileged intent 'GUILD_MEMBERS'" + "\u001B[0m");
-            DiscordWhitelister.getPluginLogger().severe( "\u001B[31m" + "To fix this, please enable 'SERVER MEMBERS INTENT' located " +
+            DiscordWhitelister.getPluginLogger().severe( "\u001B[31m" + "To fix this, please enable 'SERVER MEMBERS INTENT' & 'MESSAGE_CONTENT' located " +
                     "at https://discord.com/developers/applications -> the application you're using to run this bot -> the button called 'bot' on the left" + "\u001B[0m");
         }
     }

src/main/java/uk/co/angrybee/joe/events/SuperVanishEvents.java

@@ -0,0 +1,21 @@
+package uk.co.angrybee.joe.events;
+
+import de.myzelyam.api.vanish.PlayerHideEvent;
+import de.myzelyam.api.vanish.PlayerShowEvent;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import uk.co.angrybee.joe.DiscordWhitelister;
+
+public class SuperVanishEvents implements Listener {
+
+    @EventHandler
+    public void onPlayerShowEvent(PlayerShowEvent event){
+        VanishEvents.onPlayerShow(event.getPlayer().getDisplayName());
+    }
+
+    @EventHandler
+    public void onPlayerHideEvent(PlayerHideEvent event){
+        VanishEvents.onPlayerHide(event.getPlayer().getDisplayName());
+    }
+
+}

src/main/java/uk/co/angrybee/joe/events/VanishEvents.java

@@ -0,0 +1,25 @@
+package uk.co.angrybee.joe.events;
+
+import uk.co.angrybee.joe.DiscordClient;
+import uk.co.angrybee.joe.DiscordWhitelister;
+
+public class VanishEvents {
+
+    // Called when a player exits vanished mode
+    public static void onPlayerShow(String playerName) {
+        if(!DiscordWhitelister.showVanishedPlayersInCount) {
+            DiscordWhitelister.getPlugin().getLogger().info("Player " + playerName + " un-vanished, incrementing player count");
+            DiscordWhitelister.removeVanishedPlayer();
+            DiscordClient.SetPlayerCountStatus(DiscordWhitelister.getOnlineUsers());
+        }
+    }
+
+    // Called when a player enters vanished mode
+    public static void onPlayerHide(String playerName) {
+        if(!DiscordWhitelister.showVanishedPlayersInCount) {
+            DiscordWhitelister.getPlugin().getLogger().info("Player " + playerName + " vanished, decrementing player count");
+            DiscordWhitelister.addVanishedPlayer();
+            DiscordClient.SetPlayerCountStatus(DiscordWhitelister.getOnlineUsers());
+        }
+    }
+}

src/main/java/uk/co/angrybee/joe/events/VanishNoPacketEvents.java

@@ -0,0 +1,21 @@
+package uk.co.angrybee.joe.events;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.kitteh.vanish.event.VanishStatusChangeEvent;
+
+public class VanishNoPacketEvents implements Listener {
+
+    @EventHandler
+    public void onVanishStatusChangeEvent(VanishStatusChangeEvent event){
+        // If value is true (player just vanished)
+        if(event.isVanishing()) {
+            VanishEvents.onPlayerHide(event.getPlayer().getDisplayName());
+        }
+        // If value is false (player just un-vanished)
+        else {
+            VanishEvents.onPlayerShow(event.getPlayer().getDisplayName());
+        }
+    }
+
+}

src/main/java/uk/co/angrybee/joe/stores/InGameRemovedList.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Stores;
+package uk.co.angrybee.joe.stores;
 
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;

src/main/java/uk/co/angrybee/joe/stores/RemovedList.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Stores;
+package uk.co.angrybee.joe.stores;
 
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
@@ -70,6 +70,9 @@ public class RemovedList
     // Returns true if the player is in the store/list
     public static boolean CheckStoreForPlayer(String nameToCheck)
     {
+        // Removed list is case-insensitive, can change in the future if needed
+        nameToCheck = nameToCheck.toLowerCase();
+
         LoadStore();
         return removedPlayersConfig.get(nameToCheck) != null;
     }

src/main/java/uk/co/angrybee/joe/stores/UserList.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Stores;
+package uk.co.angrybee.joe.stores;
 
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;

src/main/java/uk/co/angrybee/joe/stores/WhitelistedPlayers.java

@@ -1,4 +1,4 @@
-package uk.co.angrybee.joe.Stores;
+package uk.co.angrybee.joe.stores;
 
 import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
@@ -7,7 +7,7 @@ import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
-import uk.co.angrybee.joe.Configs.MainConfig;
+import uk.co.angrybee.joe.configs.MainConfig;
 import uk.co.angrybee.joe.DiscordWhitelister;
 
 import java.io.File;
@@ -29,7 +29,7 @@ public class WhitelistedPlayers
     public static void Setup()
     {
         // Check if we are using EasyWhitelist
-        if(MainConfig.getMainConfig().getBoolean("use-easy-whitelist"))
+        if(DiscordWhitelister.mainConfig.getFileConfiguration().getBoolean("use-easy-whitelist"))
             GetEasyWhitelist();
 
         if(usingEasyWhitelist)

src/main/resources/logback.xml

@@ -1,12 +1,18 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<configuration>
-    <appender name="STDOUT" class="uk.co.angrybee.joe.shaded.ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>[DiscordWhitelister] %boldCyan(%-34.-34thread) %red(%10.10X{jda.shard}) %boldGreen(%-15.-15logger{0}) %highlight(%-6level) %msg%n</pattern>
-        </encoder>
-    </appender>
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE configuration>
+
+<configuration>
+<import class="uk.co.angrybee.joe.shaded.ch.qos.logback.classic.encoder.PatternLayoutEncoder"/>
+<import class="uk.co.angrybee.joe.shaded.ch.qos.logback.core.ConsoleAppender"/>
+
+<appender name="STDOUT" class="uk.co.angrybee.joe.shaded.ch.qos.logback.core.ConsoleAppender">
+    <append>true</append>
+    <immediateFlush>true</immediateFlush>
+    <encoder class="PatternLayoutEncoder">
+<!--        <pattern>[DiscordWhitelister] %boldCyan(%-34.-34thread) %red(%10.10X{jda.shard}) %boldGreen(%-15.-15logger{0}) %highlight(%-6level) %msg%n</pattern>-->
+        <pattern>[DiscordWhitelister] %msg%n</pattern>
+    </encoder>
+</appender>
+
+</configuration>
 
-    <root level="info">
-        <appender-ref ref="STDOUT" />
-    </root>
-</configuration>

src/main/resources/plugin.yml

@@ -1,8 +1,10 @@
 name: DiscordWhitelister
-version: 1.4.2
+version: 1.5.1
+api-version: 1.19
 author: Joe Shimell
 main: uk.co.angrybee.joe.DiscordWhitelister
 description: Discord Whitelister.
+softdepend: [Essentials, SuperVanish, VanishNoPacket]
 commands:
   discordwhitelister:
     description: See info about this plugin