Sync repo files to b22

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

@@ -0,0 +1,23 @@
+package fr.xephi.authme.permission.handlers;
+
+import net.luckperms.api.context.ImmutableContextSet;
+import net.luckperms.api.model.group.Group;
+
+public class LuckPermGroup {
+    private Group group;
+    private ImmutableContextSet contexts;
+
+    public LuckPermGroup(Group group, ImmutableContextSet contexts) {
+        this.group = group;
+
+        this.contexts = contexts;
+    }
+
+    public Group getGroup() {
+        return group;
+    }
+
+    public ImmutableContextSet getContexts() {
+        return contexts;
+    }
+}

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

@@ -0,0 +1,227 @@
+package fr.xephi.authme.permission.handlers;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.data.limbo.UserGroup;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsSystemType;
+import net.luckperms.api.LuckPerms;
+import net.luckperms.api.LuckPermsProvider;
+import net.luckperms.api.cacheddata.CachedPermissionData;
+import net.luckperms.api.context.ContextSetFactory;
+import net.luckperms.api.model.data.DataMutateResult;
+import net.luckperms.api.model.group.Group;
+import net.luckperms.api.model.user.User;
+import net.luckperms.api.node.NodeEqualityPredicate;
+import net.luckperms.api.node.types.InheritanceNode;
+import net.luckperms.api.query.QueryMode;
+import net.luckperms.api.query.QueryOptions;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
+
+/**
+ * Handler for LuckPerms.
+ *
+ * @see <a href="https://www.spigotmc.org/resources/luckperms-an-advanced-permissions-system.28140/">LuckPerms SpigotMC page</a>
+ * @see <a href="https://github.com/lucko/LuckPerms">LuckPerms on Github</a>
+ */
+public class LuckPermsHandler implements PermissionHandler {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(LuckPermsHandler.class);
+    private LuckPerms luckPerms;
+
+    public LuckPermsHandler() throws PermissionHandlerException {
+        try {
+            luckPerms = LuckPermsProvider.get();
+        } catch (IllegalStateException e) {
+            throw new PermissionHandlerException("Could not get api of LuckPerms", e);
+        }
+    }
+
+    @Override
+    public boolean addToGroup(OfflinePlayer player, UserGroup group) {
+        Group newGroup = luckPerms.getGroupManager().getGroup(group.getGroupName());
+        if (newGroup == null) {
+            return false;
+        }
+
+        String playerName = player.getName();
+        if (playerName == null) {
+            return false;
+        }
+        User user = luckPerms.getUserManager().getUser(playerName);
+        if (user == null) {
+            return false;
+        }
+
+        InheritanceNode node = buildGroupNode(group);
+
+        DataMutateResult result = user.data().add(node);
+        if (result == DataMutateResult.FAIL) {
+            return false;
+        }
+
+        luckPerms.getUserManager().saveUser(user);
+        return true;
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+
+    @Override
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
+        User user = luckPerms.getUserManager().getUser(name);
+        if (user == null) {
+            logger.warning("LuckPermsHandler: tried to check permission for offline user "
+                + name + " but it isn't loaded!");
+            return false;
+        }
+
+        CachedPermissionData permissionData = user.getCachedData()
+            .getPermissionData(QueryOptions.builder(QueryMode.CONTEXTUAL).build());
+        return permissionData.checkPermission(node.getNode()).asBoolean();
+    }
+
+    @Override
+    public boolean isInGroup(OfflinePlayer player, UserGroup group) {
+        String playerName = player.getName();
+        if (playerName == null) {
+            return false;
+        }
+        User user = luckPerms.getUserManager().getUser(playerName);
+        if (user == null) {
+            logger.warning("LuckPermsHandler: tried to check group for offline user "
+                + player.getName() + " but it isn't loaded!");
+            return false;
+        }
+
+        InheritanceNode inheritanceNode = InheritanceNode.builder(group.getGroupName()).build();
+        return user.data().contains(inheritanceNode, NodeEqualityPredicate.EXACT).asBoolean();
+    }
+
+    @Override
+    public boolean removeFromGroup(OfflinePlayer player, UserGroup group) {
+        String playerName = player.getName();
+        if (playerName == null) {
+            return false;
+        }
+        User user = luckPerms.getUserManager().getUser(playerName);
+        if (user == null) {
+            logger.warning("LuckPermsHandler: tried to remove group for offline user "
+                + player.getName() + " but it isn't loaded!");
+            return false;
+        }
+
+        InheritanceNode groupNode = InheritanceNode.builder(group.getGroupName()).build();
+        boolean result = user.data().remove(groupNode) != DataMutateResult.FAIL;
+
+        luckPerms.getUserManager().saveUser(user);
+        return result;
+    }
+
+    @Override
+    public boolean setGroup(OfflinePlayer player, UserGroup group) {
+        String playerName = player.getName();
+        if (playerName == null) {
+            return false;
+        }
+        User user = luckPerms.getUserManager().getUser(playerName);
+        if (user == null) {
+            logger.warning("LuckPermsHandler: tried to set group for offline user "
+                + player.getName() + " but it isn't loaded!");
+            return false;
+        }
+
+        InheritanceNode groupNode = buildGroupNode(group);
+
+        DataMutateResult result = user.data().add(groupNode);
+        if (result == DataMutateResult.FAIL) {
+            return false;
+        }
+        user.data().clear(node -> {
+            if (!(node instanceof InheritanceNode)) {
+                return false;
+            }
+            InheritanceNode inheritanceNode = (InheritanceNode) node;
+            return !inheritanceNode.equals(groupNode);
+        });
+
+        luckPerms.getUserManager().saveUser(user);
+        return true;
+    }
+
+    @Override
+    public List<UserGroup> getGroups(OfflinePlayer player) {
+        String playerName = player.getName();
+        if (playerName == null) {
+            return Collections.emptyList();
+        }
+        User user = luckPerms.getUserManager().getUser(playerName);
+        if (user == null) {
+            logger.warning("LuckPermsHandler: tried to get groups for offline user "
+                + player.getName() + " but it isn't loaded!");
+            return Collections.emptyList();
+        }
+
+        return user.getDistinctNodes().stream()
+            .filter(node -> node instanceof InheritanceNode)
+            .map(node -> (InheritanceNode) node)
+            .map(node -> {
+                Group group = luckPerms.getGroupManager().getGroup(node.getGroupName());
+                if (group == null) {
+                    return null;
+                }
+                return new LuckPermGroup(group, node.getContexts());
+            })
+            .filter(Objects::nonNull)
+            .sorted((o1, o2) -> sortGroups(user, o1, o2))
+            .map(g -> new UserGroup(g.getGroup().getName(), g.getContexts().toFlattenedMap()))
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public PermissionsSystemType getPermissionSystem() {
+        return PermissionsSystemType.LUCK_PERMS;
+    }
+
+    @Override
+    public void loadUserData(UUID uuid) throws PermissionLoadUserException {
+        try {
+            luckPerms.getUserManager().loadUser(uuid).get(5, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            throw new PermissionLoadUserException("Unable to load the permission data of the user " + uuid, e);
+        }
+    }
+
+    @NotNull
+    private InheritanceNode buildGroupNode(UserGroup group) {
+        ContextSetFactory contextSetFactory = luckPerms.getContextManager().getContextSetFactory();
+        InheritanceNode.Builder builder = InheritanceNode.builder(group.getGroupName());
+        if (group.getContextMap() != null) {
+            group.getContextMap().forEach((k, v) -> builder.withContext((contextSetFactory.immutableOf(k, v))));
+        }
+        return builder.build();
+    }
+
+    private int sortGroups(User user, LuckPermGroup o1, LuckPermGroup o2) {
+        Group group1 = o1.getGroup();
+        Group group2 = o2.getGroup();
+        if (group1.getName().equals(user.getPrimaryGroup()) || group2.getName().equals(user.getPrimaryGroup())) {
+            return group1.getName().equals(user.getPrimaryGroup()) ? 1 : -1;
+        }
+
+        int i = Integer.compare(group2.getWeight().orElse(0), group1.getWeight().orElse(0));
+        return i != 0 ? i : group1.getName().compareToIgnoreCase(group2.getName());
+    }
+}

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

@@ -0,0 +1,114 @@
+package fr.xephi.authme.permission.handlers;
+
+import fr.xephi.authme.data.limbo.UserGroup;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsSystemType;
+import fr.xephi.authme.util.Utils;
+import org.bukkit.OfflinePlayer;
+
+import java.util.Collection;
+import java.util.UUID;
+
+public interface PermissionHandler {
+
+    /**
+     * Add the permission group of a player, if supported.
+     *
+     * @param player    The player
+     * @param group 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.
+     */
+    boolean addToGroup(OfflinePlayer player, UserGroup group);
+
+    /**
+     * Check whether the current permissions system has group support.
+     * If no permissions system is hooked, false will be returned.
+     *
+     * @return True if the current permissions system supports groups, false otherwise.
+     */
+    boolean hasGroupSupport();
+
+    /**
+     * Check if a player has permission by their name.
+     * Used to check an offline player's permission.
+     *
+     * @param name  The player's name.
+     * @param node The permission node.
+     *
+     * @return True if the player has permission.
+     */
+    boolean hasPermissionOffline(String name, PermissionNode node);
+
+    /**
+     * Check whether the player is in the specified group.
+     *
+     * @param player    The player.
+     * @param group 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.
+     */
+    default boolean isInGroup(OfflinePlayer player, UserGroup group) {
+        return getGroups(player).contains(group);
+    }
+
+    /**
+     * Remove the permission group of a player, if supported.
+     *
+     * @param player    The player
+     * @param group 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.
+     */
+    boolean removeFromGroup(OfflinePlayer player, UserGroup group);
+
+    /**
+     * Set the permission group of a player, if supported.
+     * This clears the current groups of the player.
+     *
+     * @param player    The player
+     * @param group 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.
+     */
+    boolean setGroup(OfflinePlayer player, UserGroup group);
+
+    /**
+     * Get the permission groups of a player, if available.
+     *
+     * @param player The player.
+     *
+     * @return Permission groups, or an empty list if this feature is not supported.
+     */
+    Collection<UserGroup> getGroups(OfflinePlayer player);
+
+    /**
+     * Get the primary group of a player, if available.
+     *
+     * @param player The player.
+     *
+     * @return The name of the primary permission group. Or null.
+     */
+    default UserGroup getPrimaryGroup(OfflinePlayer player) {
+        Collection<UserGroup> groups = getGroups(player);
+        if (Utils.isCollectionEmpty(groups)) {
+            return null;
+        }
+        return groups.iterator().next();
+    }
+
+    /**
+     * Get the permission system that is being used.
+     *
+     * @return The permission system.
+     */
+    PermissionsSystemType getPermissionSystem();
+
+    default void loadUserData(UUID uuid) throws PermissionLoadUserException {
+    }
+
+}

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

@@ -0,0 +1,16 @@
+package fr.xephi.authme.permission.handlers;
+
+/**
+ * Exception during the instantiation of a {@link PermissionHandler}.
+ */
+@SuppressWarnings("serial")
+public class PermissionHandlerException extends Exception {
+
+    public PermissionHandlerException(String message) {
+        super(message);
+    }
+
+    public PermissionHandlerException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

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/permission/handlers/PermissionsExHandler.java

@@ -0,0 +1,90 @@
+package fr.xephi.authme.permission.handlers;
+
+import fr.xephi.authme.data.limbo.UserGroup;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsSystemType;
+import org.bukkit.OfflinePlayer;
+import ru.tehkode.permissions.PermissionManager;
+import ru.tehkode.permissions.PermissionUser;
+import ru.tehkode.permissions.bukkit.PermissionsEx;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Handler for PermissionsEx.
+ *
+ * @see <a href="https://dev.bukkit.org/projects/permissionsex">PermissionsEx Bukkit page</a>
+ * @see <a href="https://github.com/PEXPlugins/PermissionsEx">PermissionsEx on Github</a>
+ */
+public class PermissionsExHandler implements PermissionHandler {
+
+    private PermissionManager permissionManager;
+
+    public PermissionsExHandler() throws PermissionHandlerException {
+        permissionManager = PermissionsEx.getPermissionManager();
+        if (permissionManager == null) {
+            throw new PermissionHandlerException("Could not get manager of PermissionsEx");
+        }
+    }
+
+    @Override
+    public boolean addToGroup(OfflinePlayer player, UserGroup group) {
+        if (!PermissionsEx.getPermissionManager().getGroupNames().contains(group)) {
+            return false;
+        }
+
+        PermissionUser user = PermissionsEx.getUser(player.getName());
+        user.addGroup(group.getGroupName());
+        return true;
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+
+    @Override
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
+        PermissionUser user = permissionManager.getUser(name);
+        return user.has(node.getNode());
+    }
+
+    @Override
+    public boolean isInGroup(OfflinePlayer player, UserGroup group) {
+        PermissionUser user = permissionManager.getUser(player.getName());
+        return user.inGroup(group.getGroupName());
+    }
+
+    @Override
+    public boolean removeFromGroup(OfflinePlayer player, UserGroup group) {
+        PermissionUser user = permissionManager.getUser(player.getName());
+        user.removeGroup(group.getGroupName());
+        return true;
+    }
+
+    @Override
+    public boolean setGroup(OfflinePlayer player, UserGroup group) {
+        List<String> groups = new ArrayList<>();
+        groups.add(group.getGroupName());
+
+        PermissionUser user = permissionManager.getUser(player.getName());
+        user.setParentsIdentifier(groups);
+        return true;
+    }
+
+    @Override
+    public List<UserGroup> getGroups(OfflinePlayer player) {
+        PermissionUser user = permissionManager.getUser(player.getName());
+        return user.getParentIdentifiers(null).stream()
+            .map(i -> new UserGroup(i, null))
+            .collect(toList());
+    }
+
+    @Override
+    public PermissionsSystemType getPermissionSystem() {
+        return PermissionsSystemType.PERMISSIONS_EX;
+    }
+}

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

@@ -0,0 +1,105 @@
+package fr.xephi.authme.permission.handlers;
+
+import com.google.common.annotations.VisibleForTesting;
+import fr.xephi.authme.data.limbo.UserGroup;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsSystemType;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Server;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Handler for permissions via Vault.
+ *
+ * @see <a href="https://dev.bukkit.org/projects/vault">Vault Bukkit page</a>
+ * @see <a href="https://github.com/milkbowl/Vault">Vault on Github</a>
+ */
+public class VaultHandler implements PermissionHandler {
+
+    private Permission vaultProvider;
+
+    public VaultHandler(Server server) throws PermissionHandlerException {
+        this.vaultProvider = getVaultPermission(server);
+    }
+
+    /**
+     * Returns the Vault Permission interface.
+     *
+     * @param server the bukkit server instance
+     * @return the vault permission instance
+     * @throws PermissionHandlerException if the vault permission instance cannot be retrieved
+     */
+    @VisibleForTesting
+    Permission getVaultPermission(Server server) throws PermissionHandlerException {
+        // Get the permissions provider service
+        RegisteredServiceProvider<Permission> permissionProvider = server
+            .getServicesManager().getRegistration(Permission.class);
+        if (permissionProvider == null) {
+            throw new PermissionHandlerException("Could not load permissions provider service");
+        }
+
+        // Get the Vault provider and make sure it's valid
+        Permission vaultPerms = permissionProvider.getProvider();
+        if (vaultPerms == null) {
+            throw new PermissionHandlerException("Could not load Vault permissions provider");
+        }
+        return vaultPerms;
+    }
+
+    @Override
+    public boolean addToGroup(OfflinePlayer player, UserGroup group) {
+        return vaultProvider.playerAddGroup(null, player, group.getGroupName());
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return vaultProvider.hasGroupSupport();
+    }
+
+    @Override
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
+        return vaultProvider.has((String) null, name, node.getNode());
+    }
+
+    @Override
+    public boolean isInGroup(OfflinePlayer player, UserGroup group) {
+        return vaultProvider.playerInGroup(null, player, group.getGroupName());
+    }
+
+    @Override
+    public boolean removeFromGroup(OfflinePlayer player, UserGroup group) {
+        return vaultProvider.playerRemoveGroup(null, player, group.getGroupName());
+    }
+
+    @Override
+    public boolean setGroup(OfflinePlayer player, UserGroup group) {
+        for (UserGroup g : getGroups(player)) {
+            removeFromGroup(player, g);
+        }
+
+        return vaultProvider.playerAddGroup(null, player, group.getGroupName());
+    }
+
+    @Override
+    public List<UserGroup> getGroups(OfflinePlayer player) {
+        String[] groups = vaultProvider.getPlayerGroups(null, player);
+        return groups == null ? Collections.emptyList() : Arrays.stream(groups).map(UserGroup::new).collect(toList());
+    }
+
+    @Override
+    public UserGroup getPrimaryGroup(OfflinePlayer player) {
+        return new UserGroup(vaultProvider.getPrimaryGroup(null, player));
+    }
+
+    @Override
+    public PermissionsSystemType getPermissionSystem() {
+        return PermissionsSystemType.VAULT;
+    }
+}

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

@@ -0,0 +1,79 @@
+package fr.xephi.authme.permission.handlers;
+
+import fr.xephi.authme.data.limbo.UserGroup;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsSystemType;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService;
+
+import java.util.Collection;
+import java.util.Map;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Handler for zPermissions.
+ *
+ * @see <a href="https://dev.bukkit.org/projects/zpermissions">zPermissions Bukkit page</a>
+ * @see <a href="https://github.com/ZerothAngel/zPermissions">zPermissions on Github</a>
+ */
+public class ZPermissionsHandler implements PermissionHandler {
+
+    private ZPermissionsService zPermissionsService;
+
+    public ZPermissionsHandler() throws PermissionHandlerException {
+        // Set the zPermissions service and make sure it's valid
+        ZPermissionsService zPermissionsService = Bukkit.getServicesManager().load(ZPermissionsService.class);
+        if (zPermissionsService == null) {
+            throw new PermissionHandlerException("Failed to get the ZPermissions service!");
+        }
+        this.zPermissionsService = zPermissionsService;
+    }
+
+    @Override
+    public boolean addToGroup(OfflinePlayer player, UserGroup group) {
+        return Bukkit.dispatchCommand(Bukkit.getConsoleSender(),
+            "permissions player " + player.getName() + " addgroup " + group.getGroupName());
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+
+    @Override
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
+        Map<String, Boolean> perms = zPermissionsService.getPlayerPermissions(null, null, name);
+        return perms.getOrDefault(node.getNode(), false);
+    }
+
+    @Override
+    public boolean removeFromGroup(OfflinePlayer player, UserGroup group) {
+        return Bukkit.dispatchCommand(Bukkit.getConsoleSender(),
+            "permissions player " + player.getName() + " removegroup " + group.getGroupName());
+    }
+
+    @Override
+    public boolean setGroup(OfflinePlayer player, UserGroup group) {
+        return Bukkit.dispatchCommand(Bukkit.getConsoleSender(),
+            "permissions player " + player.getName() + " setgroup " + group.getGroupName());
+    }
+
+    @Override
+    public Collection<UserGroup> getGroups(OfflinePlayer player) {
+        return zPermissionsService.getPlayerGroups(player.getName()).stream()
+            .map(UserGroup::new)
+            .collect(toList());
+    }
+
+    @Override
+    public UserGroup getPrimaryGroup(OfflinePlayer player) {
+        return new UserGroup(zPermissionsService.getPlayerPrimaryGroup(player.getName()));
+    }
+
+    @Override
+    public PermissionsSystemType getPermissionSystem() {
+        return PermissionsSystemType.Z_PERMISSIONS;
+    }
+}