SimplyPerms/net/crystalyx/bukkit/simplyperms/SimplyPlugin.java

300 lines
10 KiB
Java
Executable File

package net.crystalyx.bukkit.simplyperms;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import net.crystalyx.bukkit.simplyperms.io.ConfigFile;
import net.crystalyx.bukkit.simplyperms.io.ConfigSQL;
import net.crystalyx.bukkit.simplyperms.io.PermsConfig;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.plugin.java.JavaPlugin;
public class SimplyPlugin extends JavaPlugin {
protected PermsConfig config;
private SimplyPlayer playerListener = new SimplyPlayer(this);
private SimplyCommands commandExecutor = new SimplyCommands(this);
private HashMap<String, PermissionAttachment> permissions = new HashMap<String, PermissionAttachment>();
private File configFile;
private YamlConfiguration YamlConfig;
// -- Basic stuff
@Override
public void onEnable() {
// Unregister existing PermissionsBukkit nodes
if (getServer().getPluginManager().isPluginEnabled("PermissionsBukkit")) {
for (Permission perm : getServer().getPluginManager().getPlugin("PermissionsBukkit").getDescription().getPermissions()) {
getServer().getPluginManager().removePermission(perm);
}
}
// Disable others permissions plugin
for (String permPlugin : getDescription().getSoftDepend()) {
if (getServer().getPluginManager().isPluginEnabled(permPlugin)) {
getServer().getPluginManager().disablePlugin(getServer().getPluginManager().getPlugin(permPlugin));
}
}
// Take care of configuration
configFile = new File(getDataFolder(), "config.yml");
if (!configFile.exists()) {
saveDefaultConfig();
}
reloadConfig();
// Register stuff
getCommand("permissions").setExecutor(commandExecutor);
getServer().getPluginManager().registerEvents(playerListener, this);
registerEvents();
// Register everyone online right now
for (Player p : getServer().getOnlinePlayers()) {
registerPlayer(p);
}
// How are you gentlemen
getLogger().info("Enabled successfully, " + getServer().getOnlinePlayers().length + " players registered");
}
@Override
public FileConfiguration getConfig() {
return YamlConfig;
}
@Override
public void reloadConfig() {
YamlConfig = new YamlConfiguration();
YamlConfig.options().pathSeparator('/');
try {
YamlConfig.load(configFile);
} catch (Exception e) {
getLogger().severe("Unable to load configuration!");
}
// Init DB
initDatabase();
}
@Override
public void onDisable() {
// Unregister everyone
for (Player p : getServer().getOnlinePlayers()) {
unregisterPlayer(p);
}
// Good day to you! I said good day!
getLogger().info("Disabled successfully, " + getServer().getOnlinePlayers().length + " players unregistered");
}
private void initDatabase() {
if (getConfig().getString("db/type") != null
&& !getConfig().getString("db/type").equals("file")) {
ConfigSQL configsql = new ConfigSQL(this);
if (configsql.checkDatabase()) {
config = configsql;
} else {
debug("Fail to connect to database !");
config = new ConfigFile(this);
}
}
else {
config = new ConfigFile(this);
}
}
public SimplyAPI getAPI() {
return new SimplyAPI(this);
}
// -- Plugin stuff
protected void registerPlayer(Player player) {
if (permissions.containsKey(player.getName())) {
debug("Registering " + player.getName() + ": was already registered");
unregisterPlayer(player);
}
PermissionAttachment attachment = player.addAttachment(this);
permissions.put(player.getName(), attachment);
calculateAttachment(player);
}
protected void unregisterPlayer(Player player) {
if (permissions.containsKey(player.getName())) {
try {
player.removeAttachment(permissions.get(player.getName()));
}
catch (IllegalArgumentException ex) {
debug("Unregistering " + player.getName() + ": player did not have attachment");
}
permissions.remove(player.getName());
} else {
debug("Unregistering " + player.getName() + ": was not registered");
}
}
protected void refreshPermissions() {
try {
getConfig().save(configFile);
reloadConfig();
} catch (IOException e) {
getLogger().warning("Failed to write changed config.yml: " + e.getMessage());
}
for (String player : permissions.keySet()) {
PermissionAttachment attachment = permissions.get(player);
for (String key : attachment.getPermissions().keySet()) {
attachment.unsetPermission(key);
}
calculateAttachment(getServer().getPlayer(player));
}
}
public ConfigurationSection getNode(String node) {
for (String entry : getConfig().getKeys(true)) {
if (node.equalsIgnoreCase(entry) && getConfig().isConfigurationSection(entry)) {
return getConfig().getConfigurationSection(entry);
}
}
return null;
}
protected HashMap<String, Boolean> getAllPerms(String desc, String path) {
HashMap<String, Boolean> result = new HashMap<String, Boolean>();
ConfigurationSection node = getNode(path);
int failures = 0;
String firstFailure = "";
Set<String> keys = node.getKeys(false);
for (String key : keys) {
if (node.isBoolean(key)) {
result.put(key, node.getBoolean(key));
} else {
++failures;
if (firstFailure.length() == 0) {
firstFailure = key;
}
}
}
if (failures == 1) {
getLogger().warning("In " + desc + ": " + firstFailure + " is non-boolean.");
} else if (failures > 1) {
getLogger().warning("In " + desc + ": " + firstFailure + " is non-boolean (+" + (failures-1) + " more).");
}
return result;
}
public void debug(String message) {
if (getConfig().getBoolean("debug", false)) {
getLogger().info("Debug: " + message);
}
}
protected void calculateAttachment(Player player) {
if (player == null) {
return;
}
PermissionAttachment attachment = permissions.get(player.getName());
if (attachment == null) {
debug("Calculating permissions on " + player.getName() + ": attachment was null");
return;
}
for (String key : attachment.getPermissions().keySet()) {
attachment.unsetPermission(key);
}
for (Map.Entry<String, Boolean> entry : calculatePlayerPermissions(player.getName().toLowerCase(), player.getWorld().getName()).entrySet()) {
attachment.setPermission(entry.getKey(), entry.getValue());
}
player.recalculatePermissions();
}
// -- Private stuff
private Map<String, Boolean> calculatePlayerPermissions(String player, String world) {
String default_group = getConfig().getString("default", "default");
if (!config.isPlayerInDB(player)) {
return calculateGroupPermissions(default_group, world);
}
Map<String, Boolean> perms = new HashMap<String, Boolean>();
List<String> groups = config.getPlayerGroups(player);
if (groups.isEmpty()) groups.add(default_group);
for (Entry<String, Boolean> entry : config.getPlayerPermissions(player).entrySet()) {
perms.put(entry.getKey(), entry.getValue());
}
for (Entry<String, Boolean> entry : config.getPlayerPermissions(player, world).entrySet()) {
// No containskey; world overrides non-world
perms.put(entry.getKey(), entry.getValue());
}
for (String group : groups) {
for (Map.Entry<String, Boolean> entry : calculateGroupPermissions(group, world).entrySet()) {
if (!perms.containsKey(entry.getKey())) { // User overrides group
perms.put(entry.getKey(), entry.getValue());
}
}
}
return perms;
}
private Map<String, Boolean> calculateGroupPermissions(String group, String world) {
if (getNode("groups/" + group) == null) {
return new HashMap<String, Boolean>();
}
Map<String, Boolean> perms = getNode("groups/" + group + "/permissions") == null ?
new HashMap<String, Boolean>() :
getAllPerms("group " + group, "groups/" + group + "/permissions");
if (getNode("groups/" + group + "/worlds/" + world) != null) {
for (Map.Entry<String, Boolean> entry : getAllPerms("group " + group, "groups/" + group + "/worlds/" + world).entrySet()) {
// No containskey; world overrides non-world
perms.put(entry.getKey(), entry.getValue());
}
}
for (String parent : getNode("groups/" + group).getStringList("inheritance")) {
for (Map.Entry<String, Boolean> entry : calculateGroupPermissions(parent, world).entrySet()) {
if (!perms.containsKey(entry.getKey())) { // Children override permissions
perms.put(entry.getKey(), entry.getValue());
}
}
}
return perms;
}
private void registerEvents() {
String path = getDescription().getMain().substring(0, getDescription().getMain().lastIndexOf('.'));
for (String prevent : SimplyPrevents.preventions) {
try {
getServer().getPluginManager().registerEvents((SimplyPrevents) Class.forName(path + ".preventions." + prevent).getDeclaredConstructor(SimplyPlugin.class).newInstance(this), this);
} catch (Exception e) {
debug(e.getMessage());
}
}
}
}