Various code householding

- Adjust javadoc
- Remove unused PlayerAuth constructor
- Replace legacy Settings with NewSetting calls
- Add process service to all (a)sync processes
- Change IP manager to only cache the calls to the VeryGames API

src/main/java/fr/xephi/authme/AuthMe.java

@@ -52,6 +52,7 @@ import fr.xephi.authme.settings.properties.DatabaseSettings;
 import fr.xephi.authme.settings.properties.EmailSettings;
 import fr.xephi.authme.settings.properties.HooksSettings;
 import fr.xephi.authme.settings.properties.PluginSettings;
+import fr.xephi.authme.settings.properties.PurgeSettings;
 import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.util.CollectionUtils;
@@ -301,7 +302,8 @@ public class AuthMe extends JavaPlugin {
         setupApi();
 
         // Set up the management
-        ProcessService processService = new ProcessService(newSettings, messages, this, ipAddressManager);
+        ProcessService processService = new ProcessService(newSettings, messages, this, ipAddressManager,
+            passwordSecurity);
         management = new Management(this, processService, database, PlayerCache.getInstance());
 
         // Set up the BungeeCord hook
@@ -751,26 +753,26 @@ public class AuthMe extends JavaPlugin {
 
     // Purge inactive players from the database, as defined in the configuration
     private void autoPurge() {
-        if (!Settings.usePurge) {
+        if (!newSettings.getProperty(PurgeSettings.USE_AUTO_PURGE)) {
             return;
         }
         Calendar calendar = Calendar.getInstance();
-        calendar.add(Calendar.DATE, -(Settings.purgeDelay));
+        calendar.add(Calendar.DATE, -newSettings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER));
         long until = calendar.getTimeInMillis();
         List<String> cleared = database.autoPurgeDatabase(until);
         if (CollectionUtils.isEmpty(cleared)) {
             return;
         }
         ConsoleLogger.info("AutoPurging the Database: " + cleared.size() + " accounts removed!");
-        if (Settings.purgeEssentialsFile && this.ess != null)
+        if (newSettings.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES) && this.ess != null)
             dataManager.purgeEssentials(cleared);
-        if (Settings.purgePlayerDat)
+        if (newSettings.getProperty(PurgeSettings.REMOVE_PLAYER_DAT))
             dataManager.purgeDat(cleared);
-        if (Settings.purgeLimitedCreative)
+        if (newSettings.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES))
             dataManager.purgeLimitedCreative(cleared);
-        if (Settings.purgeAntiXray)
+        if (newSettings.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE))
             dataManager.purgeAntiXray(cleared);
-        if (Settings.purgePermissions)
+        if (newSettings.getProperty(PurgeSettings.REMOVE_PERMISSIONS))
             dataManager.purgePermissions(cleared);
     }
 

src/main/java/fr/xephi/authme/cache/IpAddressManager.java

