diff --git a/pom.xml b/pom.xml index 1a908b1..aefd12b 100644 --- a/pom.xml +++ b/pom.xml @@ -84,7 +84,8 @@ org.bukkit bukkit - 1.7.9-R0.2 + 1.7.9-R0.3-SNAPSHOT + jar diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPerms.java b/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPerms.java index 4da97b8..64275e9 100644 --- a/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPerms.java +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPerms.java @@ -17,6 +17,7 @@ import de.hydrox.bukkit.DroxPerms.data.AUser; import de.hydrox.bukkit.DroxPerms.data.Config; import de.hydrox.bukkit.DroxPerms.data.IDataProvider; +import de.hydrox.bukkit.DroxPerms.data.flatfile.FlatFilePermissions; import de.hydrox.bukkit.DroxPerms.data.sql.SQLPermissions; /** @@ -61,12 +62,17 @@ public void onEnable() { saveConfig(); new Config(this); logger.info("[DroxPerms] Loading DataProvider"); - if (Config.getDataProvider().equalsIgnoreCase(SQLPermissions.NODE)) { + if (Config.getDataProvider().equalsIgnoreCase(FlatFilePermissions.NODE)) { + dataProvider = new FlatFilePermissions(this); + } else if (Config.getDataProvider().equalsIgnoreCase(SQLPermissions.NODE)) { try { dataProvider = new SQLPermissions(Config.getMySQLConfig(), this); } catch (SQLException e) { SQLPermissions.mysqlError(e); } + } else { + logger.warning("No DataProvider named \""+Config.getDataProvider()+ "\" available. Falling back to " + FlatFilePermissions.NODE); + dataProvider = new FlatFilePermissions(this); } if (!dataProvider.migrateToNewerVersion()) { diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPermsAPI.java b/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPermsAPI.java index 3962029..4853898 100644 --- a/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPermsAPI.java +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/DroxPermsAPI.java @@ -12,6 +12,7 @@ import org.bukkit.plugin.Plugin; import de.hydrox.bukkit.DroxPerms.data.AUser; +import de.hydrox.bukkit.DroxPerms.utils.uuid.MojangWebAPI; /** * This Class is the API of DroxPerms for external Plug-ins.
@@ -103,6 +104,15 @@ public boolean setPlayerGroup(String player, String group) { plugin.refreshPlayer(plugin.getServer().getPlayer(player)); return result; } + + public boolean setPlayerGroup(UUID uuid, String group) { + playerGroupSet++; + AUser user = plugin.dataProvider.getUserByUUID(uuid); + boolean result = plugin.dataProvider.setPlayerGroup(fakeCS, user, + group); + plugin.refreshPlayer(user); + return result; + } /** * Returns the sub-groups of the Player. @@ -120,6 +130,12 @@ public ArrayList getPlayerSubgroups(String player) { AUser user = plugin.dataProvider.getExactUserByName(player); return (ArrayList) plugin.dataProvider.getPlayerSubgroups(user); } + + public ArrayList getPlayerSubgroups(UUID uuid) { + playerGroupGet++; + AUser user = plugin.dataProvider.getUserByUUID(uuid); + return (ArrayList) plugin.dataProvider.getPlayerSubgroups(user); + } /** * Adds a Subgroup to a Player. @@ -141,6 +157,15 @@ public boolean addPlayerSubgroup(String player, String subgroup) { plugin.refreshPlayer(plugin.getServer().getPlayer(player)); return result; } + + public boolean addPlayerSubgroup(UUID uuid, String subgroup) { + playerGroupSet++; + AUser user = plugin.dataProvider.getUserByUUID(uuid); + boolean result = plugin.dataProvider.addPlayerSubgroup(fakeCS, user, + subgroup); + plugin.refreshPlayer(user); + return result; + } /** * Removes a Subgroup from a Player. @@ -162,6 +187,15 @@ public boolean removePlayerSubgroup(String player, String subgroup) { plugin.refreshPlayer(plugin.getServer().getPlayer(player)); return result; } + + public boolean removePlayerSubgroup(UUID uuid, String subgroup) { + playerGroupSet++; + AUser user = plugin.dataProvider.getUserByUUID(uuid); + boolean result = plugin.dataProvider.removePlayerSubgroup(fakeCS, + user, subgroup); + plugin.refreshPlayer(user); + return result; + } /** * Adds a global Permission to a Player. @@ -493,6 +527,14 @@ public boolean promotePlayer(String player, String track) { plugin.refreshPlayer(plugin.getServer().getPlayer(player)); return result; } + + public boolean promotePlayer(UUID uuid, String track) { + playerGroupSet++; + AUser user = plugin.dataProvider.getUserByUUID(uuid); + boolean result = plugin.dataProvider.promotePlayer(fakeCS, user, track); + plugin.refreshPlayer(user); + return result; + } /** * Demotes a Player along a given Track. @@ -513,6 +555,14 @@ public boolean demotePlayer(String player, String track) { plugin.refreshPlayer(plugin.getServer().getPlayer(player)); return result; } + + public boolean demotePlayer(UUID uuid, String track) { + playerGroupSet++; + AUser user = plugin.dataProvider.getUserByUUID(uuid); + boolean result = plugin.dataProvider.demotePlayer(fakeCS, user, track); + plugin.refreshPlayer(user); + return result; + } /** * Tells the DataProvider to save all changes. @@ -521,6 +571,16 @@ public boolean demotePlayer(String player, String track) { public void save() { plugin.dataProvider.save(); } + + /** + * Returns a UUID when provided with a player name. + * @param name + * @return UUID associated with player name, or null if exception occurs + * @since 1.0.0 + */ + public UUID getUUIDFromName(String name) { + return MojangWebAPI.getUUIDOf(name); + } } class FakeCommandSender implements CommandSender { diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/data/AUser.java b/src/main/java/de/hydrox/bukkit/DroxPerms/data/AUser.java index 18e67d1..0873fa0 100644 --- a/src/main/java/de/hydrox/bukkit/DroxPerms/data/AUser.java +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/data/AUser.java @@ -1,21 +1,23 @@ package de.hydrox.bukkit.DroxPerms.data; +import java.util.HashMap; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.UUID; public abstract class AUser { - //protected static Map users = new HashMap(); - //protected static Map backupUsers = new HashMap(); - //protected static boolean testmode = false; + protected static Map users = new HashMap(); + protected static Map backupUsers = new HashMap(); + protected static boolean testmode = false; - /*public static boolean removeUser(String name) { - if (existUser(name.toLowerCase())) { - users.remove(name.toLowerCase()); + public static boolean removeUser(UUID uuid) { + if (existUser(uuid)) { + users.remove(uuid); return true; } return false; - }*/ + } public abstract boolean addPermission(String world, String permission); public abstract boolean addSubgroup(String subgroup); @@ -32,20 +34,20 @@ public abstract class AUser { public abstract boolean setGroup(String newGroup); public abstract boolean setInfo(String node, String data); - /*public static boolean addUser(AUser user) { - if (existUser(user.getName().toLowerCase())) { + public static boolean addUser(AUser user) { + if (existUser(user.getUUID())) { return false; } - users.put(user.getName().toLowerCase(), user); + users.put(user.getUUID(), user); return true; } - public static AUser getUser(String name) { - return users.get(name.toLowerCase()); + public static AUser getUser(UUID uuid) { + return users.get(uuid); } - public static boolean existUser(String name) { - if (users.containsKey(name.toLowerCase())) { + public static boolean existUser(UUID uuid) { + if (users.containsKey(uuid)) { return true; } return false; @@ -62,7 +64,7 @@ public static Iterator iter() { public static void setTestMode() { if (!testmode) { backupUsers = users; - users = new HashMap(); + users = new HashMap(); testmode = true; } } @@ -72,6 +74,6 @@ public static void setNormalMode() { users = backupUsers; testmode = false; } - }*/ + } } diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/FlatFilePermissions.java b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/FlatFilePermissions.java new file mode 100644 index 0000000..f29a390 --- /dev/null +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/FlatFilePermissions.java @@ -0,0 +1,328 @@ +package de.hydrox.bukkit.DroxPerms.data.flatfile; + +import java.io.File; +import java.io.IOException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Set; +import java.util.logging.Level; +import java.util.UUID; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import org.bukkit.ChatColor; +import org.bukkit.command.CommandSender; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.configuration.file.FileConfiguration; + +import de.hydrox.bukkit.DroxPerms.DroxPerms; +import de.hydrox.bukkit.DroxPerms.data.AGroup; +import de.hydrox.bukkit.DroxPerms.data.APermissions; +import de.hydrox.bukkit.DroxPerms.data.ATrack; +import de.hydrox.bukkit.DroxPerms.data.AUser; +import de.hydrox.bukkit.DroxPerms.utils.uuid.MojangWebAPI; +import java.util.Collection; + +/** + * + * @author Matthias Söhnholz + * + */ +public class FlatFilePermissions extends APermissions{ + + public static final String NODE = "FlatFile"; + + private YamlConfiguration groupsConfig; + private YamlConfiguration usersConfig; + private YamlConfiguration tracksConfig; + + public FlatFilePermissions() { + groupsConfig = YamlConfiguration.loadConfiguration(new File("groups.yml")); + usersConfig = YamlConfiguration.loadConfiguration(new File("users.yml")); + tracksConfig = YamlConfiguration.loadConfiguration(new File("tracks.yml")); + } + + public FlatFilePermissions(DroxPerms plugin) { + FlatFilePermissions.plugin = plugin; + // Write some default configuration + + groupsConfig = YamlConfiguration.loadConfiguration(new File(plugin.getDataFolder(), "groups.yml")); + YamlConfiguration defConfig = YamlConfiguration.loadConfiguration(plugin.getResource("groups.yml")); + groupsConfig.setDefaults(defConfig); + usersConfig = YamlConfiguration.loadConfiguration(new File(plugin.getDataFolder(), "users.yml")); + defConfig = YamlConfiguration.loadConfiguration(plugin.getResource("users.yml")); + usersConfig.setDefaults(defConfig); + tracksConfig = YamlConfiguration.loadConfiguration(new File(plugin.getDataFolder(), "tracks.yml")); + + Set groups = groupsConfig.getConfigurationSection("groups.").getKeys(false); + for (String group : groups) { + plugin.getServer().getLogger().fine("load group: " + group); + ConfigurationSection conf = groupsConfig.getConfigurationSection("groups." + group); + Group newGroup = new Group(group, conf); + Group.addGroup(newGroup); + } + + ConfigurationSection tracksSection = tracksConfig.getConfigurationSection("tracks."); + if (tracksSection != null) { + Set tracks = tracksConfig.getConfigurationSection("tracks.").getKeys(false); + for (String track : tracks) { + plugin.getServer().getLogger().fine("load track: " + track); + ConfigurationSection conf = tracksConfig.getConfigurationSection("tracks." + track); + Track newTrack = new Track(track, conf); + Track.addTrack(newTrack); + } + } + } + + @Override + public void save() { + HashMap tmp = new HashMap(); + Iterator iter = AGroup.iter(); + while (iter.hasNext()) { + Group group = (Group) iter.next(); + tmp.put(group.getName().toLowerCase(), group.toConfigurationNode()); + groupsConfig.createSection("groups." + group.getName(), group.toConfigurationNode()); + } + + try { + groupsConfig.save(new File(plugin.getDataFolder(),"groups.yml")); + } catch (IOException e) { + plugin.getLogger().log(Level.SEVERE, "Could not save config to groups.yml", e); + } + + tmp = new HashMap(); + Iterator iter2 = AUser.iter(); + while (iter2.hasNext()) { + User user = (User) iter2.next(); + if (user.isDirty()) { + usersConfig.createSection("users." + user.getUUID().toString(), user.toConfigurationNode()); + user.clean(); + } + } + + try { + usersConfig.save(new File(plugin.getDataFolder(), "users.yml")); + } catch (IOException e) { + plugin.getLogger().log(Level.SEVERE, "Could not save config to users.yml", e); + } + } + + @Override + public boolean createPlayer(UUID uuid) { + if (User.existUser(uuid)) { + return false; + } else { + User.addUser(new User(uuid)); + return true; + } + } + + @Override + public boolean deletePlayer(CommandSender sender, String name) { + AUser user = getExactUserByName(name); + if (user != null) { + return deletePlayer(sender, user); + } + return false; + } + @Override + public boolean deletePlayer(CommandSender sender, AUser user) { + boolean num = false; + Player player = plugin.getServer().getPlayer(user.getUUID()); + if (player != null) { + sender.sendMessage(ChatColor.RED + "Can't delete online Player."); + return false; + } + + if (user != null) { + num = User.removeUser(user.getUUID()); + } + + if (num) { + sender.sendMessage(ChatColor.GREEN + "Deleted Player " + user.getName() + "."); + return true; + } else { + sender.sendMessage(ChatColor.RED + "No Player with this exact name found."); + return false; + } + } + + @Override + public boolean createGroup(CommandSender sender, String name) { + if (Group.existGroup(name)) { + return false; + } else { + Group.addGroup(new Group(name)); + return true; + } + } + + @Override + public AUser getUserByUUID(UUID uuid) { + AUser user = null; + if (User.existUser(uuid)) { + user = User.getUser(uuid); + return user; + } else { + ConfigurationSection node = null; + node = usersConfig.getConfigurationSection("users." + uuid.toString()); + if (node != null) { + user = new User(uuid, node); + User.addUser(user); + return user; + } + } + return null; + } + + @Override + public AUser getExactUserByName(String name) { + AUser user = null; + + ConfigurationSection node = null; + String currentUUID = null; + ConfigurationSection usersNode = usersConfig.getConfigurationSection("users"); + Iterator userIter = usersNode.getValues(false).keySet().iterator(); + + while (userIter.hasNext()) { + currentUUID = userIter.next(); + ConfigurationSection currentNode = usersConfig.getConfigurationSection("users." + currentUUID); + String lastName = currentNode.getString("info." + "lastName"); + if (name.equals(lastName)) { + node = currentNode; + break; + } + } + + if (User.existUser(UUID.fromString(currentUUID))) { + user = User.getUser(UUID.fromString(currentUUID)); + return user; + } else { + if (node != null) { + user = new User(UUID.fromString(currentUUID), node); + User.addUser(user); + return user; + } + } + return null; + } + + @Override + public AUser getPartialUserByName(String name) { + Collection players = plugin.getServer().getOnlinePlayers(); + Iterator playerIter = players.iterator(); + AUser user = null; + while (playerIter.hasNext()) { + String newName = playerIter.next().getName(); + if (newName.contains(name)) { + name = newName; + break; + } + } + ConfigurationSection node = null; + String currentUUID = null; + ConfigurationSection usersNode = usersConfig.getConfigurationSection("users"); + Iterator userIter = usersNode.getValues(false).keySet().iterator(); + + while (userIter.hasNext()) { + currentUUID = userIter.next(); + ConfigurationSection currentNode = usersConfig.getConfigurationSection("users." + currentUUID); + String lastName = currentNode.getString("info." + "lastName"); + if (name.equals(lastName)) { + node = currentNode; + break; + } + } + + if (User.existUser(UUID.fromString(currentUUID))) { + user = User.getUser(UUID.fromString(currentUUID)); + return user; + } else { + if (node != null) { + user = new User(UUID.fromString(currentUUID), node); + User.addUser(user); + return user; + } + } + return null; + } + + @Override + public Set getAllUserNames() { + return usersConfig.getConfigurationSection("users.").getKeys(false); + } + + @Override + public ATrack getTrack(String track) { + return Track.getTrack(track); + } + + @Override + public boolean migrateToNewerVersion() { + FileConfiguration configuration = plugin.getConfig(); + String dbVersion = configuration.getString("DatabaseVersion", "0.5.1-flatfile"); + + if ("0.5.1-flatfile".equals(dbVersion)) { + plugin.getLogger().info("detected Storage version 0.5.1, update to 1.0.0"); + + Set userSet = usersConfig.getConfigurationSection("users.").getKeys(false); + List users = new ArrayList(); + users.addAll(userSet); + + Map response = null; + try { + response = MojangWebAPI.lookupUUIDS(users); + } catch(Exception ex) { + plugin.getLogger().warning("Could not retreve UUIDS! Abandoning migration."); + return false; + } + + if (response == null) { + plugin.getLogger().warning("No users found. Abandoning migration."); + return false; + } else { + Iterator iterator = userSet.iterator(); + while (iterator.hasNext()) { + String player = iterator.next(); + if (response.containsKey(player)) { + String newKey = response.get(player).toString(); + for (String s : usersConfig.getConfigurationSection("users." + player).getKeys(false)) { + //info migration + if (usersConfig.getConfigurationSection("users." + player + ".").isConfigurationSection(s)) { + for (String st : usersConfig.getConfigurationSection("users." + player + "." + s).getKeys(false)) { + usersConfig.set("users." + newKey + "." + s + "." + st, usersConfig.get("users." + player + "." + s + "." + st)); + } + } else { + //data migration + usersConfig.set("users." + newKey + "." + s, usersConfig.get("users." + player + "." + s)); + } + } + usersConfig.set("users." + player, null); + usersConfig.set("users." + newKey + "." + "info." + "lastName", player); + } + } + try { + usersConfig.save(new File(plugin.getDataFolder(), "users.yml")); + } catch (IOException ex) { + plugin.getLogger().log(Level.SEVERE, "Could not save config to " + new File(plugin.getDataFolder(), "users.yml"), ex); + } + } + + dbVersion = "1.0.0-flatfile"; + plugin.getLogger().info("updated Storage to 1.0.0-flatfile"); + configuration.set("DatabaseVersion", dbVersion); + try { + configuration.save(new File(plugin.getDataFolder() + File.separator + "config.yml")); + } catch (IOException e) { + e.printStackTrace(); + return false; + } + } + + plugin.getLogger().info("Storage Migration complete"); + return true; + } +} diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/Group.java b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/Group.java new file mode 100644 index 0000000..f313dfa --- /dev/null +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/Group.java @@ -0,0 +1,334 @@ +package de.hydrox.bukkit.DroxPerms.data.flatfile; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.bukkit.Bukkit; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.permissions.Permission; +import org.bukkit.permissions.PermissionDefault; + +import de.hydrox.bukkit.DroxPerms.data.AGroup; +import de.hydrox.bukkit.DroxPerms.data.Config; + +public class Group extends AGroup{ + private Map> permissions; + private Map info; + private Map globalPermissions; + private List subgroups; + + private Map bukkitPermissions; + + public Group() { + this("default"); + } + + public Group(String name) { + this.name = name; + this.subgroups = new ArrayList(); + this.globalPermissions = new LinkedHashMap(); + this.permissions = new LinkedHashMap>(); + } + + public Group(String name, ConfigurationSection node) { + this.name = name; + this.subgroups = node.getStringList("subgroups"); + this.globalPermissions = fileFormatToInternal(node.getStringList("globalpermissions")); + if (this.globalPermissions == null) { + this.globalPermissions = new LinkedHashMap(); + } + this.permissions = new LinkedHashMap>(); + if (node.contains("permissions")) { + Set worlds = node.getConfigurationSection("permissions.").getKeys(false); + for (String world : worlds) { + permissions.put(world, fileFormatToInternal(node.getStringList("permissions." + world))); + } + } + if(node.contains("info")) { + this.info = new HashMap(); + Set infoNodes = node.getConfigurationSection("info.").getKeys(false); + for (String infoNode : infoNodes) { + info.put(infoNode, node.getString("info." + infoNode)); + } + } + + updatePermissions(); + } + + private Map fileFormatToInternal(List list){ + if (list == null) { + return null; + } + Map result = new LinkedHashMap(); + for (String string : list) { + boolean value = true; + if (string.startsWith("-")) { + string = string.substring(1); + value = false; + } + result.put(string, value); + } + return result; + } + + private List internalFormatToFile(Map map){ + if (map == null) { + return null; + } + List result = new ArrayList(); + for (String string : map.keySet()) { + if(!map.get(string)){ + string = "-"+string; + } + result.add(string); + } + return result; + } + + public Map toConfigurationNode() { + Map output = new HashMap(); + if (subgroups != null && subgroups.size() != 0) { + output.put("subgroups", subgroups); + } + if (permissions != null && permissions.size() != 0) { + Map> tmp = new LinkedHashMap>(); + for (String world : permissions.keySet()) { + tmp.put(world, internalFormatToFile(permissions.get(world))); + } + output.put("permissions", tmp); + } + if (info != null && info.size() != 0) { + output.put("info", info); + } + if (globalPermissions != null && globalPermissions.size() != 0) { + output.put("globalpermissions", internalFormatToFile(globalPermissions)); + } + return output; + } + + public Map> getPermissions(String world) { + Map> result = new LinkedHashMap>(); + Map groupperms = new LinkedHashMap(); + //add group permissions + groupperms.put("droxperms.meta.group." + name, true); + if (world != null) { + groupperms.put("droxperms.meta.group." + name + "." + Config.getRealWorld(world), true); + } + result.put("group", groupperms); + //add subgroup permissions + if (subgroups != null) { + Map subgroupperms = new LinkedHashMap(); + for (Iterator iterator = subgroups.iterator(); iterator.hasNext();) { + String subgroup = iterator.next(); + subgroupperms.put("droxperms.meta.group." + subgroup, true); + if (world != null) { + subgroupperms.put("droxperms.meta.group." + subgroup + "." + Config.getRealWorld(world), true); + } + } + result.put("subgroups", subgroupperms); + } + //add global permissions + if (globalPermissions != null) { + result.put("global", globalPermissions); + } + //add world permissions + if (world != null && permissions != null) { + Map worldperms = new LinkedHashMap(); + if (permissions.get(Config.getRealWorld(world)) != null) { + worldperms.putAll(permissions.get(Config.getRealWorld(world))); + } + result.put("world", worldperms); + } + return result; + } + + public boolean addPermission(String world, String permission) { + boolean value = true; + if (permission.startsWith("-")) { + permission = permission.substring(1); + value = false; + } + if (world == null) { + if (globalPermissions == null) { + globalPermissions = new LinkedHashMap(); + } + if (globalPermissions.containsKey(permission)) { + return false; + } + globalPermissions.put(permission, value); + updatePermissions(); + return true; + } + + Map permArray = permissions.get(Config.getRealWorld(world).toLowerCase()); + if (permArray == null) { + permArray = new LinkedHashMap(); + permissions.put(Config.getRealWorld(world).toLowerCase(), permArray); + } + if (permArray.containsKey(permission)) { + return false; + } + permArray.put(permission, value); + updatePermissions(); + return true; + } + + public boolean removePermission(String world, String permission) { + if (world == null) { + if (globalPermissions.containsKey(permission)) { + globalPermissions.remove(permission); + updatePermissions(); + return true; + } + return false; + } + + Map permArray = permissions.get(Config.getRealWorld(world).toLowerCase()); + if (permArray == null) { + permArray = new LinkedHashMap(); + permissions.put(Config.getRealWorld(world).toLowerCase(), permArray); + } + if (permArray.containsKey(permission)) { + permArray.remove(permission); + updatePermissions(); + return true; + } + return false; + } + + public boolean addSubgroup(String subgroup) { + if(Group.existGroup(subgroup.toLowerCase())) { + if (subgroups == null) { + subgroups = new ArrayList(); + } + if(!subgroups.contains(subgroup.toLowerCase())) { + subgroups.add(subgroup.toLowerCase()); + updatePermissions(); + return true; + } + } + return false; + } + + public boolean removeSubgroup(String subgroup) { + if(subgroups != null && subgroups.contains(subgroup.toLowerCase())) { + subgroups.remove(subgroup.toLowerCase()); + updatePermissions(); + return true; + } + return false; + } + + public boolean hasPermission(String world, String permission) { + Map permArray = permissions.get(world.toLowerCase()); + if (permArray != null && permArray.containsKey(permission)) { + return permArray.get(permission); + } + + for (String subgroup : subgroups) { + if (Group.getGroup(subgroup) != null && + Group.getGroup(subgroup).hasPermission(world.toLowerCase(), permission)) { + return true; + } + } + return false; + } + + public boolean setInfo(String node, String data) { + if (info == null) { + info = new HashMap(); + } + if(data == null) { + info.remove(node); + return true; + } + info.put(node, data); + return true; + } + + public String getInfo(String node) { + if (info == null) { + return null; + } + return info.get(node); + } + + public Map getInfoComplete() { + if (info == null) { + return null; + } + return new HashMap(info); + } + + public boolean addWorld(String world) { + if (permissions.containsKey(world.toLowerCase())) { + return false; + } + permissions.put(world.toLowerCase(), new LinkedHashMap()); + updatePermissions(); + return true; + } + + public List getSubgroups() { + if (subgroups == null) { + subgroups = new ArrayList(); + } + return subgroups; + } + + private void updatePermissions() { + bukkitPermissions = new LinkedHashMap(); + //create Permission for default world + if (subgroups == null) { + subgroups = new ArrayList(); + } + if (!permissions.containsKey(Config.getDefaultWorld())) { + Map children = new LinkedHashMap(); + for (String subgroup : subgroups) { + children.put("droxperms.meta.group." + subgroup + "." + Config.getDefaultWorld(), true); + } + children.put("droxperms.meta.group." + name, true); + + Permission permission = new Permission("droxperms.meta.group." + name + "." + Config.getDefaultWorld(), "Group-Permissions for group " + name + " on world " + Config.getDefaultWorld(), PermissionDefault.FALSE, children); + Bukkit.getPluginManager().removePermission(permission); + Bukkit.getPluginManager().addPermission(permission); + bukkitPermissions.put(Config.getDefaultWorld(), permission); + } + + //create Permissions for other worlds + for (String world : Config.getWorlds()) { + Map children = new LinkedHashMap(); + for (String subgroup : subgroups) { + children.put("droxperms.meta.group." + subgroup + "." + world, true); + } + + children.put("droxperms.meta.group." + name, true); + + if(permissions.get(world) != null) { + children.putAll(permissions.get(world)); + } + + Permission permission = new Permission("droxperms.meta.group." + name + "." + world, "Group-Permissions for group " + name + " on world " + world, PermissionDefault.FALSE, children); + Bukkit.getPluginManager().removePermission(permission); + Bukkit.getPluginManager().addPermission(permission); + bukkitPermissions.put(world, permission); + } + + Map children = new LinkedHashMap(); + for (String subgroup : subgroups) { + children.put("droxperms.meta.group." + subgroup, true); + } + + children.putAll(globalPermissions); + + //create Permission for global grouppermissions + Permission permission = new Permission("droxperms.meta.group." + name, "Group-Permissions for group " + name, PermissionDefault.FALSE, children); + Bukkit.getPluginManager().removePermission(permission); + Bukkit.getPluginManager().addPermission(permission); + } +} diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/Track.java b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/Track.java new file mode 100644 index 0000000..5f1cf66 --- /dev/null +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/Track.java @@ -0,0 +1,77 @@ +package de.hydrox.bukkit.DroxPerms.data.flatfile; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +import org.bukkit.configuration.ConfigurationSection; + +import de.hydrox.bukkit.DroxPerms.data.ATrack; + +public class Track extends ATrack{ + private static Map tracks = new HashMap(); + + private String name; + private Map mapping; + + public Track(String name, ConfigurationSection node) { + this.mapping = new HashMap(); + this.name = name; + + Set groups = node.getKeys(false); + for (String group : groups) { + mapping.put(group, node.getString(group)); + } + } + + public String getPromoteGroup(String before) { + return mapping.get(before.toLowerCase()); + } + + public String getDemoteGroup(String before) { + Set keys = mapping.keySet(); + for (String key : keys) { + if (mapping.get(key).equalsIgnoreCase(before)) { + return key; + } + } + return null; + } + + public static boolean addTrack(Track track) { + if (existTrack(track.name.toLowerCase())) { + return false; + } + tracks.put(track.name.toLowerCase(), track); + return true; + } + + public static boolean removeTrack(String name) { + if (existTrack(name.toLowerCase())) { + tracks.remove(name.toLowerCase()); + return true; + } + return false; + } + + public static Track getTrack(String name) { + return tracks.get(name.toLowerCase()); + } + + public static boolean existTrack(String name) { + if (tracks.containsKey(name.toLowerCase())) { + return true; + } + return false; + } + + public static void clearTracks() { + tracks.clear(); + } + + public static Iterator iter() { + return tracks.values().iterator(); + } + +} diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/User.java b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/User.java new file mode 100644 index 0000000..aef0558 --- /dev/null +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/data/flatfile/User.java @@ -0,0 +1,330 @@ +package de.hydrox.bukkit.DroxPerms.data.flatfile; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.bukkit.configuration.ConfigurationSection; + +import de.hydrox.bukkit.DroxPerms.data.AGroup; +import de.hydrox.bukkit.DroxPerms.data.AUser; +import de.hydrox.bukkit.DroxPerms.data.Config; +import de.hydrox.bukkit.DroxPerms.utils.uuid.NameFetcher; +import java.util.UUID; + +public class User extends AUser{ + + private String name; + private String group; + private UUID uuid; + private List subgroups; + private Map globalPermissions; + private Map> permissions; + private Map info; + private boolean dirty; + + public User(UUID uuid) { + this.group = "default"; + this.subgroups = new ArrayList(); + this.globalPermissions = new LinkedHashMap(); + this.permissions = new LinkedHashMap>(); + this.dirty = true; + this.uuid = uuid; + try { + name = NameFetcher.getNameOf(uuid); + } catch (Exception e) { + this.name = null; + e.printStackTrace(); + } + } + + public User(UUID uuid, ConfigurationSection node) { + this.group = node.getString("group", "default"); + this.subgroups = node.getStringList("subgroups"); + this.globalPermissions = fileFormatToInternal(node.getStringList("globalpermissions")); + if (this.globalPermissions == null) { + this.globalPermissions = new LinkedHashMap(); + } + this.permissions = new LinkedHashMap>(); + if(node.contains("permissions")) { + Set worlds = node.getConfigurationSection("permissions.").getKeys(false); + for (String world : worlds) { + permissions.put(world, fileFormatToInternal(node.getStringList("permissions." + world))); + } + } + if(node.contains("info")) { + this.info = new HashMap(); + Set infoNodes = node.getConfigurationSection("info.").getKeys(false); + for (String infoNode : infoNodes) { + info.put(infoNode, node.getString("info." + infoNode)); + } + } + + this.dirty = false; + this.uuid = uuid; + try { + name = NameFetcher.getNameOf(uuid); + } catch (Exception e) { + this.name = null; + e.printStackTrace(); + } + + } + + private Map fileFormatToInternal(List list){ + if (list == null) { + return null; + } + Map result = new LinkedHashMap(); + for (String string : list) { + boolean value = true; + if (string.startsWith("-")) { + string = string.substring(1); + value = false; + } + result.put(string, value); + } + return result; + } + + private List internalFormatToFile(Map map){ + if (map == null) { + return null; + } + List result = new ArrayList(); + for (String string : map.keySet()) { + if(!map.get(string)){ + string = "-"+string; + } + result.add(string); + } + return result; + } + + @Override + public String getName() { + return name; + } + + @Override + public String getGroup() { + return group; + } + + public Map toConfigurationNode() { + Map output = new LinkedHashMap(); + output.put("group", group); + if (subgroups != null && subgroups.size() != 0) { + output.put("subgroups", subgroups); + } + if (permissions != null && permissions.size() != 0) { + Map> tmp = new LinkedHashMap>(); + for (String world : permissions.keySet()) { + tmp.put(world, internalFormatToFile(permissions.get(world))); + } + output.put("permissions", tmp); + } + if (info != null && info.size() != 0) { + output.put("info", info); + } + if (globalPermissions != null && globalPermissions.size() != 0) { + output.put("globalpermissions", internalFormatToFile(globalPermissions)); + } + + return output; + } + + public boolean isDirty() { + return dirty; + } + + public void clean() { + dirty = false; + } + + public void dirty() { + dirty = true; + } + + @Override + public Map> getPermissions(String world) { + Map> result = new HashMap>(); + Map groupperms = new LinkedHashMap(); + //add group permissions + groupperms.put("droxperms.meta.group." + group, true); + if (world != null) { + groupperms.put("droxperms.meta.group." + group + "." + Config.getRealWorld(world), true); + } + result.put("group", groupperms); + //add subgroup permissions + if (subgroups != null) { + Map subgroupperms = new LinkedHashMap(); + for (Iterator iterator = subgroups.iterator(); iterator.hasNext();) { + String subgroup = iterator.next(); + subgroupperms.put("droxperms.meta.group." + subgroup, true); + if (world != null) { + subgroupperms.put("droxperms.meta.group." + subgroup + "." + Config.getRealWorld(world), true); + } + } + result.put("subgroups", subgroupperms); + } + //add global permissions + if (globalPermissions != null) { + result.put("global", globalPermissions); + } + //add world permissions + if (world != null && permissions != null) { + Map worldperms = new LinkedHashMap(); + if (permissions.get(Config.getRealWorld(world)) != null) { + worldperms.putAll(permissions.get(Config.getRealWorld(world))); + } + result.put("world", worldperms); + } + return result; + } + + @Override + public boolean setGroup(String newGroup) { + if (Group.existGroup(newGroup)) { + group = newGroup.toLowerCase(); + dirty = true; + return true; + } + return false; + } + + @Override + public boolean addPermission(String world, String permission) { + boolean value = true; + if (permission.startsWith("-")) { + permission = permission.substring(1); + value = false; + } + if (world == null) { + if (globalPermissions == null) { + globalPermissions = new LinkedHashMap(); + } + if (globalPermissions.containsKey(permission)) { + return false; + } + globalPermissions.put(permission, value); + dirty = true; + return true; + } + + if (permissions == null) { + permissions = new HashMap>(); + } + Map permArray = permissions.get(Config.getRealWorld(world).toLowerCase()); + if (permArray == null) { + permArray = new LinkedHashMap(); + permissions.put(Config.getRealWorld(world).toLowerCase(), permArray); + } + if (permArray.containsKey(permission)) { + return false; + } + permArray.put(permission, value); + dirty = true; + return true; + } + + @Override + public boolean removePermission(String world, String permission) { + if (world == null) { + if (globalPermissions != null && globalPermissions.containsKey(permission)) { + globalPermissions.remove(permission); + dirty = true; + return true; + } + return false; + } + + if (permissions == null) { + return false; + } + Map permArray = permissions.get(Config.getRealWorld(world).toLowerCase()); + if (permArray == null) { + permArray = new LinkedHashMap(); + permissions.put(Config.getRealWorld(world).toLowerCase(), permArray); + } + if (permArray.containsKey(permission)) { + permArray.remove(permission); + dirty = true; + return true; + } + return false; + } + + @Override + public boolean addSubgroup(String subgroup) { + if(AGroup.existGroup(subgroup.toLowerCase())) { + if (subgroups == null) { + subgroups = new ArrayList(); + } + if (!subgroups.contains(subgroup.toLowerCase())) { + subgroups.add(subgroup.toLowerCase()); + dirty = true; + return true; + } + } + return false; + } + + @Override + public boolean removeSubgroup(String subgroup) { + if(subgroups != null && subgroups.contains(subgroup.toLowerCase())) { + subgroups.remove(subgroup.toLowerCase()); + dirty = true; + return true; + } + return false; + } + + @Override + public boolean setInfo(String node, String data) { + if (info == null) { + info = new HashMap(); + } + if(data == null) { + info.remove(node); + dirty(); + return true; + } + info.put(node, data); + dirty(); + return true; + } + + @Override + public String getInfo(String node) { + if (info == null) { + return null; + } + return info.get(node); + } + + @Override + public Map getInfoComplete() { + if (info == null) { + return null; + } + return new HashMap(info); + } + + @Override + public List getSubgroups() { + if (subgroups == null) { + subgroups = new ArrayList(); + } + return subgroups; + } + + @Override + public UUID getUUID() { + return this.uuid; + } +} diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/MojangWebAPI.java b/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/MojangWebAPI.java index 746b677..85d6fa3 100644 --- a/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/MojangWebAPI.java +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/MojangWebAPI.java @@ -5,6 +5,7 @@ import java.io.OutputStream; import java.net.HttpURLConnection; import java.net.URL; +import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -31,6 +32,7 @@ public class MojangWebAPI { public static final String NAME_DATA_LOOKUP_ENDPOINT = "https://sessionserver.mojang.com/session/minecraft/profile/"; public static final String HAS_PAID_ENDPOINT = "https://minecraft.net/haspaid.jsp?user="; public static final String UUID_NAME_LOOKUP_ENDPOINT_ALT = "https://uuid.swordpvp.com/uuid/"; + private static Map storedUUIDS = new HashMap(); public static final int MAX_QUERIES_PER_REQUEST = 100; /** @@ -145,4 +147,22 @@ public static void main(String[] args) throws Exception{ } } + public static UUID getUUIDOf(String name) { + UUID uuid; + + if (storedUUIDS.containsKey(name)) { + return storedUUIDS.get(name); + } + + try { + uuid = MojangWebAPI.lookupUUIDS(Arrays.asList(name)).get(name); + } catch (Exception e) { + uuid = null; + e.printStackTrace(); + return uuid; + } + storedUUIDS.put(name, uuid); + return uuid; + } + } diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/NameFetcher.java b/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/NameFetcher.java new file mode 100644 index 0000000..c440797 --- /dev/null +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/NameFetcher.java @@ -0,0 +1,48 @@ +package de.hydrox.bukkit.DroxPerms.utils.uuid; + +import com.google.common.collect.ImmutableList; +import org.json.simple.JSONObject; +import org.json.simple.parser.JSONParser; + +import java.io.InputStreamReader; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.Callable; + +public class NameFetcher implements Callable> { + private static final String PROFILE_URL = "https://sessionserver.mojang.com/session/minecraft/profile/"; + private final JSONParser jsonParser = new JSONParser(); + private final List uuids; + public NameFetcher(List uuids) { + this.uuids = ImmutableList.copyOf(uuids); + } + + @Override + public Map call() throws Exception { + Map uuidStringMap = new HashMap(); + for (UUID uuid: uuids) { + HttpURLConnection connection = (HttpURLConnection) new URL(PROFILE_URL+uuid.toString().replace("-", "")).openConnection(); + JSONObject response = (JSONObject) jsonParser.parse(new InputStreamReader(connection.getInputStream())); + String name = (String) response.get("name"); + if (name == null) { + continue; + } + String cause = (String) response.get("cause"); + String errorMessage = (String) response.get("errorMessage"); + if (cause != null && cause.length() > 0) { + throw new IllegalStateException(errorMessage); + } + uuidStringMap.put(uuid, name); + } + return uuidStringMap; + } + + public static String getNameOf(UUID uuid) throws Exception { + return new NameFetcher(Arrays.asList(uuid)).call().get(uuid); + } +} \ No newline at end of file diff --git a/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/UUIDFetcher.java b/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/UUIDFetcher.java new file mode 100644 index 0000000..c31060f --- /dev/null +++ b/src/main/java/de/hydrox/bukkit/DroxPerms/utils/uuid/UUIDFetcher.java @@ -0,0 +1,96 @@ +package de.hydrox.bukkit.DroxPerms.utils.uuid; + +import com.google.common.collect.ImmutableList; +import org.json.simple.JSONArray; +import org.json.simple.JSONObject; +import org.json.simple.parser.JSONParser; + +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.net.HttpURLConnection; +import java.net.URL; +import java.nio.ByteBuffer; +import java.util.*; +import java.util.concurrent.Callable; + +public class UUIDFetcher implements Callable> { + private static final double PROFILES_PER_REQUEST = 100; + private static final String PROFILE_URL = "https://api.mojang.com/profiles/minecraft"; + private final JSONParser jsonParser = new JSONParser(); + private final List names; + private final boolean rateLimiting; + + public UUIDFetcher(List names, boolean rateLimiting) { + this.names = ImmutableList.copyOf(names); + this.rateLimiting = rateLimiting; + } + + public UUIDFetcher(List names) { + this(names, true); + } + + public Map call() throws Exception { + Map uuidMap = new HashMap(); + int requests = (int) Math.ceil(names.size() / PROFILES_PER_REQUEST); + for (int i = 0; i < requests; i++) { + HttpURLConnection connection = createConnection(); + String body = JSONArray.toJSONString(names.subList(i * 100, Math.min((i + 1) * 100, names.size()))); + writeBody(connection, body); + JSONArray array = (JSONArray) jsonParser.parse(new InputStreamReader(connection.getInputStream())); + for (Object profile : array) { + JSONObject jsonProfile = (JSONObject) profile; + String id = (String) jsonProfile.get("id"); + String name = (String) jsonProfile.get("name"); + UUID uuid = UUIDFetcher.getUUID(id); + uuidMap.put(name, uuid); + } + if (rateLimiting && i != requests - 1) { + Thread.sleep(100L); + } + } + return uuidMap; + } + + private static void writeBody(HttpURLConnection connection, String body) throws Exception { + OutputStream stream = connection.getOutputStream(); + stream.write(body.getBytes()); + stream.flush(); + stream.close(); + } + + private static HttpURLConnection createConnection() throws Exception { + URL url = new URL(PROFILE_URL); + HttpURLConnection connection = (HttpURLConnection) url.openConnection(); + connection.setRequestMethod("POST"); + connection.setRequestProperty("Content-Type", "application/json"); + connection.setUseCaches(false); + connection.setDoInput(true); + connection.setDoOutput(true); + return connection; + } + + private static UUID getUUID(String id) { + return UUID.fromString(id.substring(0, 8) + "-" + id.substring(8, 12) + "-" + id.substring(12, 16) + "-" + id.substring(16, 20) + "-" +id.substring(20, 32)); + } + + public static byte[] toBytes(UUID uuid) { + ByteBuffer byteBuffer = ByteBuffer.wrap(new byte[16]); + byteBuffer.putLong(uuid.getMostSignificantBits()); + byteBuffer.putLong(uuid.getLeastSignificantBits()); + return byteBuffer.array(); + } + + public static UUID fromBytes(byte[] array) { + if (array.length != 16) { + throw new IllegalArgumentException("Illegal byte array length: " + array.length); + } + ByteBuffer byteBuffer = ByteBuffer.wrap(array); + long mostSignificant = byteBuffer.getLong(); + long leastSignificant = byteBuffer.getLong(); + return new UUID(mostSignificant, leastSignificant); + } + + public static UUID getUUIDOf(String name) throws Exception { + return new UUIDFetcher(Arrays.asList(name)).call().get(name); + } +} \ No newline at end of file