Initial commit

2016-05-22 01:57:10 +01:00
commit dc1e06ebce
70 changed files with 4044 additions and 0 deletions
@@ -0,0 +1,113 @@
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.group.CreateGroupCommand;
+import me.lucko.luckperms.commands.group.DeleteGroupCommand;
+import me.lucko.luckperms.commands.group.GroupMainCommand;
+import me.lucko.luckperms.commands.group.ListGroupsCommand;
+import me.lucko.luckperms.commands.group.subcommands.*;
+import me.lucko.luckperms.commands.misc.DebugCommand;
+import me.lucko.luckperms.commands.misc.InfoCommand;
+import me.lucko.luckperms.commands.misc.SyncCommand;
+import me.lucko.luckperms.commands.user.UserMainCommand;
+import me.lucko.luckperms.commands.user.subcommands.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+
+public class CommandManager {
+    private final LuckPermsPlugin plugin;
+
+    @Getter
+    private final List<MainCommand> mainCommands = new ArrayList<>();
+
+    public CommandManager(LuckPermsPlugin plugin) {
+        this.plugin = plugin;
+
+        UserMainCommand userCommand = new UserMainCommand();
+        this.registerMainCommand(userCommand);
+        userCommand.registerSubCommand(new UserAddGroupCommand());
+        userCommand.registerSubCommand(new UserClearCommand());
+        userCommand.registerSubCommand(new UserGetUUIDCommand());
+        userCommand.registerSubCommand(new UserHasPermCommand());
+        userCommand.registerSubCommand(new UserInfoCommand());
+        userCommand.registerSubCommand(new UserListNodesCommand());
+        userCommand.registerSubCommand(new UserRemoveGroupCommand());
+        userCommand.registerSubCommand(new UserSetPermissionCommand());
+        userCommand.registerSubCommand(new UserUnSetPermissionCommand());
+
+        GroupMainCommand groupCommand = new GroupMainCommand();
+        this.registerMainCommand(groupCommand);
+        groupCommand.registerSubCommand(new GroupClearCommand());
+        groupCommand.registerSubCommand(new GroupHasPermCommand());
+        groupCommand.registerSubCommand(new GroupInfoCommand());
+        groupCommand.registerSubCommand(new GroupListNodesCommand());
+        groupCommand.registerSubCommand(new GroupSetInheritCommand());
+        groupCommand.registerSubCommand(new GroupSetPermissionCommand());
+        groupCommand.registerSubCommand(new GroupUnsetInheritCommand());
+        groupCommand.registerSubCommand(new GroupUnSetPermissionCommand());
+
+        this.registerMainCommand(new CreateGroupCommand());
+        this.registerMainCommand(new DeleteGroupCommand());
+        this.registerMainCommand(new ListGroupsCommand());
+        this.registerMainCommand(new DebugCommand());
+        this.registerMainCommand(new InfoCommand());
+        this.registerMainCommand(new SyncCommand());
+    }
+
+    /**
+     * Generic on command method to be called from the command executor object of the platform
+     * @param sender who sent the command
+     * @param args the arguments provided
+     * @return if the command was successful (hint: it always is :> )
+     */
+    public boolean onCommand(Sender sender, List<String> args) {
+        if (args.size() == 0) {
+            Util.sendPluginMessage(sender, "&6Running &bLuckPerms " + plugin.getVersion() + "&6.");
+
+            if (sender.hasPermission("luckperms.info")) {
+                for (MainCommand c : mainCommands) {
+                    Util.sendPluginMessage(sender, "&e-> &d" + c.getUsage());
+                }
+            }
+
+        } else {
+            String c = args.get(0);
+            MainCommand main = null;
+
+            for (MainCommand mainCommand : mainCommands) {
+                if (mainCommand.getName().equalsIgnoreCase(c)) {
+                    main = mainCommand;
+                    break;
+                }
+            }
+
+            if (main == null) {
+                Util.sendPluginMessage(sender, "Command not recognised.");
+                return true;
+            }
+
+            if (main.getRequiredArgsLength() == 0) {
+                main.execute(plugin, sender, null);
+                return true;
+            }
+
+            if (args.size() == 1) {
+                main.sendUsage(sender);
+                return true;
+            }
+
+            main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())));
+        }
+        return true;
+
+    }
+
+    public void registerMainCommand(MainCommand command) {
+        plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
+        mainCommands.add(command);
+    }
+
+}
@@ -0,0 +1,42 @@
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public abstract class MainCommand {
+
+    @Getter
+    private final String name;
+
+    @Getter
+    private final String usage;
+
+    @Getter
+    private final int requiredArgsLength;
+
+    public MainCommand(String name, String usage, int requiredArgsLength) {
+        this.name = name;
+        this.usage = usage;
+        this.requiredArgsLength = requiredArgsLength;
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args);
+    public abstract List<? extends SubCommand> getSubCommands();
+
+    protected void sendUsage(Sender sender) {
+        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        if (subs.size() > 0) {
+            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
+
+            for (SubCommand s : subs) {
+                s.sendUsage(sender);
+            }
+
+        } else {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+        }
+    }
+}
@@ -0,0 +1,8 @@
+package me.lucko.luckperms.commands;
+
+public interface Sender {
+
+    void sendMessage(String s);
+    boolean hasPermission(String node);
+
+}
@@ -0,0 +1,35 @@
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+
+public abstract class SubCommand {
+
+    @Getter
+    private final String name;
+
+    @Getter
+    private final String description;
+
+    @Getter
+    private final String usage;
+
+    @Getter
+    private final String permission;
+
+    public SubCommand(String name, String description, String usage, String permission) {
+        this.name = name;
+        this.description = description;
+        this.usage = usage;
+        this.permission = permission;
+    }
+
+    public boolean isAuthorized(Sender sender) {
+        return sender.hasPermission(permission);
+    }
+
+    public void sendUsage(Sender sender) {
+        Util.sendPluginMessage(sender, "&e-> &d" + getUsage());
+    }
+
+    public abstract boolean isArgLengthInvalid(int argLength);
+}
@@ -0,0 +1,81 @@
+package me.lucko.luckperms.commands;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class Util {
+
+    public static void sendPluginMessage(Sender sender, String message) {
+        // TODO: Pull the prefix from the config somehow
+        sender.sendMessage(color("&7&l[&b&lL&a&lP&7&l] &c" + message));
+    }
+
+    public static String color(String s) {
+        return translateAlternateColorCodes('&', s);
+    }
+
+    public static String translateAlternateColorCodes(char altColorChar, String textToTranslate) {
+        // Stolen from Bukkit :>
+        char[] b = textToTranslate.toCharArray();
+
+        for(int i = 0; i < b.length - 1; ++i) {
+            if(b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i + 1]) > -1) {
+                b[i] = 167;
+                b[i + 1] = Character.toLowerCase(b[i + 1]);
+            }
+        }
+
+        return new String(b);
+    }
+
+    public static void sendBoolean(Sender sender, String node, boolean b) {
+        if (b) {
+            sender.sendMessage(Util.color("&b" + node + ": &atrue"));
+        } else {
+            sender.sendMessage(Util.color("&b" + node + ": &cfalse"));
+        }
+    }
+
+    public static String listToCommaSep(List<String> strings) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+
+        for (String s : strings) {
+            sb.append("&6").append(s).append("&7, ");
+        }
+
+        return sb.delete(sb.length() - 2, sb.length()).toString();
+    }
+
+    public static String nodesToString(Map<String, Boolean> nodes) {
+        if (nodes.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+
+        for (String node : nodes.keySet()) {
+            if (nodes.get(node)) {
+                sb.append("&a").append(node).append("&7, ");
+            } else {
+                sb.append("&c").append(node).append("&7, ");
+            }
+        }
+
+        return sb.delete(sb.length() - 2, sb.length()).toString();
+    }
+
+    public static UUID parseUuid(String s) {
+        try {
+            return UUID.fromString(s);
+        } catch (IllegalArgumentException e) {
+            try {
+                return UUID.fromString(s.replaceAll(
+                        "(\\w{8})(\\w{4})(\\w{4})(\\w{4})(\\w{12})",
+                        "$1-$2-$3-$4-$5"));
+            } catch (IllegalArgumentException e1) {
+                return null;
+            }
+        }
+    }
+}
@@ -0,0 +1,51 @@
+package me.lucko.luckperms.commands.group;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CreateGroupCommand extends MainCommand {
+    public CreateGroupCommand() {
+        super("CreateGroup", "/perms creategroup <group>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.creategroup")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        if (args.size() == 0) {
+            sendUsage(sender);
+            return;
+        }
+
+        String groupName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (success) {
+                Util.sendPluginMessage(sender, "That group already exists!");
+            } else {
+                plugin.getDatastore().createAndLoadGroup(groupName, success1 -> {
+                    if (!success1) {
+                        Util.sendPluginMessage(sender, "There was an error whilst creating the group.");
+                    } else {
+                        Util.sendPluginMessage(sender, "&b" + groupName + "&a was successfully created.");
+                        plugin.runUpdateTask();
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}
@@ -0,0 +1,63 @@
+package me.lucko.luckperms.commands.group;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeleteGroupCommand extends MainCommand {
+    public DeleteGroupCommand() {
+        super("DeleteGroup", "/perms deletegroup <group>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.deletegroup")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        if (args.size() == 0) {
+            sendUsage(sender);
+            return;
+        }
+
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+            Util.sendPluginMessage(sender, "You cannot delete the default group.");
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "That group does not exist!");
+            } else {
+
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Util.sendPluginMessage(sender, "An unexpected error occurred.");
+                } else {
+                    plugin.getDatastore().deleteGroup(group, success1 -> {
+                        if (!success1) {
+                            Util.sendPluginMessage(sender, "There was an error whilst creating the group.");
+                        } else {
+                            Util.sendPluginMessage(sender, "&b" + groupName + "&a was successfully deleted.");
+                            plugin.runUpdateTask();
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}
@@ -0,0 +1,103 @@
+package me.lucko.luckperms.commands.group;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class GroupMainCommand extends MainCommand {
+
+    private final List<GroupSubCommand> subCommands = new ArrayList<>();
+
+    public GroupMainCommand() {
+        super("Group", "/perms group <group>", 2);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (args.size() <= 1) {
+            sendUsage(sender);
+            return;
+        }
+
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        String c = args.get(1);
+        GroupSubCommand tempSub = null;
+
+        for (GroupSubCommand s : subCommands) {
+            if (s.getName().equalsIgnoreCase(c)) {
+                tempSub = s;
+                break;
+            }
+        }
+
+        final GroupSubCommand sub = tempSub;
+
+        if (sub == null) {
+            Util.sendPluginMessage(sender, "Command not recognised.");
+            return;
+        }
+
+
+        if (!sub.isAuthorized(sender)) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        String g = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(g, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "&eGroup could not be found.");
+                return;
+            }
+
+            Group group = plugin.getGroupManager().getGroup(g);
+            if (group == null) {
+                Util.sendPluginMessage(sender, "&eGroup could not be found.");
+                return;
+            }
+
+            if (sub.isArgLengthInvalid(strippedArgs.size())) {
+                sub.sendUsage(sender);
+                return;
+            }
+
+            sub.execute(plugin, sender, group, strippedArgs);
+        });
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return subCommands;
+    }
+
+    public void registerSubCommand(GroupSubCommand subCommand) {
+        subCommands.add(subCommand);
+    }
+
+    @Override
+    protected void sendUsage(Sender sender) {
+        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        if (subs.size() > 0) {
+            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
+
+            for (SubCommand s : subs) {
+                s.sendUsage(sender);
+            }
+
+        } else {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+        }
+    }
+}
@@ -0,0 +1,29 @@
+package me.lucko.luckperms.commands.group;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public abstract class GroupSubCommand extends SubCommand {
+    public GroupSubCommand(String name, String description, String usage, String permission) {
+        super(name, description, usage, permission);
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args);
+
+    protected void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveGroup(group, success -> {
+            if (success) {
+                Util.sendPluginMessage(sender, "&7(Group data was saved to the datastore)");
+            } else {
+                Util.sendPluginMessage(sender, "There was an error whilst saving the group.");
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
+}
@@ -0,0 +1,37 @@
+package me.lucko.luckperms.commands.group;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListGroupsCommand extends MainCommand {
+    public ListGroupsCommand() {
+        super("ListGroups", "/perms listgroups", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.listgroups")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        plugin.getDatastore().loadAllGroups(success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "Unable to load all groups.");
+            } else {
+                Util.sendPluginMessage(sender, "&aGroups: " + Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getGroups().keySet())));
+            }
+        });
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return null;
+    }
+}
@@ -0,0 +1,29 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupClearCommand extends GroupSubCommand {
+    public GroupClearCommand() {
+        super("clear", "Clears a groups permissions",
+                "/perms group <group> clear", "luckperms.group.clear");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        group.clearNodes();
+        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a's permissions were cleared.");
+
+        saveGroup(group, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return true;
+    }
+}
@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupHasPermCommand extends GroupSubCommand {
+    public GroupHasPermCommand() {
+        super("haspermission", "Checks to see if a group has a certain permission node",
+                "/perms group <group> haspermission <node> [server]", "luckperms.group.haspermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        if (args.size() >= 2) {
+            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1)));
+        } else {
+            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}
@@ -0,0 +1,31 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupInfoCommand extends GroupSubCommand {
+    public GroupInfoCommand() {
+        super("info", "Gives info about the group",
+                "/perms group <group> info", "luckperms.group.info");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        final String prefix = plugin.getConfiguration().getPrefix();
+        String sb = prefix + "&d-> &eGroup: &6" + group.getName() + "\n" +
+                prefix + "&d-> &ePermissions: &6" + group.getNodes().keySet().size() + "\n" +
+                prefix + "&d-> &bUse &a/perms group " + group.getName() + " listnodes &bto see all permissions.";
+
+        sender.sendMessage(Util.color(sb));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}
@@ -0,0 +1,27 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupListNodesCommand extends GroupSubCommand {
+    public GroupListNodesCommand() {
+        super("listnodes", "Lists the permission nodes the group has",
+                "/perms group <group> listnodes", "luckperms.group.listnodes");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        Util.sendPluginMessage(sender, "&e" + group.getName() + "'s Nodes:");
+        sender.sendMessage(Util.color(Util.nodesToString(group.getNodes())));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}
@@ -0,0 +1,50 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupSetInheritCommand extends GroupSubCommand {
+    public GroupSetInheritCommand() {
+        super("setinherit", "Sets another group for this group to inherit permissions from",
+                "/perms group <group> setinherit <group> [server]", "luckperms.group.setinherit");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String groupName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, groupName + " does not exist!");
+            } else {
+                final String node = "luckperms.group." + groupName;
+
+                try {
+                    if (args.size() == 2) {
+                        final String server = args.get(1).toLowerCase();
+                        group.setPermission(node, true, server);
+                        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a now inherits permissions from &b" + groupName + "&a on server &b" + server + "&a.");
+                    } else {
+                        group.setPermission(node, true);
+                        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a now inherits permissions from &b" + groupName + "&a.");
+                    }
+
+                    saveGroup(group, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Util.sendPluginMessage(sender, group.getName() + " already inherits '" + groupName + "'.");
+                }
+            }
+        });
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}
@@ -0,0 +1,60 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupSetPermissionCommand extends GroupSubCommand {
+    public GroupSetPermissionCommand() {
+        super("set", "Sets a permission for a group",
+                "/perms group <group> set <node> <true|false> [server]", "luckperms.group.setpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String node = args.get(0);
+        String bool = args.get(1);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the inherit command instead of specifying the node.");
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        try {
+            if (args.size() == 3) {
+                final String server = args.get(2).toLowerCase();
+                group.setPermission(node, b, server);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to &b" + bool + "&a for &b" + group.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                group.setPermission(node, b);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to " + bool + " for &b" + group.getName() + "&a.");
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectAlreadyHasException e) {
+            Util.sendPluginMessage(sender, group.getName() + " already has this permission!");
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength < 2;
+    }
+}
@@ -0,0 +1,52 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupUnSetPermissionCommand extends GroupSubCommand {
+    public GroupUnSetPermissionCommand() {
+        super("unset", "Unsets a permission for a group",
+                "/perms group <group> unset <node> [server]", "luckperms.group.unsetpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String node = args.get(0);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the uninherit command instead of specifying the node.");
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                group.unsetPermission(node, server);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + group.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                group.unsetPermission(node);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + group.getName() + "&a.");
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "That group does not have this permission set.");
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}
@@ -0,0 +1,42 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupUnsetInheritCommand extends GroupSubCommand {
+    public GroupUnsetInheritCommand() {
+        super("unsetinherit", "Unsets another group for this group to inherit permissions from",
+                "/perms group <group> unsetinherit <group> [server]", "luckperms.group.unsetinherit");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String groupName = args.get(0).toLowerCase();
+
+        String server;
+        if (args.size() == 2) {
+            server = args.get(1).toLowerCase();
+        } else {
+            server = "global";
+        }
+
+        try {
+            group.unsetPermission("luckperms.group." + groupName, server);
+            Util.sendPluginMessage(sender, "&b" + group.getName() + "&a no longer inherits permissions from &b" + groupName + "&a on server &b" + server + "&a.");
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "That group does not inherit '" + groupName + "'.");
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}
@@ -0,0 +1,34 @@
+package me.lucko.luckperms.commands.misc;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DebugCommand extends MainCommand {
+    public DebugCommand() {
+        super("Debug", "/perms debug", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.debug")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&d>> Debug Info");
+        Util.sendPluginMessage(sender, "&eOnline Players: &6" + plugin.getPlayerCount());
+        Util.sendPluginMessage(sender, "&eLoaded Users: &6" + plugin.getUserManager().getUsers().size());
+        Util.sendPluginMessage(sender, "&eLoaded Groups: &6" + plugin.getGroupManager().getGroups().size());
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}
@@ -0,0 +1,33 @@
+package me.lucko.luckperms.commands.misc;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InfoCommand extends MainCommand {
+    public InfoCommand() {
+        super("Info", "/perms info", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.info")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&6Running &bLuckPerms " + plugin.getVersion() + "&6.");
+        Util.sendPluginMessage(sender, "&eAuthor: &6Luck");
+        Util.sendPluginMessage(sender, "&eStorage Method: &6" + plugin.getDatastore().getName());
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}
@@ -0,0 +1,32 @@
+package me.lucko.luckperms.commands.misc;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SyncCommand extends MainCommand {
+    public SyncCommand() {
+        super("Sync", "/perms sync", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.sync")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&bRunning update task for all online users.");
+        plugin.runUpdateTask();
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}
@@ -0,0 +1,115 @@
+package me.lucko.luckperms.commands.user;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.users.User;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class UserMainCommand extends MainCommand{
+
+    private final List<UserSubCommand> subCommands = new ArrayList<>();
+
+    public UserMainCommand() {
+        super("User", "/perms user <user>", 2);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (args.size() <= 1) {
+            sendUsage(sender);
+            return;
+        }
+
+        // The first argument is the name of the user, the second is the command
+        String command = args.get(1);
+        UserSubCommand tempSub = null;
+
+        // Try to identify the command used
+        for (UserSubCommand s : subCommands) {
+            if (s.getName().equalsIgnoreCase(command)) {
+                tempSub = s;
+                break;
+            }
+        }
+
+        // The command the sender used
+        final UserSubCommand sub = tempSub;
+
+        if (sub == null) {
+            Util.sendPluginMessage(sender, "Command not recognised.");
+            return;
+        }
+
+        if (!sub.isAuthorized(sender)) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        // The arguments to be passed onto the sub command
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        String user = args.get(0);
+
+        UUID u = Util.parseUuid(user);
+        if (u != null) {
+            runSub(plugin, sender, u, sub, strippedArgs);
+            return;
+        }
+
+        if (user.length() <= 16) {
+            Util.sendPluginMessage(sender, "&7(Attempting UUID lookup, since you specified a user)");
+
+            plugin.getDatastore().getUUID(user, uuid -> {
+                if (uuid == null) {
+                    Util.sendPluginMessage(sender, "&eUser could not be found.");
+                    return;
+                }
+                runSub(plugin, sender, uuid, sub, strippedArgs);
+            });
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&d" + user + "&c is not a valid username/uuid.");
+    }
+
+    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List<String> strippedArgs) {
+        plugin.getDatastore().loadUser(uuid, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "&eUser could not be found.");
+                return;
+            }
+
+            User user1 = plugin.getUserManager().getUser(uuid);
+
+            if (user1 == null) {
+                Util.sendPluginMessage(sender, "&eUser could not be found.");
+            }
+
+            if (command.isArgLengthInvalid(strippedArgs.size())) {
+                command.sendUsage(sender);
+                return;
+            }
+
+            command.execute(plugin, sender, user1, strippedArgs);
+            plugin.getUserManager().cleanupUser(user1);
+        });
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return subCommands;
+    }
+
+    public void registerSubCommand(UserSubCommand subCommand) {
+        subCommands.add(subCommand);
+    }
+}
@@ -0,0 +1,29 @@
+package me.lucko.luckperms.commands.user;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public abstract class UserSubCommand extends SubCommand {
+    public UserSubCommand(String name, String description, String usage, String permission) {
+        super(name, description, usage, permission);
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args);
+
+    protected void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
+        user.refreshPermissions();
+
+        plugin.getDatastore().saveUser(user, success -> {
+            if (success) {
+                Util.sendPluginMessage(sender, "&7(User data was saved to the datastore)");
+            } else {
+                Util.sendPluginMessage(sender, "There was an error whilst saving the user.");
+            }
+        });
+    }
+}
@@ -0,0 +1,49 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserAddGroupCommand extends UserSubCommand {
+    public UserAddGroupCommand() {
+        super("addgroup", "Adds the user to a group",
+                "/perms user <user> addgroup <group> [server]", "luckperms.user.addgroup");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String group = args.get(0).toLowerCase();
+
+        String server;
+        if (args.size() != 1) {
+            server = args.get(1);
+        } else {
+            server = "global";
+        }
+
+        Group group1 = plugin.getGroupManager().getGroup(group);
+        if (group1 == null) {
+            Util.sendPluginMessage(sender, "That group does not exist!");
+            return;
+        }
+
+        try {
+            user.addGroup(group1, server);
+            Util.sendPluginMessage(sender, "&b" + user.getName() + "&a successfully added to group &b" + group + "&a on the server &b" + server + "&a.");
+        } catch (ObjectAlreadyHasException e) {
+            Util.sendPluginMessage(sender, "The user is already a member of that group.");
+        }
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}
@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserClearCommand extends UserSubCommand {
+    public UserClearCommand() {
+        super("clear", "Clears a users permissions and groups",
+                "/perms user <user> clear", "luckperms.user.clear");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        user.clearNodes();
+        user.getNodes().put(plugin.getConfiguration().getDefaultGroupNode(), true);
+        Util.sendPluginMessage(sender, "&b" + user.getName() + "&a's permissions were cleared.");
+
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}
@@ -0,0 +1,25 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserGetUUIDCommand extends UserSubCommand {
+    public UserGetUUIDCommand() {
+        super("getuuid", "Get the UUID of a user", "/perms user <user> getuuid", "luckperms.user.getuuid");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        Util.sendPluginMessage(sender, "&bThe UUID of &e" + user.getName() + "&b is &e" + user.getUuid().toString() + "&b.");
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}
@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserHasPermCommand extends UserSubCommand {
+    public UserHasPermCommand() {
+        super("haspermission", "Checks to see if a user has a certain permission node",
+                "/perms user <user> haspermission <node> [server]", "luckperms.user.haspermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        if (args.size() >= 2) {
+            Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1)));
+        } else {
+            Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global"));
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}
@@ -0,0 +1,34 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserInfoCommand extends UserSubCommand {
+    public UserInfoCommand() {
+        super("info", "Gives info about the user",
+                "/perms user <user> info", "luckperms.user.info");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        final String prefix = plugin.getConfiguration().getPrefix();
+        String sb = prefix + "&d-> &eUser: &6" + user.getName() + "\n" +
+                prefix + "&d-> &eUUID: &6" + user.getUuid() + "\n" +
+                prefix + "&d-> &eStatus: " + plugin.getPlayerStatus(user.getUuid()) + "\n" +
+                prefix + "&d-> &eGroups: &6" + Util.listToCommaSep(user.getGroupNames()) + "\n" +
+                prefix + "&d-> &ePermissions: &6" + (user.getNodes().keySet().size() - user.getGroupNames().size()) + "\n" +
+                prefix + "&d-> &bUse &a/perms user " + user.getName() + " listnodes &bto see all permissions.";
+
+        sender.sendMessage(Util.color(sb));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}
@@ -0,0 +1,27 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserListNodesCommand extends UserSubCommand {
+    public UserListNodesCommand() {
+        super("listnodes", "Lists the permission nodes the user has",
+                "/perms user <user> listnodes", "luckperms.user.listnodes");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        Util.sendPluginMessage(sender, "&e" + user.getName() + "'s Nodes:");
+        sender.sendMessage(Util.color(Util.nodesToString(user.getNodes())));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}
@@ -0,0 +1,49 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserRemoveGroupCommand extends UserSubCommand {
+    public UserRemoveGroupCommand() {
+        super("removegroup", "Removes a user from a group",
+                "/perms user <user> removegroup <group> [server]", "luckperms.user.removegroup");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String group = args.get(0).toLowerCase();
+
+        String server;
+        if (args.size() != 1) {
+            server = args.get(1);
+        } else {
+            server = "global";
+        }
+
+        Group group1 = plugin.getGroupManager().getGroup(group);
+        if (group1 == null) {
+            Util.sendPluginMessage(sender, "That group does not exist!");
+            return;
+        }
+
+        try {
+            user.removeGroup(group1, server);
+            Util.sendPluginMessage(sender, "&b" + user.getName() + "&a was removed from group &b" + group + "&a on server &b" + server + "&a.");
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "The user is not a member of that group.");
+        }
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}
@@ -0,0 +1,60 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserSetPermissionCommand extends UserSubCommand {
+    public UserSetPermissionCommand() {
+        super("set", "Sets a permission for a user",
+                "/perms user <user> set <node> <true|false> [server]", "luckperms.user.setpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String node = args.get(0);
+        String bool = args.get(1);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the addgroup command instead of specifying the node.");
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        try {
+            if (args.size() == 3) {
+                final String server = args.get(2).toLowerCase();
+                user.setPermission(node, b, server);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to " + bool + " for &b" + user.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                user.setPermission(node, b);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to " + bool + " for &b" + user.getName() + "&a.");
+            }
+        } catch (ObjectAlreadyHasException e) {
+            Util.sendPluginMessage(sender, "That user already has this permission!");
+        }
+
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength < 2;
+    }
+}
@@ -0,0 +1,51 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserUnSetPermissionCommand extends UserSubCommand {
+    public UserUnSetPermissionCommand() {
+        super("unset", "Unsets a permission for a user",
+                "/perms user <user> unset <node> [server]", "luckperms.user.unsetpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String node = args.get(0);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the removegroup command instead of specifying the node.");
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                user.unsetPermission(node, server);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + user.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                user.unsetPermission(node);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + user.getName() + "&a.");
+            }
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "That user does not have this permission set.");
+        }
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}