Merge branch 'master' of https://github.com/AuthMe/AuthMeReloaded into 1141-optional-additional-2fa-auth

src/main/java/fr/xephi/authme/data/VerificationCodeManager.java

@@ -162,7 +162,7 @@ public class VerificationCodeManager implements SettingsDependent, HasCleanup {
      *
      * @param name the name of the player to generate a code for
      */
-    public void verify(String name){
+    public void verify(String name) {
         verifiedPlayers.add(name.toLowerCase());
     }
 

src/main/java/fr/xephi/authme/events/AuthMeAsyncPreRegisterEvent.java

@@ -0,0 +1,70 @@
+package fr.xephi.authme.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * This event is called when a player uses the register command,
+ * it's fired even when a user does a /register with invalid arguments.
+ * {@link #setCanRegister(boolean) event.setCanRegister(false)} prevents the player from registering.
+ */
+public class AuthMeAsyncPreRegisterEvent extends CustomEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player player;
+    private boolean canRegister = true;
+
+    /**
+     * Constructor.
+     *
+     * @param player The player
+     * @param isAsync True if the event is async, false otherwise
+     */
+    public AuthMeAsyncPreRegisterEvent(Player player, boolean isAsync) {
+        super(isAsync);
+        this.player = player;
+    }
+
+    /**
+     * Return the player concerned by this event.
+     *
+     * @return The player who executed a valid {@code /login} command
+     */
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * Return whether the player is allowed to register.
+     *
+     * @return True if the player can log in, false otherwise
+     */
+    public boolean canRegister() {
+        return canRegister;
+    }
+
+    /**
+     * Define whether or not the player may register.
+     *
+     * @param canRegister True to allow the player to log in; false to prevent him
+     */
+    public void setCanRegister(boolean canRegister) {
+        this.canRegister = canRegister;
+    }
+
+    /**
+     * Return the list of handlers, equivalent to {@link #getHandlers()} and required by {@link Event}.
+     *
+     * @return The list of handlers
+     */
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+}

src/main/java/fr/xephi/authme/events/EmailChangedEvent.java

@@ -0,0 +1,87 @@
+package fr.xephi.authme.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import javax.annotation.Nullable;
+
+/**
+ * This event is called when a player adds or changes his email address.
+ */
+public class EmailChangedEvent extends CustomEvent implements Cancellable {
+    private static final HandlerList handlers = new HandlerList();
+    private final Player player;
+    private final String oldEmail;
+    private final String newEmail;
+    private boolean isCancelled;
+
+    /**
+     * Constructor
+     *
+     * @param player The player that changed email
+     * @param oldEmail Old email player had on file. Can be null when user adds an email
+     * @param newEmail New email that player tries to set. In case of adding email, this will contain
+     *                the email is trying to set.
+     * @param isAsync should this event be called asynchronously?
+     */
+    public EmailChangedEvent(Player player, @Nullable String oldEmail, String newEmail, boolean isAsync) {
+        super(isAsync);
+        this.player = player;
+        this.oldEmail = oldEmail;
+        this.newEmail = newEmail;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return isCancelled;
+    }
+
+    /**
+     * Gets the player who changes the email
+     *
+     * @return The player who changed the email
+     */
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * Gets the old email in case user tries to change existing email.
+     *
+     * @return old email stored on file. Can be null when user never had an email and adds a new one.
+     */
+    public @Nullable String getOldEmail() {
+        return this.oldEmail;
+    }
+
+    /**
+     * Gets the new email.
+     *
+     * @return the email user is trying to set. If user adds email and never had one before,
+     *        this is where such email can be found.
+     */
+    public String getNewEmail() {
+        return this.newEmail;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.isCancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    /**
+     * Return the list of handlers, equivalent to {@link #getHandlers()} and required by {@link Event}.
+     *
+     * @return The list of handlers
+     */
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

src/main/java/fr/xephi/authme/events/RegisterEvent.java

@@ -0,0 +1,47 @@
+package fr.xephi.authme.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Event fired when a player has successfully registered.
+ */
+public class RegisterEvent extends CustomEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player player;
+
+    /**
+     * Constructor.
+     *
+     * @param player The player
+     */
+    public RegisterEvent(Player player) {
+        this.player = player;
+    }
+
+    /**
+     * Return the player that has successfully logged in or registered.
+     *
+     * @return The player
+     */
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * Return the list of handlers, equivalent to {@link #getHandlers()} and required by {@link Event}.
+     *
+     * @return The list of handlers
+     */
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+}

src/main/java/fr/xephi/authme/listener/PlayerListener.java

@@ -1,11 +1,13 @@
 package fr.xephi.authme.listener;
 
+import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.QuickCommandsProtectionManager;
 import fr.xephi.authme.data.auth.PlayerAuth;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.message.Messages;
 import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.permission.handlers.PermissionLoadUserException;
 import fr.xephi.authme.process.Management;
 import fr.xephi.authme.service.AntiBotService;
 import fr.xephi.authme.service.BukkitService;
@@ -260,9 +262,13 @@ public class PlayerListener implements Listener {
 
         // Keep pre-UUID compatibility
         try {
-            permissionsManager.loadUserData(event.getUniqueId());
-        } catch (NoSuchMethodError e) {
-            permissionsManager.loadUserData(name);
+            try {
+                permissionsManager.loadUserData(event.getUniqueId());
+            } catch (NoSuchMethodError e) {
+                permissionsManager.loadUserData(name);
+            }
+        } catch (PermissionLoadUserException e) {
+            ConsoleLogger.logException("Unable to load the permission data of user " + name, e);
         }
 
         try {

src/main/java/fr/xephi/authme/message/MessageKey.java

@@ -167,12 +167,18 @@ public enum MessageKey {
     /** Email address successfully added to your account! */
     EMAIL_ADDED_SUCCESS("email.added"),
 
+    /** Adding email was not allowed */
+    EMAIL_ADD_NOT_ALLOWED("email.add_not_allowed"),
+
     /** Please confirm your email address! */
     CONFIRM_EMAIL_MESSAGE("email.request_confirmation"),
 
     /** Email address changed correctly! */
     EMAIL_CHANGED_SUCCESS("email.changed"),
 
+    /** Changing email was not allowed */
+    EMAIL_CHANGE_NOT_ALLOWED("email.change_not_allowed"),
+
     /** Your current email address is: %email */
     EMAIL_SHOW("email.email_show", "%email"),
 

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

@@ -8,6 +8,7 @@ import fr.xephi.authme.permission.handlers.BPermissionsHandler;
 import fr.xephi.authme.permission.handlers.LuckPermsHandler;
 import fr.xephi.authme.permission.handlers.PermissionHandler;
 import fr.xephi.authme.permission.handlers.PermissionHandlerException;
+import fr.xephi.authme.permission.handlers.PermissionLoadUserException;
 import fr.xephi.authme.permission.handlers.PermissionsExHandler;
 import fr.xephi.authme.permission.handlers.VaultHandler;
 import fr.xephi.authme.permission.handlers.ZPermissionsHandler;
@@ -110,7 +111,9 @@ public class PermissionsManager implements Reloadable {
      * Creates a permission handler for the provided permission systems if possible.
      *
      * @param type the permission systems type for which to create a corresponding permission handler
+     *
      * @return the permission handler, or {@code null} if not possible
+     *
      * @throws PermissionHandlerException during initialization of the permission handler
      */
     private PermissionHandler createPermissionHandler(PermissionsSystemType type) throws PermissionHandlerException {
@@ -228,8 +231,9 @@ public class PermissionsManager implements Reloadable {
     /**
      * Check if the given player has permission for the given permission node.
      *
-     * @param joiningPlayer The player to check
+     * @param joiningPlayer  The player to check
      * @param permissionNode The permission node to verify
+     *
      * @return true if the player has permission, false otherwise
      */
     public boolean hasPermission(JoiningPlayer joiningPlayer, PermissionNode permissionNode) {
@@ -262,7 +266,7 @@ public class PermissionsManager implements Reloadable {
      * Check whether the offline player with the given name has permission for the given permission node.
      * This method is used as a last resort when nothing besides the name is known.
      *
-     * @param name The name of the player
+     * @param name           The name of the player
      * @param permissionNode The permission node to verify
      *
      * @return true if the player has permission, false otherwise
@@ -317,7 +321,7 @@ public class PermissionsManager implements Reloadable {
      * @param groupName The group name.
      *
      * @return True if the player is in the specified group, false otherwise.
-     *         False is also returned if groups aren't supported by the used permissions system.
+     * False is also returned if groups aren't supported by the used permissions system.
      */
     public boolean isInGroup(OfflinePlayer player, String groupName) {
         return isEnabled() && handler.isInGroup(player, groupName);
@@ -330,7 +334,7 @@ public class PermissionsManager implements Reloadable {
      * @param groupName The name of the group.
      *
      * @return True if succeed, false otherwise.
-     *         False is also returned if this feature isn't supported for the current permissions system.
+     * False is also returned if this feature isn't supported for the current permissions system.
      */
     public boolean addGroup(OfflinePlayer player, String groupName) {
         if (!isEnabled() || StringUtils.isEmpty(groupName)) {
@@ -346,7 +350,7 @@ public class PermissionsManager implements Reloadable {
      * @param groupNames The name of the groups to add.
      *
      * @return True if at least one group was added, false otherwise.
-     *         False is also returned if this feature isn't supported for the current permissions system.
+     * False is also returned if this feature isn't supported for the current permissions system.
      */
     public boolean addGroups(OfflinePlayer player, Collection<String> groupNames) {
         // If no permissions system is used, return false
@@ -373,7 +377,7 @@ public class PermissionsManager implements Reloadable {
      * @param groupName The name of the group.
      *
      * @return True if succeed, false otherwise.
-     *         False is also returned if this feature isn't supported for the current permissions system.
+     * False is also returned if this feature isn't supported for the current permissions system.
      */
     public boolean removeGroup(OfflinePlayer player, String groupName) {
         return isEnabled() && handler.removeFromGroup(player, groupName);
@@ -386,7 +390,7 @@ public class PermissionsManager implements Reloadable {
      * @param groupNames The name of the groups to remove.
      *
      * @return True if at least one group was removed, false otherwise.
-     *         False is also returned if this feature isn't supported for the current permissions system.
+     * False is also returned if this feature isn't supported for the current permissions system.
      */
     public boolean removeGroups(OfflinePlayer player, Collection<String> groupNames) {
         // If no permissions system is used, return false
@@ -414,7 +418,7 @@ public class PermissionsManager implements Reloadable {
      * @param groupName The name of the group.
      *
      * @return True if succeed, false otherwise.
-     *         False is also returned if this feature isn't supported for the current permissions system.
+     * False is also returned if this feature isn't supported for the current permissions system.
      */
     public boolean setGroup(OfflinePlayer player, String groupName) {
         return isEnabled() && handler.setGroup(player, groupName);
@@ -428,7 +432,7 @@ public class PermissionsManager implements Reloadable {
      * @param player The player to remove all groups from.
      *
      * @return True if succeed, false otherwise.
-     *         False will also be returned if this feature isn't supported for the used permissions system.
+     * False will also be returned if this feature isn't supported for the used permissions system.
      */
     public boolean removeAllGroups(OfflinePlayer player) {
         // If no permissions system is used, return false
@@ -443,15 +447,47 @@ public class PermissionsManager implements Reloadable {
         return removeGroups(player, groupNames);
     }
 
-    public void loadUserData(UUID uuid) {
-        if(!isEnabled()) {
+    /**
+     * Loads the permission data of the given player.
+     *
+     * @param offlinePlayer the offline player.
+     * @return true if the load was successful.
+     */
+    public boolean loadUserData(OfflinePlayer offlinePlayer) {
+        try {
+            try {
+                loadUserData(offlinePlayer.getUniqueId());
+            } catch (NoSuchMethodError e) {
+                loadUserData(offlinePlayer.getName());
+            }
+        } catch (PermissionLoadUserException e) {
+            ConsoleLogger.logException("Unable to load the permission data of user " + offlinePlayer.getName(), e);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Loads the permission data of the given player unique identifier.
+     *
+     * @param uuid the {@link UUID} of the player.
+     * @throws PermissionLoadUserException if the action failed.
+     */
+    public void loadUserData(UUID uuid) throws PermissionLoadUserException {
+        if (!isEnabled()) {
             return;
         }
         handler.loadUserData(uuid);
     }
 
-    public void loadUserData(String name) {
-        if(!isEnabled()) {
+    /**
+     * Loads the permission data of the given player name.
+     *
+     * @param name the name of the player.
+     * @throws PermissionLoadUserException if the action failed.
+     */
+    public void loadUserData(String name) throws PermissionLoadUserException {
+        if (!isEnabled()) {
             return;
         }
         handler.loadUserData(name);

src/main/java/fr/xephi/authme/permission/handlers/LuckPermsHandler.java

@@ -189,22 +189,21 @@ public class LuckPermsHandler implements PermissionHandler {
     }
 
     @Override
-    public void loadUserData(UUID uuid) {
+    public void loadUserData(UUID uuid) throws PermissionLoadUserException {
         try {
             luckPermsApi.getUserManager().loadUser(uuid).get(5, TimeUnit.SECONDS);
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            e.printStackTrace();
+            throw new PermissionLoadUserException("Unable to load the permission data of the user " + uuid, e);
         }
     }
 
     @Override
-    public void loadUserData(String name) {
+    public void loadUserData(String name) throws PermissionLoadUserException {
         try {
             UUID uuid = luckPermsApi.getStorage().getUUID(name).get(5, TimeUnit.SECONDS);
             loadUserData(uuid);
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            e.printStackTrace();
+            throw new PermissionLoadUserException("Unable to load the permission data of the user " + name, e);
         }
     }
-
 }

src/main/java/fr/xephi/authme/permission/handlers/PermissionHandler.java

@@ -107,10 +107,9 @@ public interface PermissionHandler {
      */
     PermissionsSystemType getPermissionSystem();
 
-    default void loadUserData(UUID uuid) {
+    default void loadUserData(UUID uuid) throws PermissionLoadUserException {
     }
 
-    default void loadUserData(String name) {
+    default void loadUserData(String name) throws PermissionLoadUserException {
     }
-
 }

src/main/java/fr/xephi/authme/permission/handlers/PermissionLoadUserException.java

@@ -0,0 +1,13 @@
+package fr.xephi.authme.permission.handlers;
+
+import java.util.UUID;
+
+/**
+ * Exception thrown when a {@link PermissionHandler#loadUserData(UUID uuid)} request fails.
+ */
+public class PermissionLoadUserException extends Exception {
+
+    public PermissionLoadUserException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

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

@@ -4,8 +4,10 @@ import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.auth.PlayerAuth;
 import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.events.EmailChangedEvent;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.AsynchronousProcess;
+import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
 import fr.xephi.authme.service.bungeecord.BungeeSender;
@@ -35,6 +37,9 @@ public class AsyncAddEmail implements AsynchronousProcess {
     @Inject
     private BungeeSender bungeeSender;
 
+    @Inject
+    private BukkitService bukkitService;
+
     AsyncAddEmail() { }
 
     /**
@@ -57,6 +62,13 @@ public class AsyncAddEmail implements AsynchronousProcess {
             } else if (!validationService.isEmailFreeForRegistration(email, player)) {
                 service.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
             } else {
+                EmailChangedEvent event = bukkitService.createAndCallEvent(isAsync
+                    -> new EmailChangedEvent(player, null, email, isAsync));
+                if (event.isCancelled()) {
+                    ConsoleLogger.info("Could not add email to player '" + player + "' – event was cancelled");
+                    service.send(player, MessageKey.EMAIL_ADD_NOT_ALLOWED);
+                    return;
+                }
                 auth.setEmail(email);
                 if (dataSource.updateEmail(auth)) {
                     playerCache.updatePlayer(auth);

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

@@ -1,10 +1,13 @@
 package fr.xephi.authme.process.email;
 
+import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.auth.PlayerAuth;
 import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.events.EmailChangedEvent;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.AsynchronousProcess;
+import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
 import fr.xephi.authme.service.bungeecord.BungeeSender;
@@ -32,6 +35,9 @@ public class AsyncChangeEmail implements AsynchronousProcess {
 
     @Inject
     private BungeeSender bungeeSender;
+    
+    @Inject
+    private BukkitService bukkitService;
 
     AsyncChangeEmail() { }
 
@@ -57,14 +63,22 @@ public class AsyncChangeEmail implements AsynchronousProcess {
             } else if (!validationService.isEmailFreeForRegistration(newEmail, player)) {
                 service.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
             } else {
-                saveNewEmail(auth, player, newEmail);
+                saveNewEmail(auth, player, oldEmail, newEmail);
             }
         } else {
             outputUnloggedMessage(player);
         }
     }
 
-    private void saveNewEmail(PlayerAuth auth, Player player, String newEmail) {
+    private void saveNewEmail(PlayerAuth auth, Player player, String oldEmail, String newEmail) {
+        EmailChangedEvent event = bukkitService.createAndCallEvent(isAsync
+            -> new EmailChangedEvent(player, oldEmail, newEmail, isAsync));
+        if (event.isCancelled()) {
+            ConsoleLogger.info("Could not change email for player '" + player + "' – event was cancelled");
+            service.send(player, MessageKey.EMAIL_CHANGE_NOT_ALLOWED);
+            return;
+        }
+
         auth.setEmail(newEmail);
         if (dataSource.updateEmail(auth)) {
             playerCache.updatePlayer(auth);

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

@@ -4,14 +4,17 @@ import ch.jalu.injector.factory.SingletonStore;
 import fr.xephi.authme.data.auth.PlayerAuth;
 import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.events.AuthMeAsyncPreRegisterEvent;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.AsynchronousProcess;
 import fr.xephi.authme.process.register.executors.RegistrationExecutor;
 import fr.xephi.authme.process.register.executors.RegistrationMethod;
 import fr.xephi.authme.process.register.executors.RegistrationParameters;
+import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.bungeecord.BungeeSender;
 import fr.xephi.authme.service.bungeecord.MessageType;
+import fr.xephi.authme.settings.properties.PluginSettings;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
 import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.util.PlayerUtils;
@@ -32,6 +35,8 @@ public class AsyncRegister implements AsynchronousProcess {
     @Inject
     private PlayerCache playerCache;
     @Inject
+    private BukkitService bukkitService;
+    @Inject
     private CommonService service;
     @Inject
     private SingletonStore<RegistrationExecutor> registrationExecutorFactory;
@@ -44,9 +49,9 @@ public class AsyncRegister implements AsynchronousProcess {
     /**
      * Performs the registration process for the given player.
      *
-     * @param variant the registration method
+     * @param variant    the registration method
      * @param parameters the parameters
-     * @param <P> parameters type
+     * @param <P>        parameters type
      */
     public <P extends RegistrationParameters> void register(RegistrationMethod<P> variant, P parameters) {
         if (preRegisterCheck(parameters.getPlayer())) {
@@ -57,6 +62,13 @@ public class AsyncRegister implements AsynchronousProcess {
         }
     }
 
+    /**
+     * Checks if the player is able to register, in that case the {@link AuthMeAsyncPreRegisterEvent} is invoked.
+     *
+     * @param player the player which is trying to register.
+     *
+     * @return true if the checks are successful and the event hasn't marked the action as denied, false otherwise.
+     */
     private boolean preRegisterCheck(Player player) {
         final String name = player.getName().toLowerCase();
         if (playerCache.isAuthenticated(name)) {
@@ -70,6 +82,13 @@ public class AsyncRegister implements AsynchronousProcess {
             return false;
         }
 
+        boolean isAsync = service.getProperty(PluginSettings.USE_ASYNC_TASKS);
+        AuthMeAsyncPreRegisterEvent event = new AuthMeAsyncPreRegisterEvent(player, isAsync);
+        bukkitService.callEvent(event);
+        if (!event.canRegister()) {
+            return false;
+        }
+
         return isPlayerIpAllowedToRegister(player);
     }
 
@@ -77,11 +96,11 @@ public class AsyncRegister implements AsynchronousProcess {
      * Executes the registration.
      *
      * @param parameters the registration parameters
-     * @param executor the executor to perform the registration process with
-     * @param <P> registration params type
+     * @param executor   the executor to perform the registration process with
+     * @param <P>        registration params type
      */
     private <P extends RegistrationParameters>
-            void executeRegistration(P parameters, RegistrationExecutor<P> executor) {
+    void executeRegistration(P parameters, RegistrationExecutor<P> executor) {
         PlayerAuth auth = executor.buildPlayerAuth(parameters);
         if (database.saveAuth(auth)) {
             executor.executePostPersistAction(parameters);
@@ -95,6 +114,7 @@ public class AsyncRegister implements AsynchronousProcess {
      * Checks whether the registration threshold has been exceeded for the given player's IP address.
      *
      * @param player the player to check
+     *
      * @return true if registration may take place, false otherwise (IP check failed)
      */
     private boolean isPlayerIpAllowedToRegister(Player player) {

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

@@ -2,8 +2,10 @@ package fr.xephi.authme.process.register;
 
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.events.RegisterEvent;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.SynchronousProcess;
+import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.util.PlayerUtils;
 import org.bukkit.entity.Player;
@@ -15,6 +17,9 @@ import javax.inject.Inject;
  */
 public class ProcessSyncEmailRegister implements SynchronousProcess {
 
+    @Inject
+    private BukkitService bukkitService;
+
     @Inject
     private CommonService service;
 
@@ -34,6 +39,7 @@ public class ProcessSyncEmailRegister implements SynchronousProcess {
         limboService.replaceTasksAfterRegistration(player);
 
         player.saveData();
+        bukkitService.callEvent(new RegisterEvent(player));
         ConsoleLogger.fine(player.getName() + " registered " + PlayerUtils.getPlayerIp(player));
     }
 

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

@@ -2,8 +2,10 @@ package fr.xephi.authme.process.register;
 
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.events.RegisterEvent;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.SynchronousProcess;
+import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.bungeecord.BungeeSender;
 import fr.xephi.authme.settings.commandconfig.CommandManager;
@@ -31,6 +33,9 @@ public class ProcessSyncPasswordRegister implements SynchronousProcess {
     @Inject
     private CommandManager commandManager;
 
+    @Inject
+    private BukkitService bukkitService;
+
     ProcessSyncPasswordRegister() {
     }
 
@@ -60,6 +65,7 @@ public class ProcessSyncPasswordRegister implements SynchronousProcess {
         }
 
         player.saveData();
+        bukkitService.callEvent(new RegisterEvent(player));
         ConsoleLogger.fine(player.getName() + " registered " + PlayerUtils.getPlayerIp(player));
 
         // Kick Player after Registration is enabled, kick the player

src/main/java/fr/xephi/authme/task/purge/PurgeExecutor.java

@@ -49,7 +49,7 @@ public class PurgeExecutor {
      * players and names.
      *
      * @param players the players to purge
-     * @param names names to purge
+     * @param names   names to purge
      */
     public void executePurge(Collection<OfflinePlayer> players, Collection<String> names) {
         // Purge other data
@@ -212,15 +212,13 @@ public class PurgeExecutor {
         }
 
         for (OfflinePlayer offlinePlayer : cleared) {
-            try {
-                permissionsManager.loadUserData(offlinePlayer.getUniqueId());
-            } catch (NoSuchMethodError e) {
-                permissionsManager.loadUserData(offlinePlayer.getName());
+            if (!permissionsManager.loadUserData(offlinePlayer)) {
+                ConsoleLogger.warning("Unable to purge the permissions of user " + offlinePlayer + "!");
+                continue;
             }
             permissionsManager.removeAllGroups(offlinePlayer);
         }
 
         ConsoleLogger.info("AutoPurge: Removed permissions from " + cleared.size() + " player(s).");
     }
-    
 }

src/main/java/fr/xephi/authme/task/purge/PurgeTask.java

@@ -3,6 +3,7 @@ package fr.xephi.authme.task.purge;
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.permission.PermissionsManager;
 import fr.xephi.authme.permission.PlayerStatePermission;
+import fr.xephi.authme.permission.handlers.PermissionLoadUserException;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
@@ -73,10 +74,9 @@ class PurgeTask extends BukkitRunnable {
 
             OfflinePlayer offlinePlayer = offlinePlayers[nextPosition];
             if (offlinePlayer.getName() != null && toPurge.remove(offlinePlayer.getName().toLowerCase())) {
-                try {
-                    permissionsManager.loadUserData(offlinePlayer.getUniqueId());
-                } catch (NoSuchMethodError e) {
-                    permissionsManager.loadUserData(offlinePlayer.getName());
+                if(!permissionsManager.loadUserData(offlinePlayer)) {
+                    ConsoleLogger.warning("Unable to check if the user " + offlinePlayer.getName() + " can be purged!");
+                    continue;
                 }
                 if (!permissionsManager.hasPermissionOffline(offlinePlayer, PlayerStatePermission.BYPASS_PURGE)) {
                     playerPortion.add(offlinePlayer);