From 8d266a34400d3eee173470e873b2385564c96f7a Mon Sep 17 00:00:00 2001 From: snowleo Date: Sun, 18 Sep 2011 02:02:09 +0200 Subject: [PATCH 1/3] Fix GroupBridge build --- .../nbproject/project.properties | 2 - .../src/com/nijiko/permissions/Entry.java | 5 + .../src/com/nijiko/permissions/Group.java | 6 + .../nijiko/permissions/PermissionHandler.java | 458 ++++++++++++++++++ .../src/com/nijiko/permissions/User.java | 5 + 5 files changed, 474 insertions(+), 2 deletions(-) create mode 100644 EssentialsGroupBridge/src/com/nijiko/permissions/Entry.java create mode 100644 EssentialsGroupBridge/src/com/nijiko/permissions/Group.java create mode 100644 EssentialsGroupBridge/src/com/nijiko/permissions/PermissionHandler.java create mode 100644 EssentialsGroupBridge/src/com/nijiko/permissions/User.java diff --git a/EssentialsGroupBridge/nbproject/project.properties b/EssentialsGroupBridge/nbproject/project.properties index 28cec30c9..3a2d806fb 100644 --- a/EssentialsGroupBridge/nbproject/project.properties +++ b/EssentialsGroupBridge/nbproject/project.properties @@ -40,14 +40,12 @@ dist.javadoc.dir=${dist.dir}/javadoc endorsed.classpath= excludes= file.reference.bukkit-0.0.1-SNAPSHOT.jar=../lib/bukkit-0.0.1-SNAPSHOT.jar -file.reference.Permissions3.jar=../lib/Permissions3.jar includes=** jar.archive.disabled=${jnlp.enabled} jar.compress=true jar.index=${jnlp.enabled} javac.classpath=\ ${reference.EssentialsGroupManager.jar}:\ - ${file.reference.Permissions3.jar}:\ ${file.reference.bukkit-0.0.1-SNAPSHOT.jar} # Space-separated list of extra javac options javac.compilerargs= diff --git a/EssentialsGroupBridge/src/com/nijiko/permissions/Entry.java b/EssentialsGroupBridge/src/com/nijiko/permissions/Entry.java new file mode 100644 index 000000000..913c7f51e --- /dev/null +++ b/EssentialsGroupBridge/src/com/nijiko/permissions/Entry.java @@ -0,0 +1,5 @@ +package com.nijiko.permissions; + +public class Entry { + +} diff --git a/EssentialsGroupBridge/src/com/nijiko/permissions/Group.java b/EssentialsGroupBridge/src/com/nijiko/permissions/Group.java new file mode 100644 index 000000000..0d070c207 --- /dev/null +++ b/EssentialsGroupBridge/src/com/nijiko/permissions/Group.java @@ -0,0 +1,6 @@ +package com.nijiko.permissions; + +public class Group extends Entry { + + +} \ No newline at end of file diff --git a/EssentialsGroupBridge/src/com/nijiko/permissions/PermissionHandler.java b/EssentialsGroupBridge/src/com/nijiko/permissions/PermissionHandler.java new file mode 100644 index 000000000..3b7181d03 --- /dev/null +++ b/EssentialsGroupBridge/src/com/nijiko/permissions/PermissionHandler.java @@ -0,0 +1,458 @@ +package com.nijiko.permissions; + +import java.util.Collection; +import java.util.Comparator; +import java.util.Map; +import java.util.Set; + +import org.bukkit.entity.Player; + +/** + * Permissions 3.0 + * Copyright (C) 2011 Matt 'The Yeti' Burnett + * Original Credit & Copyright (C) 2010 Nijikokun + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Permissions Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Permissions Public License for more details. + * + * You should have received a copy of the GNU Permissions Public License + * along with this program. If not, see . + */ + +public abstract class PermissionHandler { + //World config manipulation methods + + /** + * Sets the default world that is loaded on startup. + * @param world World to load on startup + */ + public abstract void setDefaultWorld(String world); + /** + * Check if world is loaded. + * A world is considered as loaded if there exists a user/group storage for it or it mirrors another world. + * @param world Target world + * @return Whether the world is loaded. + */ + public abstract boolean checkWorld(String world); + + /** + * Attempts to load a world. If the world is already loaded, nothing happens. + * @param world World to load + * @return Whether world isn't already loaded + * @throws Exception Any exception that may occur when loading the world. + */ + public abstract boolean loadWorld(String world) throws Exception; + /** + * Forces a load of the world. + * @param world World to load + * @throws Exception Any exception that may occur when loading the world. + */ + public abstract void forceLoadWorld(String world) throws Exception; + /** + * Returns a set of the names all loaded worlds. + * A world is considered as loaded if there exists a user/group storage for it or it mirrors another world. + * @return Set of the names all loaded worlds. + */ + public abstract Set getWorlds(); + /** + * Loads the default world and global permissions. + * @throws Exception Any exception that may occur when loading the worlds. + */ + public abstract void load() throws Exception; + /** + * Reloads all worlds + */ + public abstract void reload(); + /** + * Reloads the specified world + * @param world Name of target world + * @return False if world is not loaded, true otherwise + */ + public abstract boolean reload(String world); + /** + * Forces all storages to save, + */ + public abstract void saveAll(); + /** + * This method forces a save of the specified world + * @param world Name of target world + */ + public abstract void save(String world); + /** + * Forces all storages to close. + */ + public abstract void closeAll(); + + //Permission-checking methods + /** + * This is an alias for permission(Player, String). + * @param player Target player + * @param node Permission node + * @return True if the player has the specified node, false otherwise + */ + public abstract boolean has(Player player, String node); + /** + * This is an alias for permission(String, String, String). + * @param worldName Target world (may be different from player's current world) + * @param playerName Player's name + * @param node Permission node + * @return True if the player has the specified node, false otherwise + */ + public abstract boolean has(String worldName, String playerName, String node); + /** + * This method checks if the player has the given permissions in his/her current world. + * In other words, this calls permissions(player.getWorld().getName(), player.getName(), node). + * @param player Target player + * @param node Permission node + * @return True if the player has the specified node, false otherwise + */ + public abstract boolean permission(Player player, String node); + /** + * This method checks if the player has the given permissions in the given world. + * @param worldName Target world (may be different from player's current world) + * @param playerName Player's name + * @param node Permission node + * @return True if the player has the specified node, false otherwise + */ + public abstract boolean permission(String worldName, String playerName, String node); + + //Permission-manipulation methods + /** + * Adds the given permission to the targeted player. + * @param world Target world (may be different from player's current world) + * @param user Player's name + * @param node Permission node + */ + public abstract void addUserPermission(String world, String user, String node); + /** + * Removes the given permission from the targeted player. + * @param world Target world (may be different from player's current world) + * @param user Player's name + * @param node Permission node + */ + public abstract void removeUserPermission(String world, String user, String node); + /** + * Adds the given permission to the targeted group. + * @param world Target world + * @param user Group's name + * @param node Permission node + */ + public abstract void addGroupPermission(String world, String user, String node); + /** + * Removes the given permission from the targeted group. + * @param world Target world + * @param user Group's name + * @param node Permission node + */ + public abstract void removeGroupPermission(String world, String user, String node); + + //Chat, prefix, suffix, build methods + /** + * Retrieves the properly-capitalised version of the given group's name. + * Returns an empty string if group does not exist. + * @param world Group's world + * @param group Group's name (any capitalisation) + * @return Group's properly-capitalised name. + */ + public abstract String getGroupProperName(String world, String group); + /** + * Gets the appropriate prefix for the user. + * This method is a utility method for chat plugins to get the user's prefix + * without having to look at every one of the user's ancestors. + * Returns an empty string if user has no parent groups. + * @param world Player's world + * @param user Player's name + * @return Player's prefix + */ + public abstract String getUserPrefix(String world, String user); + /** + * Gets the appropriate suffix for the user. + * This method is a utility method for chat plugins to get the user's suffix + * without having to look at every one of the user's ancestors. + * Returns an empty string if user has no parent groups. + * @param world Player's world + * @param user Player's name + * @return Player's suffix + */ + public abstract String getUserSuffix(String world, String user); + /** + * Gets the primary group of the user. + * Returns the default group if user has no parent groups, + * or null if there is no default group for that world. + * @param world Player's world + * @param user Player's name + * @return Player's primary group + */ + public abstract Group getPrimaryGroupObject(String world, String user); + /** + * Gets name of the primary group of the user. + * Returns the name of the default group if user has no parent groups, + * or "Default" if there is no default group for that world. + * @param world Player's world + * @param user Player's name + * @return Name of player's primary group + */ + public abstract String getPrimaryGroup(String world, String user); + /** + * Check if user can build. + * @param world Player's world + * @param user Player's name + * @return Whether the user can build + */ + public abstract boolean canUserBuild(String world, String user); + + /** + * Retrieves group's raw prefix, inheritance not included. + * Will return an empty string if no prefix is defined for the group. + * @param world Group's world + * @param group Group's name + * @return The prefix defined for the group, empty string if prefix is not defined. + */ + public abstract String getGroupRawPrefix(String world, String group); + /** + * Retrieves group's raw suffix, inheritance not included. + * Will return an empty string if no suffix is defined for the group. + * @param world Group's world + * @param group Group's name + * @return The suffix defined for the group, empty string if suffix is not defined. + */ + public abstract String getGroupRawSuffix(String world, String group); + /** + * Retrieves group's build setting, inheritance not included. + * @param world Group's world + * @param group Group's name + * @return Returns group's build setting. + */ + public abstract boolean canGroupRawBuild(String world, String group); + + //Entry methods + /** + * Returns the user object defined by the given world and name. + * This method attempts to create the object if it does not exist. + * @param world User's world + * @param name User's name + * @return User object + * @throws Exception An exception when creating the user object + */ + public abstract User safeGetUser(String world, String name) throws Exception; + /** + * Returns the group object defined by the given world and name. + * This method attempts to create the object if it does not exist. + * @param world Group's world + * @param name Group's name + * @return Group object + * @throws Exception An exception when creating the group object + */ + public abstract Group safeGetGroup(String world, String name) throws Exception; + /** + * Returns the user object defined by the given world and name. + * This method will return null if the object does not exist. + * @param world User's world + * @param name User's name + * @return User object, or null if it doesn't exist + */ + public abstract User getUserObject(String world, String name); + /** + * Returns the group object defined by the given world and name. + * This method will return null if the object does not exist. + * @param world Group's world + * @param name Group's name + * @return Group object, or null if it doesn't exist + */ + public abstract Group getGroupObject(String world, String name); + + /** + * Returns the group object representing the default group of the given world. + * This method will return null if the object does not exist or the world has no default group. + * @param world Target world + * @return Group object representing default world, or null if it doesn't exist or is not defined. + */ + public abstract Group getDefaultGroup(String world); + /** + * Returns all the user objects in the world. + * Will return null if world does not exist. + * @param world Target world + * @return Collection of all user objects belonging to the world. + */ + public abstract Collection getUsers(String world); + /** + * Returns all the group objects in the world. + * Will return null if world does not exist. + * @param world Target world + * @return Collection of all group objects belonging to the world. + */ + public abstract Collection getGroups(String world); + + //Parent-related methods + public abstract Set getTracks(String world); + /** + * Checks if user is in specified group. Includes inherited groups. + * @param world World of both the user and the group + * @param user User's name + * @param group Parent group's name + * @return Whether user is a child of the specified group + */ + public abstract boolean inGroup(String world, String user, String group); + /** + * Checks if user is in specified group. Includes inherited groups. + * @param world User's world + * @param user User's name + * @param groupWorld Parent group's world + * @param group Parent group's name + * @return Whether user is a child of the specified group + */ + public abstract boolean inGroup(String world, String user, String groupWorld, String group); + /** + * Checks if user is in specified group, not counting inherited parents. + * @param world World of both the user and the group + * @param user User's name + * @param group Parent group's name + * @return Whether user is a child of the specified group + */ + public abstract boolean inSingleGroup(String world, String user, String group); + /** + * Checks if user is in specified group, not counting inherited parents. + * @param world User's world + * @param user User's name + * @param groupWorld Parent group's world + * @param group Parent group's name + * @return Whether user is a child of the specified group + */ + public abstract boolean inSingleGroup(String world, String user, String groupWorld, String group); + /** + * Gets a array of the names of all parent groups in the same world. + * @param world Target user's world + * @param name Target user's name + * @return An array containing the names of all parent groups (including ancestors) that are in the same world + */ + public abstract String[] getGroups(String world, String name); + /** + * Gets a map of world name to all parent groups of the target user in that world. + * @param world Target user's world + * @param name Target user's name + * @return Map of world name to set of groups that the user inherits from in the world. + */ + public abstract Map> getAllGroups(String world, String name); + + //Weight-related methods + /** + * Compare the weights of two users. + * This method is for plugin devs to compare whether a user can do an action to another user. + * For example, SlapPlugin can compare the weights of two users when one of them wants to /slap the other. + * It can decide whether to allow the slap using the result of this function. + * @param firstWorld First user's world + * @param first First user's name + * @param secondWorld Second user's world + * @param second Second user's name + * @return -1 if firstWeight < secondWeight, 0 if firstWeight == secondWeight, 1 if firstWeight > secondWeight + */ + public abstract int compareWeights(String firstWorld, String first, String secondWorld, String second); + /** + * Alias for compareWeights(world, first, world, second). + * @param world World + * @param first First user's name + * @param second Second user's name + * @return -1 if firstWeight < secondWeight, 0 if firstWeight == secondWeight, 1 if firstWeight > secondWeight + */ + public abstract int compareWeights(String world, String first, String second); + + //Data-related methods + public abstract String getRawInfoString(String world, String entryName, String path,boolean isGroup); + + public abstract Integer getRawInfoInteger(String world, String entryName, String path, boolean isGroup); + + public abstract Double getRawInfoDouble(String world, String entryName, String path, boolean isGroup); + + public abstract Boolean getRawInfoBoolean(String world, String entryName, String path, boolean isGroup); + + + public abstract String getInfoString(String world, String entryName, String path,boolean isGroup); + public abstract String getInfoString(String world, String entryName, String path, boolean isGroup, Comparator comparator); + + public abstract Integer getInfoInteger(String world, String entryName, String path, boolean isGroup); + public abstract Integer getInfoInteger(String world, String entryName, String path, boolean isGroup, Comparator comparator); + + public abstract Double getInfoDouble(String world, String entryName, String path, boolean isGroup); + public abstract Double getInfoDouble(String world, String entryName, String path, boolean isGroup, Comparator comparator); + + public abstract Boolean getInfoBoolean(String world, String entryName, String path, boolean isGroup); + public abstract Boolean getInfoBoolean(String world, String entryName, String path, boolean isGroup, Comparator comparator); + + + public abstract void addUserInfo(String world, String name, String path, Object data); + public abstract void removeUserInfo(String world, String name, String path); + public abstract void addGroupInfo(String world, String name, String path, Object data); + public abstract void removeGroupInfo(String world, String name, String path); + + //Legacy methods + @Deprecated + public abstract String getGroupPermissionString(String world, String group, String path); + @Deprecated + public abstract int getGroupPermissionInteger(String world, String group, String path); + @Deprecated + public abstract boolean getGroupPermissionBoolean(String world, String group, String path); + @Deprecated + public abstract double getGroupPermissionDouble(String world, String group, String path); + + @Deprecated + public abstract String getUserPermissionString(String world, String group, String path); + @Deprecated + public abstract int getUserPermissionInteger(String world, String group, String path); + @Deprecated + public abstract boolean getUserPermissionBoolean(String world, String group, String path); + @Deprecated + public abstract double getUserPermissionDouble(String world, String group, String path); + + @Deprecated + public abstract String getPermissionString(String world, String group, String path); + @Deprecated + public abstract int getPermissionInteger(String world, String group, String path); + @Deprecated + public abstract boolean getPermissionBoolean(String world, String group, String path); + @Deprecated + public abstract double getPermissionDouble(String world, String group, String path); + + + @Deprecated + public abstract String getGroup(String world, String group); + + @Deprecated + public abstract String getGroupPrefix(String world, String group); + @Deprecated + public abstract String getGroupSuffix(String world, String group); + @Deprecated + public abstract boolean canGroupBuild(String world, String group); + + //Cache methods are no longer available +// @Deprecated +// public void setCache(String world, Map Cache) { +// } +// @Deprecated +// public void setCacheItem(String world, String player, String permission, boolean data){ +// } +// @Deprecated +// public Map getCache(String world){ +// return null; +// } +// @Deprecated +// public boolean getCacheItem(String world, String player, String permission){ +// return false; +// } +// @Deprecated +// public void removeCachedItem(String world, String player, String permission){ +// } +// @Deprecated +// public void clearCache(String world){ +// } +// @Deprecated +// public void clearAllCache(){ +// } + +} \ No newline at end of file diff --git a/EssentialsGroupBridge/src/com/nijiko/permissions/User.java b/EssentialsGroupBridge/src/com/nijiko/permissions/User.java new file mode 100644 index 000000000..9e93d850a --- /dev/null +++ b/EssentialsGroupBridge/src/com/nijiko/permissions/User.java @@ -0,0 +1,5 @@ +package com.nijiko.permissions; + +public class User extends Entry { + +} From d3f6e82474c2c67a3fb17a7b08a8a94b8eb7ae60 Mon Sep 17 00:00:00 2001 From: ElgarL Date: Mon, 19 Sep 2011 22:51:07 +0100 Subject: [PATCH 2/3] - Push updates to superperms for all valid GM commands. --- EssentialsGroupManager/src/Changelog.txt | 4 +- .../anjocaido/groupmanager/GroupManager.java | 43 ++++++++++++++++++- .../permissions/BukkitPermissions.java | 34 +++++++-------- 3 files changed, 60 insertions(+), 21 deletions(-) diff --git a/EssentialsGroupManager/src/Changelog.txt b/EssentialsGroupManager/src/Changelog.txt index 56f52a998..7777af29d 100644 --- a/EssentialsGroupManager/src/Changelog.txt +++ b/EssentialsGroupManager/src/Changelog.txt @@ -9,5 +9,5 @@ v 1.1: - Fix for Users.yml containing only 'users:' causing a crash. - GroupManager will now generate a fresh Users and Groups yml if either file is empty. - Fix for an infinite loop bug with the new Bukkit Perms during a new user creation. -v 1.2: - - Fixed BukkitPerms population. Wasn't correctly setting superperms. \ No newline at end of file + - Fixed BukkitPerms population. Wasn't correctly setting superperms. + - Push updates to superperms for all valid GM commands. \ No newline at end of file diff --git a/EssentialsGroupManager/src/org/anjocaido/groupmanager/GroupManager.java b/EssentialsGroupManager/src/org/anjocaido/groupmanager/GroupManager.java index e0a29f509..8e77e2f07 100644 --- a/EssentialsGroupManager/src/org/anjocaido/groupmanager/GroupManager.java +++ b/EssentialsGroupManager/src/org/anjocaido/groupmanager/GroupManager.java @@ -208,7 +208,7 @@ public class GroupManager extends JavaPlugin { public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) { boolean playerCanDo = false; boolean isConsole = false; - Player senderPlayer = null; + Player senderPlayer = null, targetPlayer = null; Group senderGroup = null; User senderUser = null; @@ -340,6 +340,9 @@ public class GroupManager extends JavaPlugin { //PARECE OK auxUser.setGroup(auxGroup); sender.sendMessage(ChatColor.YELLOW + "You changed player '" + auxUser.getName() + "' group to '" + auxGroup.getName() + "'."); + + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); return true; //break; @@ -374,6 +377,9 @@ public class GroupManager extends JavaPlugin { //PARECE OK dataHolder.removeUser(auxUser.getName()); sender.sendMessage(ChatColor.YELLOW + "You changed player '" + auxUser.getName() + "' to default settings."); + + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); return true; case manuaddsub: @@ -416,6 +422,9 @@ public class GroupManager extends JavaPlugin { auxUser.addSubGroup(auxGroup); sender.sendMessage(ChatColor.YELLOW + "You changed player '" + auxUser.getName() + "' group to '" + auxGroup.getName() + "'."); + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); + return true; case manudelsub: //VALIDANDO ESTADO DO SENDER @@ -449,6 +458,9 @@ public class GroupManager extends JavaPlugin { auxUser.removeSubGroup(auxGroup); sender.sendMessage(ChatColor.YELLOW + "You removed subgroup '" + auxGroup.getName() + "' from player '" + auxUser.getName() + "' list."); + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); + return true; case mangadd: //VALIDANDO ESTADO DO SENDER @@ -491,6 +503,8 @@ public class GroupManager extends JavaPlugin { dataHolder.removeGroup(auxGroup.getName()); sender.sendMessage(ChatColor.YELLOW + "You deleted a group named " + auxGroup.getName() + ", it's users are default group now."); + BukkitPermissions.updateAllPlayers(); + return true; case manuaddp: //VALIDANDO ESTADO DO SENDER @@ -554,6 +568,10 @@ public class GroupManager extends JavaPlugin { //PARECE OK auxUser.addPermission(args[1]); sender.sendMessage(ChatColor.YELLOW + "You added '" + args[1] + "' to player '" + auxUser.getName() + "' permissions."); + + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); + return true; //break; case manudelp: @@ -604,6 +622,9 @@ public class GroupManager extends JavaPlugin { //PARECE OK auxUser.removePermission(args[1]); sender.sendMessage(ChatColor.YELLOW + "You removed '" + args[1] + "' from player '" + auxUser.getName() + "' permissions."); + + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); return true; //break; @@ -759,6 +780,8 @@ public class GroupManager extends JavaPlugin { //PARECE OK auxGroup.addPermission(args[1]); sender.sendMessage(ChatColor.YELLOW + "You added '" + args[1] + "' to group '" + auxGroup.getName() + "' permissions."); + + BukkitPermissions.updateAllPlayers(); return true; case mangdelp: @@ -799,6 +822,8 @@ public class GroupManager extends JavaPlugin { auxGroup.removePermission(args[1]); sender.sendMessage(ChatColor.YELLOW + "You removed '" + args[1] + "' from group '" + auxGroup.getName() + "' permissions."); + BukkitPermissions.updateAllPlayers(); + return true; case manglistp: //VALIDANDO ESTADO DO SENDER @@ -912,6 +937,8 @@ public class GroupManager extends JavaPlugin { auxGroup.addInherits(auxGroup2); sender.sendMessage(ChatColor.RED + "Group " + auxGroup2.getName() + " is now in " + auxGroup.getName() + " inheritance list."); + BukkitPermissions.updateAllPlayers(); + return true; case mangdeli: //VALIDANDO ESTADO DO SENDER @@ -947,6 +974,8 @@ public class GroupManager extends JavaPlugin { auxGroup.removeInherits(auxGroup2.getName()); sender.sendMessage(ChatColor.RED + "Group " + auxGroup2.getName() + " was removed from " + auxGroup.getName() + " inheritance list."); + BukkitPermissions.updateAllPlayers(); + return true; case manuaddv: //VALIDANDO ESTADO DO SENDER @@ -1394,6 +1423,9 @@ public class GroupManager extends JavaPlugin { } worldsHolder.loadWorld(auxString); sender.sendMessage("The request to world '" + auxString + "' was sent."); + + BukkitPermissions.updateAllPlayers(); + return true; } //VALIDANDO ESTADO DO SENDER @@ -1418,6 +1450,9 @@ public class GroupManager extends JavaPlugin { sender.sendMessage(ChatColor.YELLOW + " The current world was reloaded."); } worldsHolder.mirrorSetUp(); + + BukkitPermissions.updateAllPlayers(); + return true; case listgroups: //VALIDANDO ESTADO DO SENDER @@ -1487,6 +1522,9 @@ public class GroupManager extends JavaPlugin { //PARECE OK auxUser.setGroup(auxGroup); sender.sendMessage(ChatColor.YELLOW + "You changed " + auxUser.getName() + " group to " + auxGroup.getName() + "."); + + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); return true; //break; @@ -1542,6 +1580,9 @@ public class GroupManager extends JavaPlugin { //PARECE OK auxUser.setGroup(auxGroup); sender.sendMessage(ChatColor.YELLOW + "You changed " + auxUser.getName() + " group to " + auxGroup.getName() + "."); + + targetPlayer = this.getServer().getPlayer(auxUser.getName()); + if (targetPlayer != null) BukkitPermissions.updatePermissions(targetPlayer); return true; //break; diff --git a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java index fe381c127..c88f48d6c 100644 --- a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java +++ b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java @@ -18,12 +18,13 @@ package org.anjocaido.groupmanager.permissions; import java.util.HashMap; import java.util.HashSet; -import java.util.List; import java.util.Map; import java.util.Set; import org.anjocaido.groupmanager.GroupManager; import org.anjocaido.groupmanager.data.User; +import org.anjocaido.groupmanager.dataholder.OverloadedWorldHolder; +import org.anjocaido.groupmanager.utils.PermissionCheckResult; import org.bukkit.Bukkit; import org.bukkit.entity.Player; @@ -40,6 +41,7 @@ import org.bukkit.event.server.PluginEnableEvent; import org.bukkit.event.server.ServerListener; import org.bukkit.permissions.Permission; import org.bukkit.permissions.PermissionAttachment; +import org.bukkit.permissions.PermissionAttachmentInfo; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.PluginManager; @@ -114,9 +116,10 @@ public class BukkitPermissions { } PermissionAttachment attachment = this.attachments.get(player); + + OverloadedWorldHolder worldData = GroupManager.getWorldsHolder().getWorldData(world); - User user = GroupManager.getWorldsHolder().getWorldData(world).getUser(player.getName()); - List permissions = user.getGroup().getPermissionList(); + User user = worldData.getUser(player.getName()); // clear permissions for (String permission : attachment.getPermissions().keySet()) { @@ -125,24 +128,19 @@ public class BukkitPermissions { // find matching permissions for (Permission permission : registeredPermissions) { - boolean permissionValue = user.getGroup().hasSamePermissionNode(permission.getName()); - attachment.setPermission(permission, permissionValue); + PermissionCheckResult permissionResult = worldData.getPermissionsHandler().checkFullUserPermission(user, permission.getName()); + Boolean value = false; + if (permissionResult.resultType.equals(PermissionCheckResult.Type.NEGATION)) { + value = false; + } else if (permissionResult.resultType.equals(PermissionCheckResult.Type.FOUND)) + value = true; + + + attachment.setPermission(permission, value); } - // all permissions - for (String permission : permissions) { - Boolean value = true; - if (permission.startsWith("-")) { - permission = permission.substring(1); // cut off - - value = false; - } - - if (!attachment.getPermissions().containsKey(permission)) { - attachment.setPermission(permission, value); - } - } - player.recalculatePermissions(); + /* // List perms for this player GroupManager.logger.info("Attachment Permissions:"); From f2dd51cf573ccf403f687e5a863ba449af77b766 Mon Sep 17 00:00:00 2001 From: ElgarL Date: Tue, 20 Sep 2011 10:35:05 +0100 Subject: [PATCH 3/3] Fix for pushing perms of non superperms supporting plugins --- .../permissions/AnjoPermissionsHandler.java | 70 +++++++++++++++++++ .../permissions/BukkitPermissions.java | 33 ++++++--- .../PermissionsReaderInterface.java | 4 ++ 3 files changed, 99 insertions(+), 8 deletions(-) mode change 100755 => 100644 EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/AnjoPermissionsHandler.java mode change 100755 => 100644 EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/PermissionsReaderInterface.java diff --git a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/AnjoPermissionsHandler.java b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/AnjoPermissionsHandler.java old mode 100755 new mode 100644 index b892e653e..5830f0c88 --- a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/AnjoPermissionsHandler.java +++ b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/AnjoPermissionsHandler.java @@ -79,6 +79,76 @@ public class AnjoPermissionsHandler extends PermissionsReaderInterface { public String getGroup(String userName) { return ph.getUser(userName).getGroup().getName(); } + + /** + * Returns All permissions (including inheritance) of player name. + * @param userName + * @return + */ + @Override + public List getAllPlayersPermissions(String userName) { + + User user = ph.getUser(userName); + List playerPermArray = new ArrayList(user.getPermissionList()); + List playerMainGroupPermArray = new ArrayList(user.getGroup().getPermissionList()); + List subGroupsPermArray = new ArrayList(); + List returnPermArray = new ArrayList(); + + for (String subGroup : user.subGroupListStringCopy()) { + subGroupsPermArray.addAll(ph.getGroup(subGroup).getPermissionList()); + } + + for (String permission : subGroupsPermArray) { + /* + * Add each Negated permission + * unless it's being overridden by a higher permission + */ + if (permission.startsWith("-") + && !playerMainGroupPermArray.contains(permission.substring(1)) + && !playerPermArray.contains(permission.substring(1)) + && !playerMainGroupPermArray.contains("*") + && !playerPermArray.contains("*")) { + if (!returnPermArray.contains(permission)) { + returnPermArray.add(permission); + } + } else + if (!returnPermArray.contains(permission) + && !playerMainGroupPermArray.contains("-"+permission) + && !playerPermArray.contains("-"+permission)) { + returnPermArray.add(permission); + } + } + + for (String permission : playerMainGroupPermArray) { + /* + * Add each Negated permission + * unless it's being overridden by a higher permission + */ + if (permission.startsWith("-") + && !playerPermArray.contains(permission.substring(1)) + && !playerMainGroupPermArray.contains("*") + && !playerPermArray.contains("*")) { + if (!returnPermArray.contains(permission)) { + returnPermArray.add(permission); + } + } else + if (!returnPermArray.contains(permission) + && !playerPermArray.contains("-"+permission)) { + returnPermArray.add(permission); + } + } + + for (String permission : playerPermArray) { + /* + * Add each permission + */ + if (!returnPermArray.contains(permission)) { + returnPermArray.add(permission); + } + } + + return returnPermArray; + } /** * Verify if player is in suck group. diff --git a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java index c88f48d6c..b82a8f473 100644 --- a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java +++ b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/BukkitPermissions.java @@ -16,8 +16,10 @@ package org.anjocaido.groupmanager.permissions; +import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Map; import java.util.Set; @@ -115,11 +117,12 @@ public class BukkitPermissions { world = player.getWorld().getName(); } + // All permissions registered with Bukkit for this player PermissionAttachment attachment = this.attachments.get(player); OverloadedWorldHolder worldData = GroupManager.getWorldsHolder().getWorldData(world); - User user = worldData.getUser(player.getName()); + User user = worldData.getUser(player.getName()); // clear permissions for (String permission : attachment.getPermissions().keySet()) { @@ -127,18 +130,32 @@ public class BukkitPermissions { } // find matching permissions + PermissionCheckResult permissionResult; + Boolean value; for (Permission permission : registeredPermissions) { - PermissionCheckResult permissionResult = worldData.getPermissionsHandler().checkFullUserPermission(user, permission.getName()); - Boolean value = false; - if (permissionResult.resultType.equals(PermissionCheckResult.Type.NEGATION)) { - value = false; - } else if (permissionResult.resultType.equals(PermissionCheckResult.Type.FOUND)) + permissionResult = worldData.getPermissionsHandler().checkFullUserPermission(user, permission.getName()); + if (permissionResult.resultType.equals(PermissionCheckResult.Type.FOUND)) value = true; - + else + value = false; attachment.setPermission(permission, value); - } + } + // Add any missing permissions for this player (non bukkit plugins) + List playerPermArray = new ArrayList(worldData.getPermissionsHandler().getAllPlayersPermissions(player.getName())); + + for (String permission : playerPermArray) { + value = true; + if (permission.startsWith("-")) { + permission = permission.substring(1); // cut off - + value = false; + } + + if (!attachment.getPermissions().containsKey(permission)) { + attachment.setPermission(permission, value); + } + } player.recalculatePermissions(); /* diff --git a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/PermissionsReaderInterface.java b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/PermissionsReaderInterface.java old mode 100755 new mode 100644 index ede097ea4..bdad6f186 --- a/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/PermissionsReaderInterface.java +++ b/EssentialsGroupManager/src/org/anjocaido/groupmanager/permissions/PermissionsReaderInterface.java @@ -3,6 +3,8 @@ package org.anjocaido.groupmanager.permissions; //import java.util.Collection; //import java.util.Map; //import java.util.Set; +import java.util.List; + import org.anjocaido.groupmanager.data.Group; //import org.anjocaido.groupmanager.data.User; import org.bukkit.entity.Player; @@ -229,4 +231,6 @@ public abstract class PermissionsReaderInterface { public abstract void removeGroupInfo(String name, String path); ////////////////////////////// + + public abstract List getAllPlayersPermissions(String userName); }