@@ -17,10 +17,10 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class IpAddressManager {
 
-    /** Cache for IP lookups per player. */
-    private final ConcurrentHashMap<String, String> ipCache;
     /** Whether or not to use the VeryGames API for IP lookups. */
     private final boolean useVeryGamesIpCheck;
+    /** Cache for lookups via the VeryGames API. */
+    private final ConcurrentHashMap<String, String> ipCache;
 
     /**
      * Constructor.
@@ -32,32 +32,52 @@ public class IpAddressManager {
         this.ipCache = new ConcurrentHashMap<>();
     }
 
+    /**
+     * Return the player's IP address. If enabled in the settings, the IP address returned by the
+     * VeryGames API will be returned.
+     *
+     * @param player The player to look up
+     * @return The IP address of the player
+     */
     public String getPlayerIp(Player player) {
-        final String playerName = player.getName().toLowerCase();
-        final String cachedValue = ipCache.get(playerName);
-        if (cachedValue != null) {
-            return cachedValue;
-        }
-
-        final String plainIp = player.getAddress().getAddress().getHostAddress();
         if (useVeryGamesIpCheck) {
+            final String playerName = player.getName().toLowerCase();
+            final String cachedValue = ipCache.get(playerName);
+            if (cachedValue != null) {
+                return cachedValue;
+            }
+
+            final String plainIp = player.getAddress().getAddress().getHostAddress();
             String veryGamesResult = getVeryGamesIp(plainIp, player.getAddress().getPort());
             if (veryGamesResult != null) {
                 ipCache.put(playerName, veryGamesResult);
                 return veryGamesResult;
             }
-        } else {
-            ipCache.put(playerName, plainIp);
         }
-        return plainIp;
+        return player.getAddress().getAddress().getHostAddress();
     }
 
+    /**
+     * Add a player to the IP address cache.
+     *
+     * @param player The player to add or update the cache entry for
+     * @param ip The IP address to add
+     */
     public void addCache(String player, String ip) {
-        ipCache.put(player.toLowerCase(), ip);
+        if (useVeryGamesIpCheck) {
+            ipCache.put(player.toLowerCase(), ip);
+        }
     }
 
+    /**
+     * Remove a player's cache entry.
+     *
+     * @param player The player to remove
+     */
     public void removeCache(String player) {
-        ipCache.remove(player.toLowerCase());
+        if (useVeryGamesIpCheck) {
+            ipCache.remove(player.toLowerCase());
+        }
     }
 
     // returns null if IP could not be looked up

src/main/java/fr/xephi/authme/cache/auth/PlayerAuth.java

@@ -30,18 +30,6 @@ public class PlayerAuth {
         this.deserialize(serialized);
     }
 
-    /**
-     * Constructor for PlayerAuth.
-     *
-     * @param nickname  String
-     * @param ip        String
-     * @param lastLogin long
-     * @param realName  String
-     */
-    public PlayerAuth(String nickname, String ip, long lastLogin, String realName) {
-        this(nickname, new HashedPassword(""), -1, ip, lastLogin, 0, 0, 0, "world", "your@email.com", realName);
-    }
-
     /**
      * Constructor for PlayerAuth.
      *

src/main/java/fr/xephi/authme/command/CommandService.java

@@ -41,6 +41,7 @@ public class CommandService {
      * @param passwordSecurity The Password Security instance
      * @param permissionsManager The permissions manager
      * @param settings The settings manager
+     * @param ipAddressManager The IP address manager
      */
     public CommandService(AuthMe authMe, CommandMapper commandMapper, HelpProvider helpProvider, Messages messages,
                           PasswordSecurity passwordSecurity, PermissionsManager permissionsManager, NewSetting settings,

src/main/java/fr/xephi/authme/command/CommandUtils.java

@@ -8,6 +8,9 @@ import java.util.List;
 
 public final class CommandUtils {
 
+    private CommandUtils() {
+    }
+
     public static int getMinNumberOfArguments(CommandDescription command) {
         int mandatoryArguments = 0;
         for (CommandArgumentDescription argument : command.getArguments()) {

src/main/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommand.java

@@ -3,7 +3,7 @@ package fr.xephi.authme.command.executable.authme;
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.command.CommandService;
 import fr.xephi.authme.command.ExecutableCommand;
-import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.PurgeSettings;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 
@@ -15,7 +15,7 @@ public class PurgeBannedPlayersCommand implements ExecutableCommand {
     @Override
     public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) {
         // AuthMe plugin instance
-        final AuthMe plugin = AuthMe.getInstance();
+        final AuthMe plugin = commandService.getAuthMe();
 
         // Get the list of banned players
         List<String> bannedPlayers = new ArrayList<>();
@@ -25,13 +25,13 @@ public class PurgeBannedPlayersCommand implements ExecutableCommand {
 
         // Purge the banned players
         plugin.getDataSource().purgeBanned(bannedPlayers);
-        if (Settings.purgeEssentialsFile && plugin.ess != null)
+        if (commandService.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES) && plugin.ess != null)
             plugin.dataManager.purgeEssentials(bannedPlayers);
-        if (Settings.purgePlayerDat)
+        if (commandService.getProperty(PurgeSettings.REMOVE_PLAYER_DAT))
             plugin.dataManager.purgeDat(bannedPlayers);
-        if (Settings.purgeLimitedCreative)
+        if (commandService.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES))
             plugin.dataManager.purgeLimitedCreative(bannedPlayers);
-        if (Settings.purgeAntiXray)
+        if (commandService.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE))
             plugin.dataManager.purgeAntiXray(bannedPlayers);
 
         // Show a status message

src/main/java/fr/xephi/authme/command/executable/authme/PurgeCommand.java

@@ -3,7 +3,7 @@ package fr.xephi.authme.command.executable.authme;
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.command.CommandService;
 import fr.xephi.authme.command.ExecutableCommand;
-import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.PurgeSettings;
 import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 
@@ -15,7 +15,7 @@ public class PurgeCommand implements ExecutableCommand {
     @Override
     public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) {
         // AuthMe plugin instance
-        AuthMe plugin = AuthMe.getInstance();
+        AuthMe plugin = commandService.getAuthMe();
 
         // Get the days parameter
         String daysStr = arguments.get(0);
@@ -47,13 +47,13 @@ public class PurgeCommand implements ExecutableCommand {
         sender.sendMessage(ChatColor.GOLD + "Deleted " + purged.size() + " user accounts");
 
         // Purge other data
-        if (Settings.purgeEssentialsFile && plugin.ess != null)
+        if (commandService.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES) && plugin.ess != null)
             plugin.dataManager.purgeEssentials(purged);
-        if (Settings.purgePlayerDat)
+        if (commandService.getProperty(PurgeSettings.REMOVE_PLAYER_DAT))
             plugin.dataManager.purgeDat(purged);
-        if (Settings.purgeLimitedCreative)
+        if (commandService.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES))
             plugin.dataManager.purgeLimitedCreative(purged);
-        if (Settings.purgeAntiXray)
+        if (commandService.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE))
             plugin.dataManager.purgeAntiXray(purged);
 
         // Show a status message

src/main/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommand.java

@@ -8,6 +8,7 @@ import fr.xephi.authme.command.CommandService;
 import fr.xephi.authme.command.ExecutableCommand;
 import fr.xephi.authme.output.MessageKey;
 import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
 import fr.xephi.authme.task.MessageTask;
 import fr.xephi.authme.task.TimeoutTask;
 import fr.xephi.authme.util.Utils;
@@ -66,7 +67,7 @@ public class UnregisterAdminCommand implements ExecutableCommand {
                     plugin, new MessageTask(plugin, playerNameLowerCase, MessageKey.REGISTER_MESSAGE, interval)
                 )
             );
-            if (Settings.applyBlindEffect) {
+            if (commandService.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
                 target.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
             }
             commandService.send(target, MessageKey.UNREGISTERED_SUCCESS);

src/main/java/fr/xephi/authme/command/executable/authme/VersionCommand.java

@@ -3,15 +3,15 @@ package fr.xephi.authme.command.executable.authme;
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.command.CommandService;
 import fr.xephi.authme.command.ExecutableCommand;
-import static fr.xephi.authme.settings.properties.PluginSettings.HELP_HEADER;
 import fr.xephi.authme.util.Utils;
-
-import java.util.List;
-
 import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
+import java.util.List;
+
+import static fr.xephi.authme.settings.properties.PluginSettings.HELP_HEADER;
+
 public class VersionCommand implements ExecutableCommand {
 
     @Override
@@ -71,8 +71,6 @@ public class VersionCommand implements ExecutableCommand {
      * @return True if the player is online, false otherwise.
      */
     private static boolean isPlayerOnline(String minecraftName) {
-        // Note ljacqu 20151121: Generally you should use Utils#getOnlinePlayers to retrieve the list of online players.
-        // If it's only used in a for-each loop such as here, it's fine. For other purposes, go through the Utils class.
         for (Player player : Utils.getOnlinePlayers()) {
             if (player.getName().equalsIgnoreCase(minecraftName)) {
                 return true;

src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java

@@ -7,6 +7,7 @@ import fr.xephi.authme.process.Management;
 import fr.xephi.authme.security.HashAlgorithm;
 import fr.xephi.authme.security.RandomString;
 import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.util.Utils;
 
 import org.bukkit.entity.Player;
@@ -17,7 +18,7 @@ public class RegisterCommand extends PlayerCommand {
 
     @Override
     public void runCommand(Player player, List<String> arguments, CommandService commandService) {
-        if (Settings.getPasswordHash == HashAlgorithm.TWO_FACTOR) {
+        if (commandService.getProperty(SecuritySettings.PASSWORD_HASH) == HashAlgorithm.TWO_FACTOR) {
             //for two factor auth we don't need to check the usage
             commandService.getManagement().performRegister(player, "", "");
             return;

src/main/java/fr/xephi/authme/permission/PlayerPermission.java

@@ -55,10 +55,10 @@ public enum PlayerPermission implements PermissionNode {
      */
     CAN_LOGIN_BE_FORCED("authme.player.canbeforced"),
 
-	/**
+    /**
-	 * Permission to use to see own other accounts.
+     * Permission to use to see own other accounts.
-	 */
+     */
-	SEE_OWN_ACCOUNTS("authme.player.seeownaccounts");
+    SEE_OWN_ACCOUNTS("authme.player.seeownaccounts");
 
     /**
      * The permission node.

src/main/java/fr/xephi/authme/process/Management.java

@@ -11,7 +11,6 @@ import fr.xephi.authme.process.logout.AsynchronousLogout;
 import fr.xephi.authme.process.quit.AsynchronousQuit;
 import fr.xephi.authme.process.register.AsyncRegister;
 import fr.xephi.authme.process.unregister.AsynchronousUnregister;
-import fr.xephi.authme.settings.NewSetting;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitScheduler;
 
@@ -24,22 +23,13 @@ public class Management {
     private final ProcessService processService;
     private final DataSource dataSource;
     private final PlayerCache playerCache;
-    private final NewSetting settings;
 
-    /**
-     * Constructor for Management.
-     *
-     * @param plugin AuthMe
-     */
     public Management(AuthMe plugin, ProcessService processService, DataSource dataSource, PlayerCache playerCache) {
         this.plugin = plugin;
         this.sched = this.plugin.getServer().getScheduler();
         this.processService = processService;
         this.dataSource = dataSource;
         this.playerCache = playerCache;
-
-        // FIXME don't pass settings anymore -> go through the service in the processes
-        this.settings = processService.getSettings();
     }
 
     public void performLogin(final Player player, final String password, final boolean forceLogin) {
@@ -47,13 +37,7 @@ public class Management {
     }
 
     public void performLogout(final Player player) {
-        sched.runTaskAsynchronously(plugin, new Runnable() {
+        runTask(new AsynchronousLogout(player, plugin, dataSource, processService));
-
-            @Override
-            public void run() {
-                new AsynchronousLogout(player, plugin, plugin.getDataSource()).process();
-            }
-        });
     }
 
     public void performRegister(final Player player, final String password, final String email) {
@@ -77,7 +61,7 @@ public class Management {
     }
 
     public void performChangeEmail(final Player player, final String oldEmail, final String newEmail) {
-        runTask(new AsyncChangeEmail(player, plugin, oldEmail, newEmail, dataSource, playerCache, settings));
+        runTask(new AsyncChangeEmail(player, oldEmail, newEmail, dataSource, playerCache, processService));
     }
 
     private void runTask(Process process) {

src/main/java/fr/xephi/authme/process/ProcessService.java

@@ -4,6 +4,8 @@ import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.cache.IpAddressManager;
 import fr.xephi.authme.output.MessageKey;
 import fr.xephi.authme.output.Messages;
+import fr.xephi.authme.security.PasswordSecurity;
+import fr.xephi.authme.security.crypts.HashedPassword;
 import fr.xephi.authme.settings.NewSetting;
 import fr.xephi.authme.settings.domain.Property;
 import org.bukkit.command.CommandSender;
@@ -19,12 +21,15 @@ public class ProcessService {
     private final Messages messages;
     private final AuthMe authMe;
     private final IpAddressManager ipAddressManager;
+    private final PasswordSecurity passwordSecurity;
 
-    public ProcessService(NewSetting settings, Messages messages, AuthMe authMe, IpAddressManager ipAddressManager) {
+    public ProcessService(NewSetting settings, Messages messages, AuthMe authMe, IpAddressManager ipAddressManager,
+                          PasswordSecurity passwordSecurity) {
         this.settings = settings;
         this.messages = messages;
         this.authMe = authMe;
         this.ipAddressManager = ipAddressManager;
+        this.passwordSecurity = passwordSecurity;
     }
 
     public <T> T getProperty(Property<T> property) {
@@ -75,4 +80,8 @@ public class ProcessService {
         return ipAddressManager;
     }
 
+    public HashedPassword computeHash(String password, String username) {
+        return passwordSecurity.computeHash(password, username);
+    }
+
 }

src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java

@@ -1,14 +1,12 @@
 package fr.xephi.authme.process.email;
 
-import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.cache.auth.PlayerAuth;
 import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.output.MessageKey;
-import fr.xephi.authme.output.Messages;
 import fr.xephi.authme.process.Process;
-import fr.xephi.authme.settings.NewSetting;
+import fr.xephi.authme.process.ProcessService;
-import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
 import fr.xephi.authme.util.Utils;
 import org.bukkit.entity.Player;
 
@@ -20,20 +18,18 @@ public class AsyncChangeEmail implements Process {
     private final Player player;
     private final String oldEmail;
     private final String newEmail;
-    private final Messages m;
+    private final ProcessService service;
-    private final NewSetting settings;
     private final PlayerCache playerCache;
     private final DataSource dataSource;
 
-    public AsyncChangeEmail(Player player, AuthMe plugin, String oldEmail, String newEmail, DataSource dataSource,
+    public AsyncChangeEmail(Player player, String oldEmail, String newEmail, DataSource dataSource,
-                            PlayerCache playerCache, NewSetting settings) {
+                            PlayerCache playerCache, ProcessService service) {
-        this.m = plugin.getMessages();
         this.player = player;
         this.oldEmail = oldEmail;
         this.newEmail = newEmail;
         this.playerCache = playerCache;
         this.dataSource = dataSource;
-        this.settings = settings;
+        this.service = service;
     }
 
     @Override
@@ -44,13 +40,13 @@ public class AsyncChangeEmail implements Process {
             final String currentEmail = auth.getEmail();
 
             if (currentEmail == null) {
-                m.send(player, MessageKey.USAGE_ADD_EMAIL);
+                service.send(player, MessageKey.USAGE_ADD_EMAIL);
-            } else if (newEmail == null || !Utils.isEmailCorrect(newEmail, settings)) {
+            } else if (newEmail == null || !Utils.isEmailCorrect(newEmail, service.getSettings())) {
-                m.send(player, MessageKey.INVALID_NEW_EMAIL);
+                service.send(player, MessageKey.INVALID_NEW_EMAIL);
             } else if (!oldEmail.equals(currentEmail)) {
-                m.send(player, MessageKey.INVALID_OLD_EMAIL);
+                service.send(player, MessageKey.INVALID_OLD_EMAIL);
             } else if (dataSource.isEmailStored(newEmail)) {
-                m.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
+                service.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
             } else {
                 saveNewEmail(auth);
             }
@@ -63,20 +59,20 @@ public class AsyncChangeEmail implements Process {
         auth.setEmail(newEmail);
         if (dataSource.updateEmail(auth)) {
             playerCache.updatePlayer(auth);
-            m.send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
+            service.send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
         } else {
-            m.send(player, MessageKey.ERROR);
+            service.send(player, MessageKey.ERROR);
             auth.setEmail(newEmail);
         }
     }
 
     private void outputUnloggedMessage() {
         if (dataSource.isAuthAvailable(player.getName())) {
-            m.send(player, MessageKey.LOGIN_MESSAGE);
+            service.send(player, MessageKey.LOGIN_MESSAGE);
-        } else if (Settings.emailRegistration) {
+        } else if (service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)) {
-            m.send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
+            service.send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
         } else {
-            m.send(player, MessageKey.REGISTER_MESSAGE);
+            service.send(player, MessageKey.REGISTER_MESSAGE);
         }
     }
 }

src/main/java/fr/xephi/authme/process/login/AsynchronousLogin.java

@@ -15,6 +15,7 @@ import fr.xephi.authme.process.Process;
 import fr.xephi.authme.process.ProcessService;
 import fr.xephi.authme.security.RandomString;
 import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.DatabaseSettings;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.task.MessageTask;
@@ -98,7 +99,7 @@ public class AsynchronousLogin implements Process {
             return null;
         }
 
-        if (!Settings.getMySQLColumnGroup.isEmpty() && pAuth.getGroupId() == Settings.getNonActivatedGroup) {
+        if (!service.getProperty(DatabaseSettings.MYSQL_COL_GROUP).isEmpty() && pAuth.getGroupId() == Settings.getNonActivatedGroup) {
             service.send(player, MessageKey.ACCOUNT_NOT_ACTIVATED);
             return null;
         }
@@ -146,7 +147,7 @@ public class AsynchronousLogin implements Process {
                 .build();
             database.updateSession(auth);
 
-            if (Settings.useCaptcha) {
+            if (service.getProperty(SecuritySettings.USE_CAPTCHA)) {
                 if (plugin.captcha.containsKey(name)) {
                     plugin.captcha.remove(name);
                 }

src/main/java/fr/xephi/authme/process/logout/AsynchronousLogout.java

@@ -6,22 +6,22 @@ import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.cache.limbo.LimboCache;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.output.MessageKey;
-import fr.xephi.authme.output.Messages;
+import fr.xephi.authme.process.Process;
+import fr.xephi.authme.process.ProcessService;
 import fr.xephi.authme.util.Utils;
 import fr.xephi.authme.util.Utils.GroupType;
 import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitScheduler;
 
 /**
  */
-public class AsynchronousLogout {
+public class AsynchronousLogout implements Process {
 
-    protected final Player player;
+    private final Player player;
-    protected final String name;
+    private final String name;
-    protected final AuthMe plugin;
+    private final AuthMe plugin;
-    protected final DataSource database;
+    private final DataSource database;
-    protected boolean canLogout = true;
+    private boolean canLogout = true;
-    private final Messages m;
+    private final ProcessService service;
 
     /**
      * Constructor for AsynchronousLogout.
@@ -29,29 +29,30 @@ public class AsynchronousLogout {
      * @param player   Player
      * @param plugin   AuthMe
      * @param database DataSource
+     * @param service  The process service
      */
-    public AsynchronousLogout(Player player, AuthMe plugin, DataSource database) {
+    public AsynchronousLogout(Player player, AuthMe plugin, DataSource database, ProcessService service) {
-        this.m = plugin.getMessages();
         this.player = player;
         this.plugin = plugin;
         this.database = database;
         this.name = player.getName().toLowerCase();
+        this.service = service;
     }
 
     private void preLogout() {
         if (!PlayerCache.getInstance().isAuthenticated(name)) {
-            m.send(player, MessageKey.NOT_LOGGED_IN);
+            service.send(player, MessageKey.NOT_LOGGED_IN);
             canLogout = false;
         }
     }
 
-    public void process() {
+    @Override
+    public void run() {
         preLogout();
         if (!canLogout) {
             return;
         }
         final Player p = player;
-        BukkitScheduler scheduler = p.getServer().getScheduler();
         PlayerAuth auth = PlayerCache.getInstance().getAuth(name);
         database.updateSession(auth);
         auth.setQuitLocX(p.getLocation().getX());
@@ -62,7 +63,7 @@ public class AsynchronousLogout {
 
         PlayerCache.getInstance().removePlayer(name);
         database.setUnlogged(name);
-        scheduler.scheduleSyncDelayedTask(plugin, new Runnable() {
+        service.scheduleSyncDelayedTask(new Runnable() {
             @Override
             public void run() {
                 Utils.teleportToSpawn(p);
@@ -73,6 +74,6 @@ public class AsynchronousLogout {
         }
         LimboCache.getInstance().addLimboPlayer(player);
         Utils.setGroup(player, GroupType.NOTLOGGEDIN);
-        scheduler.scheduleSyncDelayedTask(plugin, new ProcessSyncronousPlayerLogout(p, plugin));
+        service.scheduleSyncDelayedTask(new ProcessSynchronousPlayerLogout(p, plugin, service));
     }
 }

src/main/java/fr/xephi/authme/process/logout/ProcessSynchronousPlayerLogout.java

@@ -7,37 +7,40 @@ import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.cache.limbo.LimboCache;
 import fr.xephi.authme.events.LogoutEvent;
 import fr.xephi.authme.output.MessageKey;
-import fr.xephi.authme.output.Messages;
+import fr.xephi.authme.process.Process;
+import fr.xephi.authme.process.ProcessService;
 import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.task.MessageTask;
 import fr.xephi.authme.task.TimeoutTask;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
-import org.bukkit.scheduler.BukkitScheduler;
 import org.bukkit.scheduler.BukkitTask;
 
 /**
  */
-public class ProcessSyncronousPlayerLogout implements Runnable {
+public class ProcessSynchronousPlayerLogout implements Process {
 
-    protected final Player player;
+    private final Player player;
-    protected final AuthMe plugin;
+    private final AuthMe plugin;
-    protected final String name;
+    private final String name;
-    private final Messages m;
+    private final ProcessService service;
 
     /**
-     * Constructor for ProcessSyncronousPlayerLogout.
+     * Constructor for ProcessSynchronousPlayerLogout.
      *
      * @param player Player
      * @param plugin AuthMe
+     * @param service The process service
      */
-    public ProcessSyncronousPlayerLogout(Player player, AuthMe plugin) {
+    public ProcessSynchronousPlayerLogout(Player player, AuthMe plugin, ProcessService service) {
-        this.m = plugin.getMessages();
         this.player = player;
         this.plugin = plugin;
         this.name = player.getName().toLowerCase();
+        this.service = service;
     }
 
     protected void sendBungeeMessage() {
@@ -56,11 +59,6 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
         }
     }
 
-    /**
-     * Method run.
-     *
-     * @see java.lang.Runnable#run()
-     */
     @Override
     public void run() {
         if (plugin.sessions.containsKey(name)) {
@@ -70,19 +68,18 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
         if (Settings.protectInventoryBeforeLogInEnabled) {
             plugin.inventoryProtector.sendBlankInventoryPacket(player);
         }
-        int timeOut = Settings.getRegistrationTimeout * 20;
+        int timeOut = service.getProperty(RestrictionSettings.TIMEOUT) * 20;
-        int interval = Settings.getWarnMessageInterval;
+        int interval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
-        BukkitScheduler sched = player.getServer().getScheduler();
         if (timeOut != 0) {
-            BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut);
+            BukkitTask id = service.runTaskLater(new TimeoutTask(plugin, name, player), timeOut);
             LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id);
         }
-        BukkitTask msgT = sched.runTask(plugin, new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval));
+        BukkitTask msgT = service.runTask(new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval));
         LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgT);
         if (player.isInsideVehicle() && player.getVehicle() != null) {
             player.getVehicle().eject();
         }
-        if (Settings.applyBlindEffect) {
+        if (service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
             player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
         }
         player.setOp(false);
@@ -92,7 +89,7 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
         if (Settings.bungee) {
             sendBungeeMessage();
         }
-        m.send(player, MessageKey.LOGOUT_SUCCESS);
+        service.send(player, MessageKey.LOGOUT_SUCCESS);
         ConsoleLogger.info(player.getName() + " logged out");
     }
 

src/main/java/fr/xephi/authme/process/quit/AsynchronousQuit.java

@@ -13,7 +13,6 @@ import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.util.StringUtils;
 import fr.xephi.authme.util.Utils;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
@@ -54,7 +53,12 @@ public class AsynchronousQuit implements Process {
                     .realName(player.getName()).build();
                 database.updateQuitLoc(auth);
             }
-            PlayerAuth auth = new PlayerAuth(name, ip, System.currentTimeMillis(), player.getName());
+            PlayerAuth auth = PlayerAuth.builder()
+                .name(name)
+                .realName(player.getName())
+                .ip(ip)
+                .lastLogin(System.currentTimeMillis())
+                .build();
             database.updateSession(auth);
         }
 
@@ -92,7 +96,7 @@ public class AsynchronousQuit implements Process {
 
         service.getIpAddressManager().removeCache(player.getName());
         if (plugin.isEnabled()) {
-            Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new ProcessSyncronousPlayerQuit(plugin, player, isOp, needToChange));
+            service.scheduleSyncDelayedTask(new ProcessSyncronousPlayerQuit(plugin, player, isOp, needToChange));
         }
         // remove player from cache
         if (database instanceof CacheDataSource) {

src/main/java/fr/xephi/authme/process/register/AsyncRegister.java

@@ -1,10 +1,5 @@
 package fr.xephi.authme.process.register;
 
-import java.util.List;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.cache.auth.PlayerAuth;
 import fr.xephi.authme.cache.auth.PlayerCache;
@@ -22,6 +17,8 @@ import fr.xephi.authme.util.StringUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
+import java.util.List;
+
 /**
  */
 public class AsyncRegister implements Process {
@@ -82,10 +79,11 @@ public class AsyncRegister implements Process {
             && !ip.equalsIgnoreCase("127.0.0.1")
             && !ip.equalsIgnoreCase("localhost")
             && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)) {
-            Integer maxReg = Settings.getmaxRegPerIp;
+            int maxReg = Settings.getmaxRegPerIp;
             List<String> otherAccounts = database.getAllAuthsByIp(ip);
             if (otherAccounts.size() >= maxReg) {
-                m.send(player, MessageKey.MAX_REGISTER_EXCEEDED, maxReg.toString(), Integer.toString(otherAccounts.size()), otherAccounts.toString());
+                service.send(player, MessageKey.MAX_REGISTER_EXCEEDED, Integer.toString(maxReg),
+                    Integer.toString(otherAccounts.size()), StringUtils.join(", ", otherAccounts.toString()));
                 return false;
             }
         }
@@ -104,18 +102,19 @@ public class AsyncRegister implements Process {
     }
 
     private void emailRegister() {
-        if(Settings.getmaxRegPerEmail > 0
+        if (Settings.getmaxRegPerEmail > 0
             && !ip.equalsIgnoreCase("127.0.0.1")
             && !ip.equalsIgnoreCase("localhost")
             && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)) {
-            Integer maxReg = Settings.getmaxRegPerIp;
+            int maxReg = Settings.getmaxRegPerIp;
             List<String> otherAccounts = database.getAllAuthsByIp(ip);
             if (otherAccounts.size() >= maxReg) {
-                m.send(player, MessageKey.MAX_REGISTER_EXCEEDED, maxReg.toString(), Integer.toString(otherAccounts.size()), otherAccounts.toString());
+                service.send(player, MessageKey.MAX_REGISTER_EXCEEDED, Integer.toString(maxReg),
+                    Integer.toString(otherAccounts.size()), StringUtils.join(", ", otherAccounts.toString()));
                 return;
             }
         }
-        final HashedPassword hashedPassword = plugin.getPasswordSecurity().computeHash(password, name);
+        final HashedPassword hashedPassword = service.computeHash(password, name);
         PlayerAuth auth = PlayerAuth.builder()
             .name(name)
             .realName(player.getName())
@@ -133,12 +132,12 @@ public class AsyncRegister implements Process {
         database.updateSession(auth);
         plugin.mail.main(auth, password);
         ProcessSyncEmailRegister sync = new ProcessSyncEmailRegister(player, service);
-        plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, sync);
+        service.scheduleSyncDelayedTask(sync);
 
     }
 
     private void passwordRegister() {
-        final HashedPassword hashedPassword = plugin.getPasswordSecurity().computeHash(password, name);
+        final HashedPassword hashedPassword = service.computeHash(password, name);
         PlayerAuth auth = PlayerAuth.builder()
             .name(name)
             .realName(player.getName())
@@ -163,7 +162,7 @@ public class AsyncRegister implements Process {
         service.scheduleSyncDelayedTask(sync);
 
         //give the user the secret code to setup their app code generation
-        if (Settings.getPasswordHash == HashAlgorithm.TWO_FACTOR) {
+        if (service.getProperty(SecuritySettings.PASSWORD_HASH) == HashAlgorithm.TWO_FACTOR) {
             String qrCodeUrl = TwoFactor.getQRBarcodeURL(player.getName(), Bukkit.getIp(), hashedPassword.getHash());
             service.send(player, MessageKey.TWO_FACTOR_CREATE, hashedPassword.getHash(), qrCodeUrl);
         }

src/main/java/fr/xephi/authme/process/register/ProcessSyncEmailRegister.java

@@ -4,6 +4,7 @@ import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.cache.limbo.LimboCache;
 import fr.xephi.authme.cache.limbo.LimboPlayer;
 import fr.xephi.authme.output.MessageKey;
+import fr.xephi.authme.process.Process;
 import fr.xephi.authme.process.ProcessService;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
@@ -17,10 +18,10 @@ import org.bukkit.scheduler.BukkitTask;
 
 /**
  */
-public class ProcessSyncEmailRegister implements Runnable {
+public class ProcessSyncEmailRegister implements Process {
 
-    protected final Player player;
+    private final Player player;
-    protected final String name;
+    private final String name;
     private final ProcessService service;
 
     /**

src/main/java/fr/xephi/authme/settings/Settings.java

@@ -1,10 +1,8 @@
 package fr.xephi.authme.settings;
 
 import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.datasource.DataSourceType;
 import fr.xephi.authme.security.HashAlgorithm;
 import fr.xephi.authme.settings.domain.Property;
-import fr.xephi.authme.settings.properties.DatabaseSettings;
 import fr.xephi.authme.settings.properties.HooksSettings;
 import fr.xephi.authme.settings.properties.PluginSettings;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
@@ -41,13 +39,9 @@ public final class Settings {
     public static List<String> forceRegisterCommands;
     public static List<String> forceRegisterCommandsAsConsole;
     public static List<String> unsafePasswords;
-    public static List<String> emailBlacklist;
-    public static List<String> emailWhitelist;
-    public static DataSourceType getDataSource;
     public static HashAlgorithm getPasswordHash;
     public static Pattern nickPattern;
     public static boolean useLogging = false;
-    public static int purgeDelay = 60;
     public static boolean isChatAllowed, isPermissionCheckEnabled, isRegistrationEnabled,
         isForcedRegistrationEnabled, isTeleportToSpawnEnabled,
         isSessionsEnabled, isAllowRestrictedIp,
@@ -57,19 +51,17 @@ public final class Settings {
         isKickOnWrongPasswordEnabled, enablePasswordConfirmation,
         protectInventoryBeforeLogInEnabled, isStopEnabled, reloadSupport,
         rakamakUseIp, noConsoleSpam, removePassword, displayOtherAccounts,
-        useCaptcha, emailRegistration, multiverse, bungee,
+        emailRegistration, multiverse, bungee,
         banUnsafeIp, doubleEmailCheck, sessionExpireOnIpChange,
-        disableSocialSpy, useEssentialsMotd, usePurge,
+        disableSocialSpy, useEssentialsMotd,
-        purgePlayerDat, purgeEssentialsFile,
-        purgeLimitedCreative, purgeAntiXray, purgePermissions,
         enableProtection, enableAntiBot, recallEmail, useWelcomeMessage,
         broadcastWelcomeMessage, forceRegKick, forceRegLogin,
         checkVeryGames, removeJoinMessage, removeLeaveMessage, delayJoinMessage,
-        noTeleport, applyBlindEffect, hideTablistBeforeLogin, denyTabcompleteBeforeLogin,
+        noTeleport, hideTablistBeforeLogin, denyTabcompleteBeforeLogin,
         kickPlayersBeforeStopping, allowAllCommandsIfRegIsOptional,
-        customAttributes, generateImage, isRemoveSpeedEnabled, preventOtherCase;
+        customAttributes, isRemoveSpeedEnabled, preventOtherCase;
     public static String getNickRegex, getUnloggedinGroup,
-        getMySQLColumnGroup, unRegisteredGroup,
+        unRegisteredGroup,
         backupWindowsPath, getRegisteredGroup,
         rakamakUsers, rakamakUsersIp, getmailAccount, defaultWorld,
         spawnPriority, crazyloginFileName, getPassRegex, sendPlayerTo;
@@ -79,7 +71,7 @@ public final class Settings {
         getNonActivatedGroup, passwordMaxLength, getRecoveryPassLength,
         getMailPort, maxLoginTry, captchaLength, saltLength,
         getmaxRegPerEmail, bCryptLog2Rounds,
-        antiBotSensibility, antiBotDuration, delayRecall, getMaxLoginPerIp,
+        antiBotSensibility, antiBotDuration, getMaxLoginPerIp,
         getMaxJoinPerIp;
     protected static FileConfiguration configFile;
 
@@ -123,8 +115,6 @@ public final class Settings {
         getmaxRegPerIp = configFile.getInt("settings.restrictions.maxRegPerIp", 1);
         getPasswordHash = load(SecuritySettings.PASSWORD_HASH);
         getUnloggedinGroup = load(SecuritySettings.UNLOGGEDIN_GROUP);
-        getDataSource = load(DatabaseSettings.BACKEND);
-        getMySQLColumnGroup = configFile.getString("ExternalBoardOptions.mySQLColumnGroup", "");
         getNonActivatedGroup = configFile.getInt("ExternalBoardOptions.nonActivedUserGroup", -1);
         unRegisteredGroup = configFile.getString("GroupOptions.UnregisteredPlayerGroup", "");
 
@@ -164,7 +154,6 @@ public final class Settings {
         getMailPort = configFile.getInt("Email.mailPort", 465);
         getRecoveryPassLength = configFile.getInt("Email.RecoveryPasswordLength", 8);
         displayOtherAccounts = configFile.getBoolean("settings.restrictions.displayOtherAccounts", true);
-        useCaptcha = configFile.getBoolean("Security.captcha.useCaptcha", false);
         maxLoginTry = configFile.getInt("Security.captcha.maxLoginTry", 5);
         captchaLength = configFile.getInt("Security.captcha.captchaLength", 5);
         emailRegistration = load(RegistrationSettings.USE_EMAIL_REGISTRATION);
@@ -180,14 +169,7 @@ public final class Settings {
         disableSocialSpy = configFile.getBoolean("Hooks.disableSocialSpy", true);
         bCryptLog2Rounds = configFile.getInt("ExternalBoardOptions.bCryptLog2Round", 10);
         useEssentialsMotd = configFile.getBoolean("Hooks.useEssentialsMotd", false);
-        usePurge = configFile.getBoolean("Purge.useAutoPurge", false);
-        purgeDelay = configFile.getInt("Purge.daysBeforeRemovePlayer", 60);
-        purgePlayerDat = configFile.getBoolean("Purge.removePlayerDat", false);
-        purgeEssentialsFile = configFile.getBoolean("Purge.removeEssentialsFile", false);
         defaultWorld = configFile.getString("Purge.defaultWorld", "world");
-        purgeLimitedCreative = configFile.getBoolean("Purge.removeLimitedCreativesInventories", false);
-        purgeAntiXray = configFile.getBoolean("Purge.removeAntiXRayFile", false);
-        purgePermissions = configFile.getBoolean("Purge.removePermissions", false);
         enableProtection = configFile.getBoolean("Protection.enableProtection", false);
         countries = configFile.getStringList("Protection.countries");
         enableAntiBot = configFile.getBoolean("Protection.enableAntiBot", false);
@@ -196,7 +178,6 @@ public final class Settings {
         forceCommands = configFile.getStringList("settings.forceCommands");
         forceCommandsAsConsole = configFile.getStringList("settings.forceCommandsAsConsole");
         recallEmail = configFile.getBoolean("Email.recallPlayers", false);
-        delayRecall = configFile.getInt("Email.delayRecall", 5);
         useWelcomeMessage = load(RegistrationSettings.USE_WELCOME_MESSAGE);
         unsafePasswords = configFile.getStringList("settings.security.unsafePasswords");
         countriesBlacklist = configFile.getStringList("Protection.countriesBlacklist");
@@ -213,13 +194,9 @@ public final class Settings {
         noTeleport = load(RestrictionSettings.NO_TELEPORT);
         crazyloginFileName = configFile.getString("Converter.CrazyLogin.fileName", "accounts.db");
         getPassRegex = configFile.getString("settings.restrictions.allowedPasswordCharacters", "[\\x21-\\x7E]*");
-        applyBlindEffect = configFile.getBoolean("settings.applyBlindEffect", false);
-        emailBlacklist = configFile.getStringList("Email.emailBlacklisted");
-        emailWhitelist = configFile.getStringList("Email.emailWhitelisted");
         forceRegisterCommands = configFile.getStringList("settings.forceRegisterCommands");
         forceRegisterCommandsAsConsole = configFile.getStringList("settings.forceRegisterCommandsAsConsole");
         customAttributes = configFile.getBoolean("Hooks.customAttributes");
-        generateImage = configFile.getBoolean("Email.generateImage", false);
         preventOtherCase = configFile.getBoolean("settings.preventOtherCase", false);
         kickPlayersBeforeStopping = configFile.getBoolean("Security.stop.kickPlayersBeforeStopping", true);
         sendPlayerTo = configFile.getString("Hooks.sendPlayerTo", "");

src/main/java/fr/xephi/authme/settings/properties/PurgeSettings.java

@@ -5,43 +5,40 @@ import fr.xephi.authme.settings.domain.Property;
 import fr.xephi.authme.settings.domain.SettingsClass;
 
 import static fr.xephi.authme.settings.domain.Property.newProperty;
-import static fr.xephi.authme.settings.domain.PropertyType.BOOLEAN;
-import static fr.xephi.authme.settings.domain.PropertyType.INTEGER;
-import static fr.xephi.authme.settings.domain.PropertyType.STRING;
 
 public class PurgeSettings implements SettingsClass {
 
     @Comment("If enabled, AuthMe automatically purges old, unused accounts")
     public static final Property<Boolean> USE_AUTO_PURGE =
-        newProperty(BOOLEAN, "Purge.useAutoPurge", false);
+        newProperty("Purge.useAutoPurge", false);
 
     @Comment("Number of Days an account become Unused")
     public static final Property<Integer> DAYS_BEFORE_REMOVE_PLAYER =
-        newProperty(INTEGER, "Purge.daysBeforeRemovePlayer", 60);
+        newProperty("Purge.daysBeforeRemovePlayer", 60);
 
     @Comment("Do we need to remove the player.dat file during purge process?")
     public static final Property<Boolean> REMOVE_PLAYER_DAT =
-        newProperty(BOOLEAN, "Purge.removePlayerDat", false);
+        newProperty("Purge.removePlayerDat", false);
 
     @Comment("Do we need to remove the Essentials/users/player.yml file during purge process?")
     public static final Property<Boolean> REMOVE_ESSENTIALS_FILES =
-        newProperty(BOOLEAN, "Purge.removeEssentialsFile", false);
+        newProperty("Purge.removeEssentialsFile", false);
 
     @Comment("World where are players.dat stores")
     public static final Property<String> DEFAULT_WORLD =
-        newProperty(STRING, "Purge.defaultWorld", "world");
+        newProperty("Purge.defaultWorld", "world");
 
     @Comment("Do we need to remove LimitedCreative/inventories/player.yml, player_creative.yml files during purge process ?")
     public static final Property<Boolean> REMOVE_LIMITED_CREATIVE_INVENTORIES =
-        newProperty(BOOLEAN, "Purge.removeLimitedCreativesInventories", false);
+        newProperty("Purge.removeLimitedCreativesInventories", false);
 
     @Comment("Do we need to remove the AntiXRayData/PlayerData/player file during purge process?")
     public static final Property<Boolean> REMOVE_ANTI_XRAY_FILE =
-        newProperty(BOOLEAN, "Purge.removeAntiXRayFile", false);
+        newProperty("Purge.removeAntiXRayFile", false);
 
     @Comment("Do we need to remove permissions?")
     public static final Property<Boolean> REMOVE_PERMISSIONS =
-        newProperty(BOOLEAN, "Purge.removePermissions", false);
+        newProperty("Purge.removePermissions", false);
 
     private PurgeSettings() {
     }

src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java

@@ -58,7 +58,7 @@ import static org.mockito.Mockito.verify;
 public abstract class AbstractResourceClosingTest {
 
     /** List of DataSource method names not to test. */
-    private static final Set<String> IGNORED_METHODS = ImmutableSet.of("reload", "close", "getType");
+    private static final Set<String> IGNORED_METHODS = ImmutableSet.of("close", "getType");
 
     /** Collection of values to use to call methods with the parameters they expect. */
     private static final Map<Class<?>, Object> PARAM_VALUES = getDefaultParameters();

src/test/java/fr/xephi/authme/manager/IpAddressManagerTest.java

@@ -22,7 +22,7 @@ public class IpAddressManagerTest {
     @Test
     public void shouldRetrieveFromCache() {
         // given
-        IpAddressManager ipAddressManager = new IpAddressManager(mockSettings(false));
+        IpAddressManager ipAddressManager = new IpAddressManager(mockSettings(true));
         ipAddressManager.addCache("Test", "my test IP");
 
         // when

src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java

@@ -1,13 +1,12 @@
 package fr.xephi.authme.process.email;
 
-import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.cache.auth.PlayerAuth;
 import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.output.MessageKey;
-import fr.xephi.authme.output.Messages;
+import fr.xephi.authme.process.ProcessService;
 import fr.xephi.authme.settings.NewSetting;
-import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
 import fr.xephi.authme.util.WrapperMock;
 import org.bukkit.entity.Player;
 import org.junit.After;
@@ -27,9 +26,9 @@ import static org.mockito.Mockito.when;
 public class AsyncChangeEmailTest {
 
     private Player player;
-    private Messages messages;
     private PlayerCache playerCache;
     private DataSource dataSource;
+    private ProcessService service;
     private NewSetting settings;
 
     @BeforeClass
@@ -41,9 +40,10 @@ public class AsyncChangeEmailTest {
     @After
     public void cleanFields() {
         player = null;
-        messages = null;
         playerCache = null;
         dataSource = null;
+        service = null;
+        settings = null;
     }
 
     @Test
@@ -62,7 +62,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource).updateEmail(auth);
         verify(playerCache).updatePlayer(auth);
-        verify(messages).send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
+        verify(service).send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
     }
 
     @Test
@@ -81,7 +81,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource).updateEmail(auth);
         verify(playerCache, never()).updatePlayer(auth);
-        verify(messages).send(player, MessageKey.ERROR);
+        verify(service).send(player, MessageKey.ERROR);
     }
 
     @Test
@@ -99,7 +99,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.USAGE_ADD_EMAIL);
+        verify(service).send(player, MessageKey.USAGE_ADD_EMAIL);
     }
 
     @Test
@@ -117,7 +117,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.INVALID_NEW_EMAIL);
+        verify(service).send(player, MessageKey.INVALID_NEW_EMAIL);
     }
 
     @Test
@@ -135,7 +135,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.INVALID_OLD_EMAIL);
+        verify(service).send(player, MessageKey.INVALID_OLD_EMAIL);
     }
 
     @Test
@@ -154,7 +154,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
+        verify(service).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
     }
 
     @Test
@@ -171,7 +171,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.LOGIN_MESSAGE);
+        verify(service).send(player, MessageKey.LOGIN_MESSAGE);
     }
 
     @Test
@@ -181,7 +181,7 @@ public class AsyncChangeEmailTest {
         given(player.getName()).willReturn("Bobby");
         given(playerCache.isAuthenticated("bobby")).willReturn(false);
         given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
-        Settings.emailRegistration = true;
+        given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
 
         // when
         process.run();
@@ -189,7 +189,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
+        verify(service).send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
     }
 
     @Test
@@ -199,7 +199,7 @@ public class AsyncChangeEmailTest {
         given(player.getName()).willReturn("Bobby");
         given(playerCache.isAuthenticated("bobby")).willReturn(false);
         given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
-        Settings.emailRegistration = false;
+        given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(false);
 
         // when
         process.run();
@@ -207,7 +207,7 @@ public class AsyncChangeEmailTest {
         // then
         verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
         verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(messages).send(player, MessageKey.REGISTER_MESSAGE);
+        verify(service).send(player, MessageKey.REGISTER_MESSAGE);
     }
 
     private static PlayerAuth authWithMail(String email) {
@@ -218,12 +218,11 @@ public class AsyncChangeEmailTest {
 
     private AsyncChangeEmail createProcess(String oldEmail, String newEmail) {
         player = mock(Player.class);
-        messages = mock(Messages.class);
-        AuthMe authMe = mock(AuthMe.class);
-        when(authMe.getMessages()).thenReturn(messages);
         playerCache = mock(PlayerCache.class);
         dataSource = mock(DataSource.class);
+        service = mock(ProcessService.class);
         settings = mock(NewSetting.class);
-        return new AsyncChangeEmail(player, authMe, oldEmail, newEmail, dataSource, playerCache, settings);
+        given(service.getSettings()).willReturn(settings);
+        return new AsyncChangeEmail(player, oldEmail, newEmail, dataSource, playerCache, service);
     }
 }