Del all files
This commit is contained in:
HaHaWTH
@@ -1,23 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,227 +0,0 @@
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
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 {
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -1,90 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user