Initial commit

2016-05-22 01:57:10 +01:00
commit dc1e06ebce
70 changed files with 4044 additions and 0 deletions
@@ -0,0 +1,71 @@
+package me.lucko.luckperms;
+
+import me.lucko.luckperms.utils.LPConfiguration;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+
+public class BukkitConfig implements LPConfiguration {
+    private final LPBukkitPlugin plugin;
+    private YamlConfiguration configuration;
+
+    public BukkitConfig(LPBukkitPlugin plugin) {
+        this.plugin = plugin;
+        create();
+    }
+
+    private void create() {
+        File configFile = new File(plugin.getDataFolder(), "config.yml");
+
+        if (!configFile.exists()) {
+            configFile.getParentFile().mkdirs();
+            plugin.saveResource("config.yml", false);
+        }
+
+        configuration = new YamlConfiguration();
+
+        try {
+            configuration.load(configFile);
+
+        } catch (InvalidConfigurationException | IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public String getServer() {
+        return configuration.getString("server");
+    }
+
+    @Override
+    public String getPrefix() {
+        return configuration.getString("prefix");
+    }
+
+    @Override
+    public int getSyncTime() {
+        return configuration.getInt("sql.sync-minutes");
+    }
+
+    @Override
+    public String getDefaultGroupNode() {
+        return "luckperms.group." + configuration.getString("default-group");
+    }
+
+    @Override
+    public String getDefaultGroupName() {
+        return configuration.getString("default-group");
+    }
+
+    @Override
+    public boolean getIncludeGlobalPerms() {
+        return configuration.getBoolean("include-global");
+    }
+
+    @Override
+    public String getDatabaseValue(String value) {
+        return configuration.getString("sql." + value);
+    }
+}
@@ -0,0 +1,30 @@
+package me.lucko.luckperms;
+
+import me.lucko.luckperms.commands.CommandManager;
+import me.lucko.luckperms.commands.Sender;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import java.util.Arrays;
+
+class CommandManagerBukkit extends CommandManager implements CommandExecutor {
+    CommandManagerBukkit(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        return onCommand(new Sender() {
+            @Override
+            public void sendMessage(String s) {
+                sender.sendMessage(s);
+            }
+
+            @Override
+            public boolean hasPermission(String node) {
+                return sender.hasPermission(node);
+            }
+        }, Arrays.asList(args));
+    }
+}
@@ -0,0 +1,109 @@
+package me.lucko.luckperms;
+
+import lombok.Getter;
+import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.data.DatastoreConfiguration;
+import me.lucko.luckperms.data.HikariDatastore;
+import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.listeners.PlayerListener;
+import me.lucko.luckperms.runnables.UpdateTask;
+import me.lucko.luckperms.users.BukkitUserManager;
+import me.lucko.luckperms.users.UserManager;
+import me.lucko.luckperms.utils.LPConfiguration;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.Arrays;
+import java.util.UUID;
+
+@Getter
+public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
+    public static final String VERSION = "v1.0";
+
+    private LPConfiguration configuration;
+    private UserManager userManager;
+    private GroupManager groupManager;
+    private Datastore datastore;
+
+    @Override
+    public void onEnable() {
+        configuration = new BukkitConfig(this);
+
+        // register events
+        PluginManager pm = Bukkit.getPluginManager();
+        pm.registerEvents(new PlayerListener(this), this);
+
+        // register commands
+        CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
+        PluginCommand main = getServer().getPluginCommand("luckperms");
+        main.setExecutor(commandManager);
+        main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
+
+        datastore = new HikariDatastore(this);
+        datastore.init(new DatastoreConfiguration(
+                configuration.getDatabaseValue("address"),
+                configuration.getDatabaseValue("database"),
+                configuration.getDatabaseValue("username"),
+                configuration.getDatabaseValue("password")
+        ));
+
+        userManager = new BukkitUserManager(this);
+        groupManager = new GroupManager(this);
+
+        int mins = getConfiguration().getSyncTime();
+        if (mins > 0) {
+            long ticks = mins * 60 * 20;
+            new UpdateTask(this).runTaskTimer(this, ticks, ticks);
+        }
+
+        // Provide vault support
+        try {
+            if (getServer().getPluginManager().isPluginEnabled("Vault")) {
+                getServer().getServicesManager().register(Permission.class, new VaultHook(this), this, ServicePriority.High);
+                getLogger().info("Registered Vault permission hook.");
+            } else {
+                getLogger().info("Vault not found.");
+            }
+        } catch (Exception e) {
+            getLogger().warning("Error whilst hooking into Vault.");
+            e.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public void doAsync(Runnable r) {
+        Bukkit.getScheduler().runTaskAsynchronously(this, r);
+    }
+
+    @Override
+    public void doSync(Runnable r) {
+        Bukkit.getScheduler().runTask(this, r);
+    }
+
+    @Override
+    public String getVersion() {
+        return VERSION;
+    }
+
+    @Override
+    public String getPlayerStatus(UUID uuid) {
+        if (getServer().getPlayer(uuid) != null) return "&aOnline";
+        return "&cOffline";
+    }
+
+    @Override
+    public int getPlayerCount() {
+        return getServer().getOnlinePlayers().size();
+    }
+
+    @Override
+    public void runUpdateTask() {
+        new UpdateTask(this).runTask(this);
+    }
+}
@@ -0,0 +1,150 @@
+package me.lucko.luckperms;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+import net.milkbowl.vault.permission.Permission;
+
+@AllArgsConstructor
+public class VaultHook extends Permission {
+    private final LPBukkitPlugin plugin;
+
+    @Override
+    public String getName() {
+        return "LuckPerms";
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return plugin.getDatastore().isAcceptingLogins();
+    }
+
+    @Override
+    public boolean hasSuperPermsCompat() {
+        // Idk???
+        return true;
+    }
+
+    @Override
+    public boolean playerHas(String world, String player, String permission) {
+        final User user = plugin.getUserManager().getUser(player);
+        return user != null && user.hasPermission(permission, true);
+    }
+
+    @Override
+    public boolean playerAdd(String world, String player, String permission) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        try {
+            user.setPermission(permission, true);
+        } catch (ObjectAlreadyHasException ignored) {}
+        plugin.getUserManager().saveUser(user, plugin.getDatastore());
+        return true;
+    }
+
+    @Override
+    public boolean playerRemove(String world, String player, String permission) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        try {
+            user.unsetPermission(permission);
+        } catch (ObjectLacksPermissionException ignored) {}
+        plugin.getUserManager().saveUser(user, plugin.getDatastore());
+        return true;
+    }
+
+    @Override
+    public boolean groupHas(String world, String groupName, String permission) {
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        return group != null && group.hasPermission(permission, true);
+    }
+
+    @Override
+    public boolean groupAdd(String world, String groupName, String permission) {
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        if (group == null) return false;
+
+        try {
+            group.setPermission(permission, true);
+        } catch (ObjectAlreadyHasException ignored) {}
+        plugin.runUpdateTask();
+        return true;
+    }
+
+    @Override
+    public boolean groupRemove(String world, String groupName, String permission) {
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        if (group == null) return false;
+
+        try {
+            group.unsetPermission(permission);
+        } catch (ObjectLacksPermissionException ignored) {}
+        plugin.runUpdateTask();
+        return true;
+    }
+
+    @Override
+    public boolean playerInGroup(String world, String player, String group) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        return user.getGroupNames().contains(group);
+    }
+
+    @Override
+    public boolean playerAddGroup(String world, String player, String groupName) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        if (group == null) return false;
+
+        try {
+            user.addGroup(group);
+        } catch (ObjectAlreadyHasException ignored) {}
+        plugin.getUserManager().saveUser(user, plugin.getDatastore());
+        return true;
+    }
+
+    @Override
+    public boolean playerRemoveGroup(String world, String player, String groupName) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return false;
+
+        final Group group = plugin.getGroupManager().getGroup(groupName);
+        if (group == null) return false;
+
+        try {
+            user.removeGroup(group);
+        } catch (ObjectLacksPermissionException ignored) {}
+        plugin.getUserManager().saveUser(user, plugin.getDatastore());
+        return true;
+    }
+
+    @Override
+    public String[] getPlayerGroups(String world, String player) {
+        final User user = plugin.getUserManager().getUser(player);
+        if (user == null) return new String[0];
+
+        return user.getGroupNames().toArray(new String[0]);
+    }
+
+    @Override
+    public String getPrimaryGroup(String world, String player) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroupManager().getGroups().keySet().toArray(new String[0]);
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+}
@@ -0,0 +1,75 @@
+package me.lucko.luckperms.listeners;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.users.BukkitUser;
+import me.lucko.luckperms.users.User;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+@AllArgsConstructor
+public class PlayerListener implements Listener {
+    private final LPBukkitPlugin plugin;
+
+    @EventHandler
+    public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
+        if (!plugin.getDatastore().isAcceptingLogins()) {
+            e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, color(plugin.getConfiguration().getPrefix() +
+                    "&cError whilst validating login with the network. \nPlease contact an administrator."));
+            return;
+        }
+        plugin.getDatastore().loadOrCreateUser(e.getUniqueId(), e.getName());
+    }
+
+    @EventHandler
+    public void onPlayerLogin(PlayerLoginEvent e) {
+        Player player = e.getPlayer();
+        User user = plugin.getUserManager().getUser(player.getUniqueId());
+
+        if (user == null) {
+            e.disallow(PlayerLoginEvent.Result.KICK_OTHER, color(plugin.getConfiguration().getPrefix() +
+                    "&cUser data could not be loaded. Please contact an administrator."));
+            return;
+        }
+
+        if (user instanceof BukkitUser) {
+            BukkitUser u = (BukkitUser) user;
+            u.setAttachment(player.addAttachment(plugin));
+        }
+
+        user.refreshPermissions();
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent e) {
+        // Save UUID data for the player
+        plugin.getDatastore().saveUUIDData(e.getPlayer().getName(), e.getPlayer().getUniqueId(), success -> {});
+
+        User user = plugin.getUserManager().getUser(e.getPlayer().getUniqueId());
+        if (user != null) {
+            // Refresh permissions again
+            user.refreshPermissions();
+        }
+
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent e) {
+        Player player = e.getPlayer();
+
+        // Unload the user from memory when they disconnect
+        User user = plugin.getUserManager().getUser(player.getUniqueId());
+        plugin.getUserManager().unloadUser(user);
+    }
+
+    public static String color(String string) {
+        return ChatColor.translateAlternateColorCodes('&', string);
+    }
+
+}
@@ -0,0 +1,25 @@
+package me.lucko.luckperms.runnables;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.LPBukkitPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+@AllArgsConstructor
+public class UpdateTask extends BukkitRunnable {
+    private final LPBukkitPlugin plugin;
+
+    @Override
+    public void run() {
+        plugin.getLogger().info("Running update task.");
+
+        // Re-load all of the groups
+        plugin.getGroupManager().loadAllGroups();
+
+        // Refresh all online users.
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            plugin.getDatastore().loadUser(p.getUniqueId(), success -> {});
+        }
+    }
+}
@@ -0,0 +1,52 @@
+package me.lucko.luckperms.users;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.lucko.luckperms.LPBukkitPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.PermissionAttachment;
+
+import java.util.Map;
+import java.util.UUID;
+
+public class BukkitUser extends User {
+
+    private final LPBukkitPlugin plugin;
+
+    @Getter
+    @Setter
+    private PermissionAttachment attachment = null;
+
+    public BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
+        super(uuid, plugin);
+        this.plugin = plugin;
+    }
+
+    public BukkitUser(UUID uuid, String username, LPBukkitPlugin plugin) {
+        super(uuid, username, plugin);
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void refreshPermissions() {
+        Player player = Bukkit.getPlayer(getUuid());
+        if (player == null) return;
+
+        if (attachment == null) {
+            getPlugin().getLogger().warning("User " + getName() + " does not have a permissions attachment defined.");
+            setAttachment(player.addAttachment(plugin));
+        }
+
+        // Clear existing permissions
+        for (String p : attachment.getPermissions().keySet()) {
+            attachment.setPermission(p, false);
+        }
+
+        // Re-add all defined permissions for the user
+        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
+        for (String node : local.keySet()) {
+            attachment.setPermission(node, local.get(node));
+        }
+    }
+}
@@ -0,0 +1,53 @@
+package me.lucko.luckperms.users;
+
+import me.lucko.luckperms.LPBukkitPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+public class BukkitUserManager extends UserManager {
+    private final LPBukkitPlugin plugin;
+
+    public BukkitUserManager(LPBukkitPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void unloadUser(User user) {
+        if (user != null) {
+
+            if (user instanceof BukkitUser) {
+                BukkitUser u = (BukkitUser) user;
+
+                if (u.getAttachment() != null) {
+                    Player player = Bukkit.getPlayer(u.getUuid());
+
+                    if (player != null) {
+                        player.removeAttachment(u.getAttachment());
+                    }
+                    u.setAttachment(null);
+                }
+            }
+
+            getUsers().remove(user.getUuid());
+        }
+    }
+
+    @Override
+    public void cleanupUser(User user) {
+        if (Bukkit.getPlayer(user.getUuid()) == null) {
+            unloadUser(user);
+        }
+    }
+
+    @Override
+    public User makeUser(UUID uuid) {
+        return new BukkitUser(uuid, plugin);
+    }
+
+    @Override
+    public User makeUser(UUID uuid, String username) {
+        return new BukkitUser(uuid, username, plugin);
+    }
+}
@@ -0,0 +1,19 @@
+# LuckPerms Configuration
+
+# The name of the server, used for server specific permissions. Set to 'global' to disable.
+server: global
+
+# The default group assigned to all user on join. e.g. a value of "default" = luckperms.group.default
+default-group: default
+
+# If users on this server should have their global permissions/groups applied.
+include-global: true
+
+prefix: '&7&l[&b&lL&a&lP&7&l] &c'
+
+sql:
+  address: localhost:3306
+  database: minecraft
+  username: root
+  password: ''
+  sync-minutes: 3
@@ -0,0 +1,10 @@
+name: LuckPerms
+author: Luck
+version: 1.0
+main: me.lucko.luckperms.LPBukkitPlugin
+softdepend: [Vault]
+description: A permissions plugin
+commands:
+  luckperms:
+    description: Manage permissions
+    aliases: [perms, permissions, lp, p, perm]