Remove test files, bump version

README.creole

@@ -0,0 +1,142 @@
+= LuckPerms
+A (fairly bad) permissions implementation for Bukkit/BungeeCord.
+
+== Features
+* **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
+* **Temporary permissions** - users/groups can be given permissions that expire after a given time
+* **Temporary groups** - users/groups can be added to/inherit other groups temporarily
+* **Multi-server support** - data is synced across all servers/platforms
+* **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
+* **Server-specific groups** - define groups that only apply on certain servers
+* **Tracks / paths** - users can be promoted/demoted along multiple group tracks
+* **Vault Support** - hooks into Vault to integrate with other plugins
+* **Easy and simple setup and configuration using commands** - no editing yml files, yuck
+* **Efficient/lightweight** - maybe? Who knows, it might be.
+* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
+* **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
+
+===== Possible Caveats
+* Currently only supports MySQL, SQLite & Flatfile (JSON) (support for more methods might come in the future)
+* Not at all tested and could produce unexpected/buggy results and errors
+
+== Setup
+All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
+
+You can define the settings for per-server permissions, the storage method and credentials within this file.
+
+== Info
+=== Permission Calculation
+Permissions are calculated based on a priority system as follows.
+
+* Temporary permissions will override non-temporary permissions.
+
+Example: if a user has a false permission set for "test.node", and a temporary true permission set for "test.node", the temporary permission will override the permanent one, and the user will be granted the true node.
+
+* Server specific permissions will override generic/global permissions.
+
+Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission on the "factions" server, the server specific permission will override the globally defined one, and the user will be granted the negated node.
+
+* Inherited permissions will be overridden by an objects own permissions.
+
+Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node.
+
+=== Temporary Permissions
+Temporary permissions are checked each time a user/group is loaded, and when the sync task runs. This means if you set a temporary permission to expire after 30 seconds, it won't actually be removed until the sync task runs.
+
+The only way around this is to decrease the sync interval.
+
+== Commands
+
+Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
+
+=== Aliases
+| Bukkit | /luckperms |
+| | /perms |
+| | /permissions |
+| | /lp |
+| | /perm |
+| Bungee | /luckpermsbungee |
+| | /bperms |
+| | /bpermissions |
+| | /lpb |
+| | /bperm |
+
+Arguments: <required> [optional]
+
+Users with OP have access to all commands.
+
+Additionally, you can use wildcards to grant users access to a selection of commands.
+* **All commands** - luckperms.*
+* **All user commands** - luckperms.user.*
+* **All group commands** - luckperms.group.*
+* **All track commands** - luckperms.track.*
+
+
+|  **Command**  |  **Description**  |  **Permission**  |
+| /perms | Sends plugin info and usage | N/A |
+| /perms sync | Runs an update task and reloads the data of all online users | luckperms.sync |
+| /perms info | Shows information about the plugin | luckperms.info |
+| /perms debug | Shows some very brief debug info about the number of users/groups loaded | luckperms.debug |
+|  |  |  |
+|  |  |  |
+|  |  |  |
+| /perms creategroup <group> | Creates a new group with the given name | luckperms.creategroup |
+| /perms deletegroup <group> | Deletes an existing group | luckperms.deletegroup |
+| /perms listgroups | Shows a list of the groups registered within the system | luckperms.listgroups |
+|  |  |  |
+|  |  |  |
+|  |  |  |
+| /perms createtrack <track> | Creates a new track with the given name | luckperms.createtrack |
+| /perms deletetrack <track> | Deletes an existing track | luckperms.deletetrack |
+| /perms listtracks | Shows a list of the tracks registered within the system | luckperms.listtracks |
+|  |  |  |
+|  |  |  |
+|  |  |  |
+| /perms user <user> info | Shows info about the user | luckperms.user.info |
+| /perms user <user> getuuid | Shows the users Mojang UUID | luckperms.user.getuuid |
+| /perms user <user> listnodes | Lists all of the permission nodes the user has | luckperms.user.listnodes |
+| /perms user <user> haspermission <node> [server] | Checks if the user has a permission on a certain server | luckperms.user.haspermission |
+| /perms user <user> inheritspermission <node> [server] | Checks if the user inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.user.inheritspermission |
+| /perms user <user> set <node> <true/false> [server]| Sets a permission for the user | luckperms.user.setpermission |
+| /perms user <user> unset <node> [server] | Unsets a permission for the user | luckperms.user.unsetpermission |
+| /perms user <user> addgroup <group> [server] | Adds the user to a group | luckperms.user.addgroup |
+| /perms user <user> removegroup <group> [server] | Removes the user from a group | luckperms.user.removegroup |
+| /perms user <user> settemp <node> <true/false> <duration> [server]| Sets a temporary permission for the user | luckperms.user.settemppermission |
+| /perms user <user> unsettemp <node> [server] | Unsets a temporary permission for the user | luckperms.user.unsettemppermission |
+| /perms user <user> addtempgroup <group> <duration> [server] | Adds the user to a group temporarily | luckperms.user.addtempgroup |
+| /perms user <user> removetempgroup <group> [server] | Removes the user from a temporary group | luckperms.user.removetempgroup |
+| /perms user <user> setprimarygroup <group> | Sets the users primary group | luckperms.user.setprimarygroup |
+| /perms user <user> showtracks | Shows a list of the tracks the user can be promoted/demoted on | luckperms.user.showtracks |
+| /perms user <user> promote <track> | Promotes the user along a given track | luckperms.user.promote |
+| /perms user <user> demote <track> | Demotes the user along a given track | luckperms.user.demote |
+| /perms user <user> showpos <track> | Shows the users position on a given track | luckperms.user.showpos |
+| /perms user <user> clear | Clears all permissions the user has | luckperms.user.clear |
+|  |  |  |
+|  |  |  |
+|  |  |  |
+| /perms group <group> info | Shows info about the group | luckperms.group.info |
+| /perms group <group> listnodes | Lists all of the permission nodes the group has | luckperms.group.listnodes |
+| /perms group <group> haspermission <node> [server] | Checks if the group has a permission on a certain server | luckperms.group.haspermission |
+| /perms group <group> inheritspermission <node> [server] | Checks if the group inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.group.inheritspermission |
+| /perms group <group> set <node> <true/false> [server]| Sets a permission for the group | luckperms.group.setpermission |
+| /perms group <group> unset <node> [server] | Unsets a permission for the group | luckperms.group.unsetpermission |
+| /perms group <group> setinherit <group> [server]| Sets the group to inherit all permissions from another group | luckperms.group.setinherit |
+| /perms group <group> unsetinherit <group> [server] | Unsets a previously defined inheritance rule | luckperms.group.unsetinherit |
+| /perms group <group> settemp <node> <true/false> <duration> [server] | Sets a temporary permission for the group | luckperms.group.settemppermission |
+| /perms group <group> unsettemp <node> [server] | Unsets a temporary permission for the group | luckperms.group.unsettemppermission |
+| /perms group <group> settempinherit <group> <duration> [server] | Sets the group to inherit all permissions from another group temporarily | luckperms.group.settempinherit |
+| /perms group <group> unsettempinherit <group> [server] | Unsets a previously defined temporary inheritance rule | luckperms.group.unsettempinherit |
+| /perms group <group> showtracks | Shows a list of the tracks that the users in the group can be promoted/demoted on | luckperms.group.showtracks |
+| /perms group <group> clear | Clears all permissions the group has | luckperms.group.clear |
+|  |  |  |
+|  |  |  |
+|  |  |  |
+| /perms track <track> info | Shows info about the track | luckperms.track.info |
+| /perms track <track> append <group> | Appends a group to the end of the track | luckperms.track.append |
+| /perms track <track> insert <group> <position> | Inserts a group at the given position on the track | luckperms.track.insert |
+| /perms track <track> remove <group> | Removes a group from the track | luckperms.track.remove |
+| /perms track <track> clear | Clears all groups on the track | luckperms.track.clear |
+
+
+== License
+See LICENSE.md.

README.md

@@ -1,28 +0,0 @@
-# LuckPerms
-A quite possibly shit™ permissions implementation for Bukkit/BungeeCord.
-
-### Why?
-Yeah, I don't know. There are other more advanced, optimized, better programmed and thoroughly tested alternative plugins around, you should probably use those instead. I just wanted some specific features, and something that was compatible with BungeeCord.
-
-### Features
- - **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
- - **Multi-server support** - data is synced across all servers/platforms
- - **Per-server permissions/groups** - define permissions that only apply on certain servers
- - **Vault Support** - hooks into Vault to integrate with other plugins
- - **Everything is configured using commands** - no editing yml files, yuck
- - **Efficient** - maybe? Who knows, it might be.
- - **BungeeCord compatible** - my main motive for making this was that all other Bungee/Bukkit compatible perms plugins are utter aids. (At least, I couldn't find any decent ones)
-
-### Caveats
- - Only supports MySQL
- - Not at all tested and could be super unreliable
- - It's quite possibly shit™
-
-So, not anything major, really ¯\ _(ツ)_ /¯
-
-### Commands
-Command usage is printed when you supply too little arguments.
-
-Bukkit: `/luckperms` `/perms` `/permissions` `/lp` `/perm`
-
-Bungee: `/luckpermsbungee` `/bperms` `/bpermissions` `/lpb` `/bperm`

bukkit/pom.xml

@@ -5,12 +5,12 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko</groupId>
-        <version>1.0-SNAPSHOT</version>
+        <version>1.2</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bukkit</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>$(project.parent.version)</version>
     <packaging>jar</packaging>
     <name>LuckPerms</name>
 
@@ -28,7 +28,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.2</version>
+                <version>3.5.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -37,7 +37,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>2.3</version>
+                <version>2.4.3</version>
                 <executions>
                     <execution>
                         <phase>package</phase>

bukkit/src/main/java/me/lucko/luckperms/BukkitConfig.java

@@ -16,6 +16,7 @@ public class BukkitConfig implements LPConfiguration {
         create();
     }
 
+    @SuppressWarnings("ResultOfMethodCallIgnored")
     private void create() {
         File configFile = new File(plugin.getDataFolder(), "config.yml");
 
@@ -36,36 +37,36 @@ public class BukkitConfig implements LPConfiguration {
 
     @Override
     public String getServer() {
-        return configuration.getString("server");
-    }
-
-    @Override
-    public String getPrefix() {
-        return configuration.getString("prefix");
+        return configuration.getString("server", "global");
     }
 
     @Override
     public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes");
+        return configuration.getInt("sql.sync-minutes", 3);
     }
 
     @Override
     public String getDefaultGroupNode() {
-        return "luckperms.group." + configuration.getString("default-group");
+        return "group." + configuration.getString("default-group", "default");
     }
 
     @Override
     public String getDefaultGroupName() {
-        return configuration.getString("default-group");
+        return configuration.getString("default-group", "default");
     }
 
     @Override
     public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global");
+        return configuration.getBoolean("include-global", true);
     }
 
     @Override
     public String getDatabaseValue(String value) {
         return configuration.getString("sql." + value);
     }
+
+    @Override
+    public String getStorageMethod() {
+        return configuration.getString("storage-method", "sqlite");
+    }
 }

bukkit/src/main/java/me/lucko/luckperms/CommandManagerBukkit.java

@@ -5,26 +5,45 @@ import me.lucko.luckperms.commands.Sender;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 
+import java.lang.ref.WeakReference;
 import java.util.Arrays;
+import java.util.List;
 
-class CommandManagerBukkit extends CommandManager implements CommandExecutor {
+class CommandManagerBukkit extends CommandManager implements CommandExecutor, TabExecutor {
     CommandManagerBukkit(LuckPermsPlugin plugin) {
         super(plugin);
     }
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        return onCommand(new Sender() {
+        return onCommand(makeSender(sender), label, Arrays.asList(args));
+    }
+
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+        return onTabComplete(makeSender(sender), Arrays.asList(args));
+    }
+
+    private static Sender makeSender(CommandSender sender) {
+        return new Sender() {
+            final WeakReference<CommandSender> cs = new WeakReference<>(sender);
+
             @Override
             public void sendMessage(String s) {
-                sender.sendMessage(s);
+                final CommandSender c = cs.get();
+                if (c != null) {
+                    c.sendMessage(s);
+                }
             }
 
             @Override
             public boolean hasPermission(String node) {
-                return sender.hasPermission(node);
+                final CommandSender c = cs.get();
+                return c != null && c.hasPermission(node);
             }
-        }, Arrays.asList(args));
+        };
     }
 }

bukkit/src/main/java/me/lucko/luckperms/LPBukkitPlugin.java

@@ -2,32 +2,38 @@ 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.data.MySQLConfiguration;
+import me.lucko.luckperms.data.methods.FlatfileDatastore;
+import me.lucko.luckperms.data.methods.MySQLDatastore;
+import me.lucko.luckperms.data.methods.SQLiteDatastore;
 import me.lucko.luckperms.groups.GroupManager;
 import me.lucko.luckperms.listeners.PlayerListener;
 import me.lucko.luckperms.runnables.UpdateTask;
+import me.lucko.luckperms.tracks.TrackManager;
 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 me.lucko.luckperms.vaulthooks.VaultHook;
 import org.bukkit.Bukkit;
 import org.bukkit.command.PluginCommand;
+import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import java.io.File;
 import java.util.Arrays;
+import java.util.List;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 @Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.0";
+    public static final String VERSION = "v1.2";
 
     private LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
+    private TrackManager trackManager;
     private Datastore datastore;
 
     @Override
@@ -42,40 +48,60 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
         PluginCommand main = getServer().getPluginCommand("luckperms");
         main.setExecutor(commandManager);
+        main.setTabCompleter(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")
-        ));
+        final String storageMethod = configuration.getStorageMethod();
+
+        if (storageMethod.equalsIgnoreCase("mysql")) {
+            getLogger().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, new MySQLConfiguration(
+                    configuration.getDatabaseValue("address"),
+                    configuration.getDatabaseValue("database"),
+                    configuration.getDatabaseValue("username"),
+                    configuration.getDatabaseValue("password")
+            ));
+        } else if (storageMethod.equalsIgnoreCase("sqlite")) {
+            getLogger().info("Using SQLite as storage method.");
+            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
+        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
+            getLogger().info("Using Flatfile (JSON) as storage method.");
+            datastore = new FlatfileDatastore(this, getDataFolder());
+        } else {
+            getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
+            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
+        }
+
+        datastore.init();
 
         userManager = new BukkitUserManager(this);
         groupManager = new GroupManager(this);
+        trackManager = new TrackManager(this);
+
+        // Run update task to refresh any online users
+        runUpdateTask();
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
             long ticks = mins * 60 * 20;
-            new UpdateTask(this).runTaskTimer(this, ticks, ticks);
+            getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(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();
+        if (getServer().getPluginManager().isPluginEnabled("Vault")) {
+            VaultHook.hook(this);
+            getLogger().info("Registered Vault permission & chat hook.");
+        } else {
+            getLogger().info("Vault not found.");
         }
 
     }
 
+    @Override
+    public void onDisable() {
+        datastore.shutdown();
+    }
+
     @Override
     public void doAsync(Runnable r) {
         Bukkit.getScheduler().runTaskAsynchronously(this, r);
@@ -93,8 +119,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
 
     @Override
     public String getPlayerStatus(UUID uuid) {
-        if (getServer().getPlayer(uuid) != null) return "&aOnline";
-        return "&cOffline";
+        return getServer().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
     }
 
     @Override
@@ -102,8 +127,13 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return getServer().getOnlinePlayers().size();
     }
 
+    @Override
+    public List<String> getPlayerList() {
+        return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
+    }
+
     @Override
     public void runUpdateTask() {
-        new UpdateTask(this).runTask(this);
+        getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));
     }
 }

bukkit/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -2,9 +2,10 @@ package me.lucko.luckperms.listeners;
 
 import lombok.AllArgsConstructor;
 import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.constants.Message;
 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;
@@ -20,8 +21,8 @@ public class PlayerListener implements Listener {
     @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."));
+            e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER,
+                    Util.color(Message.PREFIX + "Error whilst validating login with the network. \nPlease contact an administrator."));
             return;
         }
         plugin.getDatastore().loadOrCreateUser(e.getUniqueId(), e.getName());
@@ -33,8 +34,8 @@ public class PlayerListener implements Listener {
         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."));
+            e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
+                    Util.color(Message.PREFIX + "User data could not be loaded. Please contact an administrator."));
             return;
         }
 
@@ -68,8 +69,4 @@ public class PlayerListener implements Listener {
         plugin.getUserManager().unloadUser(user);
     }
 
-    public static String color(String string) {
-        return ChatColor.translateAlternateColorCodes('&', string);
-    }
-
 }

bukkit/src/main/java/me/lucko/luckperms/runnables/UpdateTask.java

@@ -1,25 +0,0 @@
-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 -> {});
-        }
-    }
-}

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUser.java

@@ -18,35 +18,33 @@ public class BukkitUser extends User {
     @Setter
     private PermissionAttachment attachment = null;
 
-    public BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
+    BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
         super(uuid, plugin);
         this.plugin = plugin;
     }
 
-    public BukkitUser(UUID uuid, String username, LPBukkitPlugin plugin) {
+    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;
+        plugin.doSync(() -> {
+            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));
-        }
+            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);
-        }
+            // Clear existing permissions
+            attachment.getPermissions().keySet().forEach(p -> 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));
-        }
+            // Re-add all defined permissions for the user
+            Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
+            local.entrySet().forEach(e -> attachment.setPermission(e.getKey(), e.getValue()));
+        });
     }
 }

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUserManager.java

@@ -10,6 +10,7 @@ public class BukkitUserManager extends UserManager {
     private final LPBukkitPlugin plugin;
 
     public BukkitUserManager(LPBukkitPlugin plugin) {
+        super(plugin);
         this.plugin = plugin;
     }
 
@@ -50,4 +51,9 @@ public class BukkitUserManager extends UserManager {
     public User makeUser(UUID uuid, String username) {
         return new BukkitUser(uuid, username, plugin);
     }
+
+    @Override
+    public void updateAllUsers() {
+        plugin.getServer().getOnlinePlayers().stream().map(Player::getUniqueId).forEach(u -> plugin.getDatastore().loadUser(u));
+    }
 }

bukkit/src/main/java/me/lucko/luckperms/vaulthooks/VaultChatHook.java

@@ -0,0 +1,127 @@
+package me.lucko.luckperms.vaulthooks;
+
+import net.milkbowl.vault.chat.Chat;
+import net.milkbowl.vault.permission.Permission;
+
+/**
+ * Dummy class for hooking with Vault plugins that need both Chat + Perms
+ * This doesn't return anything useful, or change anything internally
+ *
+ * Registered on the lowest priority so other plugins can override
+ */
+class VaultChatHook extends Chat {
+
+    VaultChatHook(Permission perms) {
+        super(perms);
+    }
+
+    private void throwNotSupported() {
+        // throw new UnsupportedOperationException("LuckPerms cannot perform this operation.");
+    }
+
+    public String getName() {
+        return "LuckPerms";
+    }
+
+
+    public boolean isEnabled() {
+        return true;
+    }
+
+    public String getPlayerPrefix(String world, String player) {
+        return "";
+    }
+
+    public void setPlayerPrefix(String world, String player, String prefix) {
+        throwNotSupported();
+    }
+
+    public String getPlayerSuffix(String world, String player) {
+        return "";
+    }
+
+    public void setPlayerSuffix(String world, String player, String suffix) {
+        throwNotSupported();
+    }
+
+    public String getGroupPrefix(String world, String group) {
+        return "";
+    }
+
+    public void setGroupPrefix(String world, String group, String prefix) {
+        throwNotSupported();
+    }
+
+    public String getGroupSuffix(String world, String group) {
+        return "";
+    }
+
+    public void setGroupSuffix(String world, String group, String suffix) {
+        throwNotSupported();
+    }
+
+    public int getPlayerInfoInteger(String world, String player, String node, int defaultValue) {
+        return defaultValue;
+    }
+
+    public void setPlayerInfoInteger(String world, String player, String node, int value) {
+        throwNotSupported();
+    }
+
+    public int getGroupInfoInteger(String world, String group, String node, int defaultValue) {
+        return defaultValue;
+    }
+
+    public void setGroupInfoInteger(String world, String group, String node, int value) {
+        throwNotSupported();
+    }
+
+    public double getPlayerInfoDouble(String world, String player, String node, double defaultValue) {
+        return defaultValue;
+    }
+
+    public void setPlayerInfoDouble(String world, String player, String node, double value) {
+        throwNotSupported();
+    }
+
+    public double getGroupInfoDouble(String world, String group, String node, double defaultValue) {
+        return defaultValue;
+    }
+
+    public void setGroupInfoDouble(String world, String group, String node, double value) {
+        throwNotSupported();
+    }
+
+    public boolean getPlayerInfoBoolean(String world, String player, String node, boolean defaultValue) {
+        return defaultValue;
+    }
+
+    public void setPlayerInfoBoolean(String world, String player, String node, boolean value) {
+        throwNotSupported();
+    }
+
+    public boolean getGroupInfoBoolean(String world, String group, String node, boolean defaultValue) {
+        return defaultValue;
+    }
+
+    public void setGroupInfoBoolean(String world, String group, String node, boolean value) {
+        throwNotSupported();
+    }
+
+    public String getPlayerInfoString(String world, String player, String node, String defaultValue) {
+        return defaultValue;
+    }
+
+    public void setPlayerInfoString(String world, String player, String node, String value) {
+        throwNotSupported();
+    }
+
+    public String getGroupInfoString(String world, String group, String node, String defaultValue) {
+        return defaultValue;
+    }
+
+    public void setGroupInfoString(String world, String group, String node, String value) {
+        throwNotSupported();
+    }
+
+}

bukkit/src/main/java/me/lucko/luckperms/vaulthooks/VaultHook.java

@@ -0,0 +1,36 @@
+package me.lucko.luckperms.vaulthooks;
+
+import me.lucko.luckperms.LPBukkitPlugin;
+import net.milkbowl.vault.chat.Chat;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.ServicesManager;
+
+public class VaultHook {
+
+    private static VaultChatHook chatHook = null;
+    private static VaultPermissionHook permissionHook = null;
+
+    public static void hook(LPBukkitPlugin plugin) {
+        try {
+            if (permissionHook == null) {
+                permissionHook = new VaultPermissionHook();
+            }
+            permissionHook.setPlugin(plugin);
+
+            if (chatHook == null) {
+                chatHook = new VaultChatHook(permissionHook);
+            }
+
+            final ServicesManager sm = plugin.getServer().getServicesManager();
+            sm.unregisterAll(plugin);
+            sm.register(Permission.class, permissionHook, plugin, ServicePriority.High);
+            sm.register(Chat.class, chatHook, plugin, ServicePriority.Lowest);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}

bukkit/src/main/java/me/lucko/luckperms/vaulthooks/VaultPermissionHook.java

@@ -1,15 +1,17 @@
-package me.lucko.luckperms;
+package me.lucko.luckperms.vaulthooks;
 
-import lombok.AllArgsConstructor;
+import lombok.Setter;
+import me.lucko.luckperms.LPBukkitPlugin;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
 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;
+class VaultPermissionHook extends Permission {
+
+    @Setter
+    private LPBukkitPlugin plugin;
 
     @Override
     public String getName() {
@@ -52,7 +54,7 @@ public class VaultHook extends Permission {
 
         try {
             user.unsetPermission(permission);
-        } catch (ObjectLacksPermissionException ignored) {}
+        } catch (ObjectLacksException ignored) {}
         plugin.getUserManager().saveUser(user, plugin.getDatastore());
         return true;
     }
@@ -82,7 +84,7 @@ public class VaultHook extends Permission {
 
         try {
             group.unsetPermission(permission);
-        } catch (ObjectLacksPermissionException ignored) {}
+        } catch (ObjectLacksException ignored) {}
         plugin.runUpdateTask();
         return true;
     }
@@ -92,7 +94,8 @@ public class VaultHook extends Permission {
         final User user = plugin.getUserManager().getUser(player);
         if (user == null) return false;
 
-        return user.getGroupNames().contains(group);
+        final Group group1 = plugin.getGroupManager().getGroup(group);
+        return group1 != null && user.isInGroup(group1);
     }
 
     @Override
@@ -120,7 +123,7 @@ public class VaultHook extends Permission {
 
         try {
             user.removeGroup(group);
-        } catch (ObjectLacksPermissionException ignored) {}
+        } catch (ObjectLacksException ignored) {}
         plugin.getUserManager().saveUser(user, plugin.getDatastore());
         return true;
     }
@@ -128,14 +131,13 @@ public class VaultHook extends Permission {
     @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]);
+        return (user == null) ? new String[0] : user.getGroupNames().toArray(new String[0]);
     }
 
     @Override
     public String getPrimaryGroup(String world, String player) {
-        throw new UnsupportedOperationException();
+        final User user = plugin.getUserManager().getUser(player);
+        return (user == null) ? null : user.getPrimaryGroup();
     }
 
     @Override

bukkit/src/main/resources/config.yml

@@ -3,13 +3,16 @@
 # 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
+# The default group assigned to all users on their first join.
 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'
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, flatfile
+# Fill out connection info below if you're using MySQL
+storage-method: sqlite
 
 sql:
   address: localhost:3306

bukkit/src/main/resources/plugin.yml

@@ -1,6 +1,6 @@
 name: LuckPerms
 author: Luck
-version: 1.0
+version: 1.2
 main: me.lucko.luckperms.LPBukkitPlugin
 softdepend: [Vault]
 description: A permissions plugin

bungee/pom.xml

@@ -5,12 +5,12 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko</groupId>
-        <version>1.0-SNAPSHOT</version>
+        <version>1.2</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bungee</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>$(project.parent.version)</version>
     <packaging>jar</packaging>
     <name>LuckPerms</name>
 
@@ -28,7 +28,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.2</version>
+                <version>3.5.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -37,7 +37,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>2.3</version>
+                <version>2.4.3</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
@@ -59,7 +59,6 @@
             <groupId>net.md-5</groupId>
             <artifactId>bungeecord-api</artifactId>
             <version>1.9-SNAPSHOT</version>
-            <type>jar</type>
             <scope>provided</scope>
         </dependency>
         <!-- LuckPerms Common -->

bungee/src/main/java/me/lucko/luckperms/BungeeConfig.java

@@ -27,6 +27,7 @@ public class BungeeConfig implements LPConfiguration {
         }
     }
 
+    @SuppressWarnings("ResultOfMethodCallIgnored")
     private File makeFile(String file) throws IOException {
         File cfg = new File(plugin.getDataFolder(), file);
 
@@ -40,39 +41,38 @@ public class BungeeConfig implements LPConfiguration {
         return cfg;
     }
 
-
     @Override
     public String getServer() {
-        return configuration.getString("server");
-    }
-
-    @Override
-    public String getPrefix() {
-        return configuration.getString("prefix");
+        return configuration.getString("server", "bungee");
     }
 
     @Override
     public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes");
+        return configuration.getInt("sql.sync-minutes", 3);
     }
 
     @Override
     public String getDefaultGroupNode() {
-        return "luckperms.group." + configuration.getString("default-group");
+        return "group." + configuration.getString("default-group", "default");
     }
 
     @Override
     public String getDefaultGroupName() {
-        return configuration.getString("default-group");
+        return configuration.getString("default-group", "default");
     }
 
     @Override
     public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global");
+        return configuration.getBoolean("include-global", false);
     }
 
     @Override
     public String getDatabaseValue(String value) {
         return configuration.getString("sql." + value);
     }
+
+    @Override
+    public String getStorageMethod() {
+        return configuration.getString("storage-method", "sqlite");
+    }
 }

bungee/src/main/java/me/lucko/luckperms/LPBungeePlugin.java

@@ -3,33 +3,33 @@ package me.lucko.luckperms;
 import lombok.Getter;
 import me.lucko.luckperms.commands.CommandManager;
 import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.DatastoreConfiguration;
-import me.lucko.luckperms.data.HikariDatastore;
+import me.lucko.luckperms.data.MySQLConfiguration;
+import me.lucko.luckperms.data.methods.FlatfileDatastore;
+import me.lucko.luckperms.data.methods.MySQLDatastore;
 import me.lucko.luckperms.groups.GroupManager;
 import me.lucko.luckperms.listeners.PlayerListener;
 import me.lucko.luckperms.runnables.UpdateTask;
+import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
 
+import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
+@Getter
 public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.0";
+    public static final String VERSION = "v1.2";
 
-    @Getter
-    LPConfiguration configuration;
-
-    @Getter
-    UserManager userManager;
-
-    @Getter
-    GroupManager groupManager;
-
-    @Getter
-    Datastore datastore;
+    private LPConfiguration configuration;
+    private UserManager userManager;
+    private GroupManager groupManager;
+    private TrackManager trackManager;
+    private Datastore datastore;
 
     @Override
     public void onEnable() {
@@ -41,16 +41,32 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         // register commands
         getProxy().getPluginManager().registerCommand(this, new MainCommand(new CommandManager(this)));
 
-        datastore = new HikariDatastore(this);
-        datastore.init(new DatastoreConfiguration(
-                configuration.getDatabaseValue("address"),
-                configuration.getDatabaseValue("database"),
-                configuration.getDatabaseValue("username"),
-                configuration.getDatabaseValue("password")
-        ));
+        // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
+        getProxy().getDisabledCommands().add("perms");
+
+        final String storageMethod = configuration.getStorageMethod();
+
+        if (storageMethod.equalsIgnoreCase("mysql")) {
+            getLogger().info("Using MySQL as storage method.");
+            datastore = new MySQLDatastore(this, new MySQLConfiguration(
+                    configuration.getDatabaseValue("address"),
+                    configuration.getDatabaseValue("database"),
+                    configuration.getDatabaseValue("username"),
+                    configuration.getDatabaseValue("password")
+            ));
+        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
+            getLogger().info("Using Flatfile (JSON) as storage method.");
+            datastore = new FlatfileDatastore(this, getDataFolder());
+        } else {
+            getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
+            datastore = new FlatfileDatastore(this, getDataFolder());
+        }
+
+        datastore.init();
 
         userManager = new BungeeUserManager(this);
         groupManager = new GroupManager(this);
+        trackManager = new TrackManager(this);
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
@@ -58,15 +74,9 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         }
     }
 
-
     @Override
-    public UserManager getUserManager() {
-        return userManager;
-    }
-
-    @Override
-    public GroupManager getGroupManager() {
-        return groupManager;
+    public void onDisable() {
+        datastore.shutdown();
     }
 
     @Override
@@ -76,8 +86,7 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
 
     @Override
     public String getPlayerStatus(UUID uuid) {
-        if (getProxy().getPlayer(uuid) != null) return "&aOnline";
-        return "&cOffline";
+        return getProxy().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
     }
 
     @Override
@@ -86,18 +95,13 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     }
 
     @Override
-    public LPConfiguration getConfiguration() {
-        return configuration;
-    }
-
-    @Override
-    public Datastore getDatastore() {
-        return datastore;
+    public List<String> getPlayerList() {
+        return getProxy().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList());
     }
 
     @Override
     public void runUpdateTask() {
-        new UpdateTask(this).run();
+        doAsync(new UpdateTask(this));
     }
 
     @Override

bungee/src/main/java/me/lucko/luckperms/MainCommand.java

@@ -5,30 +5,47 @@ import me.lucko.luckperms.commands.Sender;
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.plugin.Command;
+import net.md_5.bungee.api.plugin.TabExecutor;
 
+import java.lang.ref.WeakReference;
 import java.util.Arrays;
 
-public class MainCommand extends Command {
+class MainCommand extends Command implements TabExecutor {
     private final CommandManager manager;
 
     public MainCommand(CommandManager manager) {
-        super("luckpermsbungee", "luckperms.use", "bperms", "lpb", "bpermissions", "bp", "bperm");
+        super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
         this.manager = manager;
 
     }
 
     @Override
     public void execute(CommandSender sender, String[] args) {
-        manager.onCommand(new Sender() {
+        manager.onCommand(makeSender(sender), "bperms", Arrays.asList(args));
+    }
+
+    @Override
+    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
+        return manager.onTabComplete(makeSender(sender), Arrays.asList(args));
+    }
+
+    private static Sender makeSender(CommandSender sender) {
+        return new Sender() {
+            final WeakReference<CommandSender> cs = new WeakReference<>(sender);
+
             @Override
             public void sendMessage(String s) {
-                sender.sendMessage(new TextComponent(s));
+                final CommandSender c = cs.get();
+                if (c != null) {
+                    c.sendMessage(new TextComponent(s));
+                }
             }
 
             @Override
             public boolean hasPermission(String node) {
-                return sender.hasPermission(node);
+                final CommandSender c = cs.get();
+                return c != null && c.hasPermission(node);
             }
-        }, Arrays.asList(args));
+        };
     }
 }

bungee/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -3,7 +3,7 @@ package me.lucko.luckperms.listeners;
 import lombok.AllArgsConstructor;
 import me.lucko.luckperms.LPBungeePlugin;
 import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.users.User;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
@@ -12,6 +12,9 @@ import net.md_5.bungee.api.event.PostLoginEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
 
+import java.lang.ref.WeakReference;
+import java.util.concurrent.TimeUnit;
+
 @AllArgsConstructor
 public class PlayerListener implements Listener {
 
@@ -20,17 +23,27 @@ public class PlayerListener implements Listener {
     @EventHandler
     public void onPlayerPostLogin(PostLoginEvent e) {
         final ProxiedPlayer player = e.getPlayer();
+        final WeakReference<ProxiedPlayer> p = new WeakReference<>(player);
 
         plugin.getDatastore().loadOrCreateUser(player.getUniqueId(), player.getName(), success -> {
             if (!success) {
-                e.getPlayer().sendMessage(new TextComponent(Util.color("&e&l[LP] &cPermissions data could not be loaded. Please contact an administrator.")));
+                plugin.getProxy().getScheduler().schedule(plugin, () -> {
+                    final ProxiedPlayer pl = p.get();
+                    if (pl != null) {
+                        pl.sendMessage(new TextComponent(Util.color(Message.PREFIX + "Permissions data could not be loaded. Please contact an administrator.")));
+                    }
+                }, 3, TimeUnit.SECONDS);
+
             } else {
-                User user = plugin.getUserManager().getUser(player.getUniqueId());
-                user.refreshPermissions();
+                final ProxiedPlayer pl = p.get();
+                if (pl != null) {
+                    final User user = plugin.getUserManager().getUser(pl.getUniqueId());
+                    user.refreshPermissions();
+                }
             }
         });
 
-        plugin.getDatastore().saveUUIDData(e.getPlayer().getName(), e.getPlayer().getUniqueId(), success -> {});
+        plugin.getDatastore().saveUUIDData(player.getName(), player.getUniqueId(), success -> {});
     }
 
     @EventHandler

bungee/src/main/java/me/lucko/luckperms/runnables/UpdateTask.java

@@ -1,23 +0,0 @@
-package me.lucko.luckperms.runnables;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.LPBungeePlugin;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-@AllArgsConstructor
-public class UpdateTask implements Runnable {
-    private final LPBungeePlugin 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 (ProxiedPlayer p : plugin.getProxy().getPlayers()) {
-            plugin.getDatastore().loadUser(p.getUniqueId(), success -> {});
-        }
-    }
-}

bungee/src/main/java/me/lucko/luckperms/users/BungeeUser.java

@@ -12,12 +12,12 @@ public class BungeeUser extends User {
 
     private final LPBungeePlugin plugin;
 
-    public BungeeUser(UUID uuid, LPBungeePlugin plugin) {
+    BungeeUser(UUID uuid, LPBungeePlugin plugin) {
         super(uuid, plugin);
         this.plugin = plugin;
     }
 
-    public BungeeUser(UUID uuid, String username, LPBungeePlugin plugin) {
+    BungeeUser(UUID uuid, String username, LPBungeePlugin plugin) {
         super(uuid, username, plugin);
         this.plugin = plugin;
     }
@@ -29,14 +29,10 @@ public class BungeeUser extends User {
 
         // Clear existing permissions
         Collection<String> perms = new ArrayList<>(player.getPermissions());
-        for (String p : perms) {
-            player.setPermission(p, false);
-        }
+        perms.forEach(p -> player.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()) {
-            player.setPermission(node, local.get(node));
-        }
+        local.entrySet().forEach(e -> player.setPermission(e.getKey(), e.getValue()));
     }
 }

bungee/src/main/java/me/lucko/luckperms/users/BungeeUserManager.java

@@ -9,18 +9,15 @@ public class BungeeUserManager extends UserManager {
     private final LPBungeePlugin plugin;
 
     public BungeeUserManager(LPBungeePlugin plugin) {
+        super(plugin);
         this.plugin = plugin;
     }
 
     @Override
     public void unloadUser(User user) {
         if (user != null) {
-
-            ProxiedPlayer player = plugin.getProxy().getPlayer(user.getUuid());
-            if (player != null) {
-                player.getPermissions().clear();
-            }
-
+            // Cannot clear the ProxiedPlayer's permission map, they're leaving so that will get GCed anyway
+            // Calling getPermissions.clear() throws an UnsupportedOperationException
             getUsers().remove(user.getUuid());
         }
     }
@@ -41,4 +38,9 @@ public class BungeeUserManager extends UserManager {
     public User makeUser(UUID uuid, String username) {
         return new BungeeUser(uuid, username, plugin);
     }
+
+    @Override
+    public void updateAllUsers() {
+        plugin.getProxy().getPlayers().stream().map(ProxiedPlayer::getUniqueId).forEach(u -> plugin.getDatastore().loadUser(u));
+    }
 }

bungee/src/main/resources/config.yml

@@ -3,13 +3,16 @@
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: bungee
 
-# The default group assigned to all user on join. e.g. a value of "default" = luckperms.group.default
+# The default group assigned to all users on their first join.
 default-group: default
 
 # If users on this server should have their global permissions/groups applied.
 include-global: false
 
-prefix: '&7&l[&b&lL&a&lP&7&l] &c'
+# Which storage method the plugin should use.
+# Currently supported: mysql & flatfile
+# Fill out connection info below if you're using MySQL
+storage-method: flatfile
 
 sql:
   address: localhost:3306

bungee/src/main/resources/plugin.yml

@@ -1,3 +1,5 @@
 name: LuckPerms
+author: Luck
+version: 1.2
 main: me.lucko.luckperms.LPBungeePlugin
-author: Luck
+description: A permissions plugin

common/pom.xml

@@ -5,17 +5,18 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko</groupId>
-        <version>1.0-SNAPSHOT</version>
+        <version>1.2</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-common</artifactId>
+    <version>$(project.parent.version)</version>
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.2</version>
+                <version>3.5.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>

common/src/main/java/me/lucko/luckperms/LuckPermsPlugin.java

@@ -2,9 +2,11 @@ package me.lucko.luckperms;
 
 import me.lucko.luckperms.data.Datastore;
 import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.UserManager;
 import me.lucko.luckperms.utils.LPConfiguration;
 
+import java.util.List;
 import java.util.UUID;
 import java.util.logging.Logger;
 
@@ -12,16 +14,22 @@ public interface LuckPermsPlugin {
 
     /**
      * Retrieves the {@link UserManager} used to manage users and their permissions/groups
-     * @return the {@link UserManager} object
+     * @return the {@link UserManager} instance
      */
     UserManager getUserManager();
 
     /**
      * Retrieves the {@link GroupManager} used to manage the loaded groups and modify their permissions
-     * @return the {@link GroupManager} object
+     * @return the {@link GroupManager} instance
      */
     GroupManager getGroupManager();
 
+    /**
+     * Retrieves the {@link TrackManager} used to manage the loaded tracks
+     * @return the {@link TrackManager} instance
+     */
+    TrackManager getTrackManager();
+
     /**
      * Retrieves the {@link LPConfiguration} for getting values from the config
      * @return the {@link LPConfiguration} implementation for the platform
@@ -58,6 +66,12 @@ public interface LuckPermsPlugin {
      */
     int getPlayerCount();
 
+    /**
+     * Gets the usernames of the users online on the platform
+     * @return a {@link List} of usernames
+     */
+    List<String> getPlayerList();
+
     /**
      * Runs an update task
      */

common/src/main/java/me/lucko/luckperms/commands/CommandManager.java

@@ -2,20 +2,29 @@ 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.CreateGroup;
+import me.lucko.luckperms.commands.group.DeleteGroup;
 import me.lucko.luckperms.commands.group.GroupMainCommand;
-import me.lucko.luckperms.commands.group.ListGroupsCommand;
+import me.lucko.luckperms.commands.group.ListGroups;
 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.track.CreateTrack;
+import me.lucko.luckperms.commands.track.DeleteTrack;
+import me.lucko.luckperms.commands.track.ListTracks;
+import me.lucko.luckperms.commands.track.TrackMainCommand;
+import me.lucko.luckperms.commands.track.subcommands.*;
 import me.lucko.luckperms.commands.user.UserMainCommand;
 import me.lucko.luckperms.commands.user.subcommands.*;
+import me.lucko.luckperms.constants.Message;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
 import java.util.logging.Level;
+import java.util.stream.Collectors;
 
 public class CommandManager {
     private final LuckPermsPlugin plugin;
@@ -28,33 +37,60 @@ public class CommandManager {
 
         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());
+        userCommand.registerSubCommand(new UserInfo());
+        userCommand.registerSubCommand(new UserGetUUID());
+        userCommand.registerSubCommand(new UserListNodes());
+        userCommand.registerSubCommand(new UserHasPerm());
+        userCommand.registerSubCommand(new UserInheritsPerm());
+        userCommand.registerSubCommand(new UserSetPermission());
+        userCommand.registerSubCommand(new UserUnSetPermission());
+        userCommand.registerSubCommand(new UserAddGroup());
+        userCommand.registerSubCommand(new UserRemoveGroup());
+        userCommand.registerSubCommand(new UserSetTempPermission());
+        userCommand.registerSubCommand(new UserUnsetTempPermission());
+        userCommand.registerSubCommand(new UserAddTempGroup());
+        userCommand.registerSubCommand(new UserRemoveTempGroup());
+        userCommand.registerSubCommand(new UserSetPrimaryGroup());
+        userCommand.registerSubCommand(new UserShowTracks());
+        userCommand.registerSubCommand(new UserPromote());
+        userCommand.registerSubCommand(new UserDemote());
+        userCommand.registerSubCommand(new UserShowPos());
+        userCommand.registerSubCommand(new UserClear());
 
         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());
+        groupCommand.registerSubCommand(new GroupInfo());
+        groupCommand.registerSubCommand(new GroupListNodes());
+        groupCommand.registerSubCommand(new GroupHasPerm());
+        groupCommand.registerSubCommand(new GroupInheritsPerm());
+        groupCommand.registerSubCommand(new GroupSetPermission());
+        groupCommand.registerSubCommand(new GroupUnSetPermission());
+        groupCommand.registerSubCommand(new GroupSetInherit());
+        groupCommand.registerSubCommand(new GroupUnsetInherit());
+        groupCommand.registerSubCommand(new GroupSetTempPermission());
+        groupCommand.registerSubCommand(new GroupUnsetTempPermission());
+        groupCommand.registerSubCommand(new GroupSetTempInherit());
+        groupCommand.registerSubCommand(new GroupUnsetTempInherit());
+        groupCommand.registerSubCommand(new GroupShowTracks());
+        groupCommand.registerSubCommand(new GroupClear());
+
+        TrackMainCommand trackCommand = new TrackMainCommand();
+        this.registerMainCommand(trackCommand);
+        trackCommand.registerSubCommand(new TrackInfo());
+        trackCommand.registerSubCommand(new TrackAppend());
+        trackCommand.registerSubCommand(new TrackInsert());
+        trackCommand.registerSubCommand(new TrackRemove());
+        trackCommand.registerSubCommand(new TrackClear());
 
-        this.registerMainCommand(new CreateGroupCommand());
-        this.registerMainCommand(new DeleteGroupCommand());
-        this.registerMainCommand(new ListGroupsCommand());
-        this.registerMainCommand(new DebugCommand());
-        this.registerMainCommand(new InfoCommand());
         this.registerMainCommand(new SyncCommand());
+        this.registerMainCommand(new InfoCommand());
+        this.registerMainCommand(new DebugCommand());
+        this.registerMainCommand(new CreateGroup());
+        this.registerMainCommand(new DeleteGroup());
+        this.registerMainCommand(new ListGroups());
+        this.registerMainCommand(new CreateTrack());
+        this.registerMainCommand(new DeleteTrack());
+        this.registerMainCommand(new ListTracks());
     }
 
     /**
@@ -63,51 +99,75 @@ public class CommandManager {
      * @param args the arguments provided
      * @return if the command was successful (hint: it always is :> )
      */
-    public boolean onCommand(Sender sender, List<String> args) {
+    public boolean onCommand(Sender sender, String label, 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())));
+            sendCommandUsage(sender, label);
+            return true;
         }
+
+        Optional<MainCommand> o = mainCommands.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+
+        if (!o.isPresent()) {
+            sendCommandUsage(sender, label);
+            return true;
+        }
+
+        final MainCommand main = o.get();
+        if (!main.canUse(sender)) {
+            sendCommandUsage(sender, label);
+            return true;
+        }
+
+        if (main.getRequiredArgsLength() == 0) {
+            main.execute(plugin, sender, null, label);
+            return true;
+        }
+
+        if (args.size() == 1) {
+            main.sendUsage(sender, label);
+            return true;
+        }
+
+        main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
         return true;
 
     }
 
-    public void registerMainCommand(MainCommand command) {
+    /**
+     * Generic tab complete method to be called from the command executor object of the platform
+     * @param sender who is tab completing
+     * @param args the arguments provided so far
+     * @return a list of suggestions
+     */
+    public List<String> onTabComplete(Sender sender, List<String> args) {
+        final List<MainCommand> mains = mainCommands.stream().filter(m -> m.canUse(sender)).collect(Collectors.toList());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return mains.stream().map(MainCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+            }
+
+            return mains.stream().map(MainCommand::getName).map(String::toLowerCase).filter(s -> s.startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        Optional<MainCommand> o = mains.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+        if (!o.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        return o.get().onTabComplete(sender, args.subList(1, args.size()), plugin);
+    }
+
+    private void registerMainCommand(MainCommand command) {
         plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
         mainCommands.add(command);
     }
 
+    private void sendCommandUsage(Sender sender, String label) {
+        Message.INFO_BRIEF.send(sender, plugin.getVersion());
+
+        mainCommands.stream()
+                .filter(c -> c.canUse(sender))
+                .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/MainCommand.java

@@ -1,42 +1,66 @@
 package me.lucko.luckperms.commands;
 
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Message;
 
+import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
+@Getter
+@AllArgsConstructor
 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);
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label);
+    protected abstract List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin);
     public abstract List<? extends SubCommand> getSubCommands();
 
-    protected void sendUsage(Sender sender) {
+    protected void sendUsage(Sender sender, String label) {
+        if (getSubCommands().isEmpty()) {
+            Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
+            return;
+        }
+
         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);
+                s.sendUsage(sender, label);
             }
 
         } else {
-            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            Message.COMMAND_NO_PERMISSION.send(sender);
         }
     }
+
+    protected boolean canUse(Sender sender) {
+        return getSubCommands().stream().filter(sc -> sc.isAuthorized(sender)).count() != 0;
+    }
+
+    protected List<String> onAbstractTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        if (args.size() == 2) {
+            if (args.get(1).equalsIgnoreCase("")) {
+                return subs.stream().map(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+            }
+
+            return subs.stream().map(SubCommand::getName).map(String::toLowerCase)
+                    .filter(s -> s.toLowerCase().startsWith(args.get(1).toLowerCase())).collect(Collectors.toList());
+        }
+
+        Optional<SubCommand> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+        if (!o.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        return o.get().onTabComplete(sender, args.subList(2, args.size()), plugin);
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/SubCommand.java

@@ -1,34 +1,62 @@
 package me.lucko.luckperms.commands;
 
+import lombok.AllArgsConstructor;
 import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Permission;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Getter
+@AllArgsConstructor
 public abstract class SubCommand {
-
-    @Getter
     private final String name;
-
-    @Getter
     private final String description;
-
-    @Getter
     private final String usage;
+    private final Permission permission;
 
-    @Getter
-    private final String permission;
+    protected static List<String> getGroupTabComplete(List<String> args, LuckPermsPlugin plugin) {
+        return getTabComplete(new ArrayList<>(plugin.getGroupManager().getGroups().keySet()), args);
+    }
 
-    public SubCommand(String name, String description, String usage, String permission) {
-        this.name = name;
-        this.description = description;
-        this.usage = usage;
-        this.permission = permission;
+    protected static List<String> getTrackTabComplete(List<String> args, LuckPermsPlugin plugin) {
+        return getTabComplete(new ArrayList<>(plugin.getTrackManager().getTracks().keySet()), args);
+    }
+
+    private static List<String> getTabComplete(List<String> options, List<String> args) {
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return options;
+            }
+
+            return options.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return Collections.emptyList();
+    }
+
+    protected static List<String> getBoolTabComplete(List<String> args) {
+        if (args.size() == 2) {
+            return Arrays.asList("true", "false");
+        } else {
+            return Collections.emptyList();
+        }
     }
 
     public boolean isAuthorized(Sender sender) {
-        return sender.hasPermission(permission);
+        return permission.isAuthorized(sender);
     }
 
-    public void sendUsage(Sender sender) {
-        Util.sendPluginMessage(sender, "&e-> &d" + getUsage());
+    public void sendUsage(Sender sender, String label) {
+        Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
+    }
+
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
     }
 
     public abstract boolean isArgLengthInvalid(int argLength);

common/src/main/java/me/lucko/luckperms/commands/Util.java

@@ -1,14 +1,18 @@
 package me.lucko.luckperms.commands;
 
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.utils.DateUtil;
+
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
 public class Util {
 
+    private 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));
+        sender.sendMessage(color(Message.PREFIX + message));
     }
 
     public static String color(String s) {
@@ -19,8 +23,8 @@ public class Util {
         // 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) {
+        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]);
             }
@@ -41,28 +45,80 @@ public class Util {
         if (strings.isEmpty()) return "&6None";
 
         StringBuilder sb = new StringBuilder();
+        strings.forEach(s -> sb.append("&6").append(s).append("&7, "));
+        return sb.delete(sb.length() - 2, sb.length()).toString();
+    }
 
+    public static String listToArrowSep(List<String> strings, String highlight) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
         for (String s : strings) {
-            sb.append("&6").append(s).append("&7, ");
+            if (s.equalsIgnoreCase(highlight)) {
+                sb.append("&e").append(s).append("&7 ---> ");
+            } else {
+                sb.append("&6").append(s).append("&7 ---> ");
+            }
+        }
+        return sb.delete(sb.length() - 6, sb.length()).toString();
+    }
+
+    public static String listToArrowSep(List<String> strings, String highlightFirst, String highlightSecond, boolean reversed) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+        for (String s : strings) {
+            if (s.equalsIgnoreCase(highlightFirst)) {
+                sb.append("&e").append(s).append("&4").append(reversed ? " <--- " : " ---> ");
+            } else if (s.equalsIgnoreCase(highlightSecond)) {
+                sb.append("&e").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
+            } else {
+                sb.append("&6").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
+            }
+        }
+        return sb.delete(sb.length() - 6, sb.length()).toString();
+    }
+
+    public static String listToArrowSep(List<String> strings) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+        strings.forEach(s -> sb.append("&6").append(s).append("&e ---> "));
+        return sb.delete(sb.length() - 6, sb.length()).toString();
+    }
+
+    public static String permNodesToString(Map<String, Boolean> nodes) {
+        if (nodes.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+
+        for (Map.Entry<String, Boolean> e : nodes.entrySet()) {
+            if (e.getValue()) {
+                sb.append("&a").append(e.getKey()).append("&7, ");
+            } else {
+                sb.append("&c").append(e.getKey()).append("&7, ");
+            }
         }
 
         return sb.delete(sb.length() - 2, sb.length()).toString();
     }
 
-    public static String nodesToString(Map<String, Boolean> nodes) {
+    public static String tempNodesToString(Map<Map.Entry<String, Boolean>, Long> 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, ");
+        for (Map.Entry<Map.Entry<String, Boolean>, Long> e : nodes.entrySet()) {
+            if (e.getKey().getValue()) {
+                sb.append("&a").append(e.getKey().getKey()).append("&6 - expires in ")
+                        .append(DateUtil.formatDateDiff(e.getValue())).append("\n");
             } else {
-                sb.append("&c").append(node).append("&7, ");
+                sb.append("&c").append(e.getKey().getKey()).append("&6 - expires in ")
+                        .append(DateUtil.formatDateDiff(e.getValue())).append("\n");
             }
         }
 
-        return sb.delete(sb.length() - 2, sb.length()).toString();
+        return sb.toString();
     }
 
     public static UUID parseUuid(String s) {

common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java

@@ -0,0 +1,68 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.Collections;
+import java.util.List;
+
+public class CreateGroup extends MainCommand {
+    public CreateGroup() {
+        super("CreateGroup", "/%s creategroup <group>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() == 0) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.length() > 36) {
+            Message.GROUP_NAME_TOO_LONG.send(sender, groupName);
+            return;
+        }
+
+        if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
+            Message.GROUP_INVALID_ENTRY.send(sender);
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (success) {
+                Message.GROUP_ALREADY_EXISTS.send(sender);
+            } else {
+                plugin.getDatastore().createAndLoadGroup(groupName, success1 -> {
+                    if (!success1) {
+                        Message.CREATE_GROUP_ERROR.send(sender);
+                    } else {
+                        Message.CREATE_SUCCESS.send(sender, groupName);
+                        plugin.runUpdateTask();
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.CREATE_GROUP.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/CreateGroupCommand.java

@@ -1,51 +0,0 @@
-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<>();
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java

@@ -0,0 +1,81 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DeleteGroup extends MainCommand {
+    public DeleteGroup() {
+        super("DeleteGroup", "/%s deletegroup <group>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() == 0) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+            Message.DELETE_GROUP_ERROR_DEFAULT.send(sender);
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_DOES_NOT_EXIST.send(sender);
+            } else {
+
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Message.GROUP_LOAD_ERROR.send(sender);
+                } else {
+                    plugin.getDatastore().deleteGroup(group, success1 -> {
+                        if (!success1) {
+                            Message.DELETE_GROUP_ERROR.send(sender);
+                        } else {
+                            Message.DELETE_SUCCESS.send(sender, groupName);
+                            plugin.runUpdateTask();
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> groups = new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return groups;
+            }
+
+            return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.DELETE_GROUP.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroupCommand.java

@@ -1,63 +0,0 @@
-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<>();
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java

@@ -4,11 +4,12 @@ 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.constants.Message;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 public class GroupMainCommand extends MainCommand {
@@ -16,13 +17,26 @@ public class GroupMainCommand extends MainCommand {
     private final List<GroupSubCommand> subCommands = new ArrayList<>();
 
     public GroupMainCommand() {
-        super("Group", "/perms group <group>", 2);
+        super("Group", "/%s group <group>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        if (args.size() <= 1) {
-            sendUsage(sender);
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < 2) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        Optional<GroupSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+
+        if (!o.isPresent()) {
+            Message.COMMAND_NOT_RECOGNISED.send(sender);
+            return;
+        }
+
+        final GroupSubCommand sub = o.get();
+        if (!sub.isAuthorized(sender)) {
+            Message.COMMAND_NO_PERMISSION.send(sender);
             return;
         }
 
@@ -31,52 +45,43 @@ public class GroupMainCommand extends MainCommand {
             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.");
+        if (sub.isArgLengthInvalid(strippedArgs.size())) {
+            sub.sendUsage(sender, label);
             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 -> {
+        final String groupName = args.get(0).toLowerCase();
+        plugin.getDatastore().loadGroup(groupName, success -> {
             if (!success) {
-                Util.sendPluginMessage(sender, "&eGroup could not be found.");
+                Message.GROUP_NOT_FOUND.send(sender);
                 return;
             }
 
-            Group group = plugin.getGroupManager().getGroup(g);
+            Group group = plugin.getGroupManager().getGroup(groupName);
             if (group == null) {
-                Util.sendPluginMessage(sender, "&eGroup could not be found.");
+                Message.GROUP_NOT_FOUND.send(sender);
                 return;
             }
 
-            if (sub.isArgLengthInvalid(strippedArgs.size())) {
-                sub.sendUsage(sender);
-                return;
-            }
-
-            sub.execute(plugin, sender, group, strippedArgs);
+            sub.execute(plugin, sender, group, strippedArgs, label);
         });
     }
 
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> groups = new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return groups;
+            }
+
+            return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return onAbstractTabComplete(sender, args, plugin);
+    }
+
     @Override
     public List<? extends SubCommand> getSubCommands() {
         return subCommands;
@@ -86,18 +91,4 @@ public class GroupMainCommand extends MainCommand {
         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!");
-        }
-    }
 }

common/src/main/java/me/lucko/luckperms/commands/group/GroupSubCommand.java

@@ -3,24 +3,25 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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) {
+    protected GroupSubCommand(String name, String description, String usage, Permission permission) {
         super(name, description, usage, permission);
     }
 
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args);
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label);
 
     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)");
+                Message.GROUP_SAVE_SUCCESS.send(sender);
             } else {
-                Util.sendPluginMessage(sender, "There was an error whilst saving the group.");
+                Message.GROUP_SAVE_ERROR.send(sender);
             }
 
             plugin.runUpdateTask();

common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java

@@ -0,0 +1,45 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ListGroups extends MainCommand {
+    public ListGroups() {
+        super("ListGroups", "/%s listgroups", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        plugin.getDatastore().loadAllGroups(success -> {
+            if (!success) {
+                Message.GROUPS_LOAD_ERROR.send(sender);
+            } else {
+                Message.GROUPS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getGroups().keySet())));
+            }
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.LIST_GROUPS.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/ListGroupsCommand.java

@@ -1,37 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java

@@ -2,28 +2,28 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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");
+public class GroupClear extends GroupSubCommand {
+    public GroupClear() {
+        super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         group.clearNodes();
-        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a's permissions were cleared.");
+        Message.CLEAR_SUCCESS.send(sender, group.getName());
 
         saveGroup(group, sender, plugin);
     }
 
     @Override
     public boolean isArgLengthInvalid(int argLength) {
-        return true;
+        return false;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java

@@ -4,20 +4,21 @@ 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.constants.Permission;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
-public class GroupHasPermCommand extends GroupSubCommand {
-    public GroupHasPermCommand() {
+public class GroupHasPerm extends GroupSubCommand {
+    public GroupHasPerm() {
         super("haspermission", "Checks to see if a group has a certain permission node",
-                "/perms group <group> haspermission <node> [server]", "luckperms.group.haspermission");
+                "/%s group <group> haspermission <node> [server]", Permission.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)));
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        if (args.size() == 2) {
+            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1).toLowerCase()));
         } else {
             Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
         }
@@ -25,6 +26,6 @@ public class GroupHasPermCommand extends GroupSubCommand {
 
     @Override
     public boolean isArgLengthInvalid(int argLength) {
-        return argLength == 0;
+        return argLength != 1 && argLength != 2;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java

@@ -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.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupInfo extends GroupSubCommand {
+    public GroupInfo() {
+        super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        Message.GROUP_INFO.send(sender, group.getName(), group.getPermanentNodes().keySet().size(),
+                group.getTemporaryNodes().keySet().size(), label, group.getName());
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfoCommand.java

@@ -1,31 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java

@@ -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.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupInheritsPerm extends GroupSubCommand {
+    public GroupInheritsPerm() {
+        super("inheritspermission", "Checks to see if a group inherits a certain permission node",
+                "/%s group <group> inheritspermission <node> [server]", Permission.GROUP_INHERITSPERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        if (args.size() == 2) {
+            Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1).toLowerCase()));
+        } else {
+            Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java

@@ -4,20 +4,22 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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");
+public class GroupListNodes extends GroupSubCommand {
+    public GroupListNodes() {
+        super("listnodes", "Lists the permission nodes the group has", "/%s group <group> listnodes",
+                Permission.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())));
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermanentNodes()));
+        Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodes()));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java

@@ -0,0 +1,59 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupSetInherit extends GroupSubCommand {
+    public GroupSetInherit() {
+        super("setinherit", "Sets another group for this group to inherit permissions from",
+                "/%s group <group> setinherit <group> [server]", Permission.GROUP_SETINHERIT);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_LOAD_ERROR.send(sender);
+            } else {
+                try {
+                    if (args.size() == 2) {
+                        final String server = args.get(1).toLowerCase();
+                        group.setPermission("group." + groupName, true, server);
+                        Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                    } else {
+                        group.setPermission("group." + groupName, true);
+                        Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                    }
+
+                    saveGroup(group, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Message.GROUP_ALREADY_INHERITS.send(sender, group.getName(), groupName);
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInheritCommand.java

@@ -1,50 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java

@@ -0,0 +1,67 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class GroupSetPermission extends GroupSubCommand {
+    public GroupSetPermission() {
+        super("set", "Sets a permission for a group", "/%s group <group> set <node> <true|false> [server]",
+                Permission.GROUP_SETPERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String node = args.get(0);
+        String bool = args.get(1).toLowerCase();
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.GROUP_USE_INHERIT.send(sender);
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        try {
+            if (args.size() == 3) {
+                final String server = args.get(2).toLowerCase();
+                group.setPermission(node, b, server);
+                Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
+            } else {
+                group.setPermission(node, b);
+                Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectAlreadyHasException e) {
+            Message.ALREADY_HASPERMISSION.send(sender, group.getName());
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getBoolTabComplete(args);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 2 && argLength != 3;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermissionCommand.java

@@ -1,60 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java

@@ -0,0 +1,74 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+
+public class GroupSetTempInherit extends GroupSubCommand {
+    public GroupSetTempInherit() {
+        super("settempinherit", "Sets another group for this group to inherit permissions from temporarily",
+                "/%s group <group> settempinherit <group> <duration> [server]", Permission.GROUP_SET_TEMP_INHERIT);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        long duration;
+        try {
+            duration = DateUtil.parseDateDiff(args.get(1), true);
+        } catch (DateUtil.IllegalDateException e) {
+            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
+            return;
+        }
+
+        if (DateUtil.shouldExpire(duration)) {
+            Message.PAST_DATE_ERROR.send(sender);
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_LOAD_ERROR.send(sender);
+            } else {
+                try {
+                    if (args.size() == 3) {
+                        final String server = args.get(2).toLowerCase();
+                        group.setPermission("group." + groupName, true, server, duration);
+                        Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server,
+                                DateUtil.formatDateDiff(duration));
+                    } else {
+                        group.setPermission("group." + groupName, true, duration);
+                        Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName, DateUtil.formatDateDiff(duration));
+                    }
+
+                    saveGroup(group, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Message.GROUP_ALREADY_TEMP_INHERITS.send(sender, group.getName(), groupName);
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 2 && argLength != 3;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java

@@ -0,0 +1,81 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.DateUtil;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class GroupSetTempPermission extends GroupSubCommand {
+    public GroupSetTempPermission() {
+        super("settemp", "Sets a temporary permission for a group", "/%s group <group> settemp <node> <true|false> <duration> [server]",
+                Permission.GROUP_SET_TEMP_PERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String node = args.get(0);
+        String bool = args.get(1).toLowerCase();
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.GROUP_USE_INHERIT.send(sender);
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        long duration;
+        try {
+            duration = DateUtil.parseDateDiff(args.get(2), true);
+        } catch (DateUtil.IllegalDateException e) {
+            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
+            return;
+        }
+
+        if (DateUtil.shouldExpire(duration)) {
+            Message.PAST_DATE_ERROR.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 4) {
+                final String server = args.get(3).toLowerCase();
+                group.setPermission(node, b, server, duration);
+                Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server, DateUtil.formatDateDiff(duration));
+            } else {
+                group.setPermission(node, b, duration);
+                Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectAlreadyHasException e) {
+            Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, group.getName());
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getBoolTabComplete(args);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 3 && argLength != 4;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java

@@ -0,0 +1,37 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class GroupShowTracks extends GroupSubCommand {
+    public GroupShowTracks() {
+        super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks", Permission.GROUP_SHOWTRACKS);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        plugin.getDatastore().loadAllTracks(success -> {
+            if (!success) {
+                Message.TRACKS_LOAD_ERROR.send(sender);
+                return;
+            }
+
+            Message.TRACKS_LIST.send(sender, Util.listToCommaSep(
+                    plugin.getTrackManager().getApplicableTracks(group.getName()).stream().map(Track::getName).collect(Collectors.toList())));
+        });
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java

@@ -0,0 +1,54 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class GroupUnSetPermission extends GroupSubCommand {
+    public GroupUnSetPermission() {
+        super("unset", "Unsets a permission for a group",
+                "/%s group <group> unset <node> [server]", Permission.GROUP_UNSETPERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String node = args.get(0);
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.GROUP_USE_UNINHERIT.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                group.unsetPermission(node, server);
+                Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+            } else {
+                group.unsetPermission(node);
+                Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName());
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermissionCommand.java

@@ -1,52 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java

@@ -0,0 +1,53 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupUnsetInherit extends GroupSubCommand {
+    public GroupUnsetInherit() {
+        super("unsetinherit", "Unsets another group for this group to inherit permissions from",
+                "/%s group <group> unsetinherit <group> [server]", Permission.GROUP_UNSETINHERIT);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                group.unsetPermission("group." + groupName, server);
+                Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+            } else {
+                group.unsetPermission("group." + groupName);
+                Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.GROUP_DOES_NOT_INHERIT.send(sender, group.getName(), groupName);
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInheritCommand.java

@@ -1,42 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java

@@ -0,0 +1,53 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupUnsetTempInherit extends GroupSubCommand {
+    public GroupUnsetTempInherit() {
+        super("unsettempinherit", "Unsets another group for this group to inherit permissions from",
+                "/%s group <group> unsettempinherit <group> [server]", Permission.GROUP_UNSET_TEMP_INHERIT);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                group.unsetPermission("group." + groupName, server, true);
+                Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+            } else {
+                group.unsetPermission("group." + groupName, true);
+                Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.GROUP_DOES_NOT_TEMP_INHERIT.send(sender, group.getName(), groupName);
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java

@@ -0,0 +1,54 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class GroupUnsetTempPermission extends GroupSubCommand {
+    public GroupUnsetTempPermission() {
+        super("unsettemp", "Unsets a temporary permission for a group",
+                "/%s group <group> unsettemp <node> [server]", Permission.GROUP_UNSET_TEMP_PERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String node = args.get(0);
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.GROUP_USE_UNINHERIT.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                group.unsetPermission(node, server);
+                Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server, true);
+            } else {
+                group.unsetPermission(node, true);
+                Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName());
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/misc/DebugCommand.java

@@ -4,31 +4,36 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public class DebugCommand extends MainCommand {
     public DebugCommand() {
-        super("Debug", "/perms debug", 0);
+        super("Debug", "/%s 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;
-        }
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        Message.DEBUG.send(sender, plugin.getPlayerCount(), plugin.getUserManager().getUsers().size(),
+                plugin.getGroupManager().getGroups().size(), plugin.getTrackManager().getTracks().size()
+        );
+    }
 
-        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
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
     }
 
     @Override
     public List<? extends SubCommand> getSubCommands() {
-        return new ArrayList<>();
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.DEBUG.isAuthorized(sender);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java

@@ -4,30 +4,34 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public class InfoCommand extends MainCommand {
     public InfoCommand() {
-        super("Info", "/perms info", 0);
+        super("Info", "/%s 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;
-        }
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        Message.INFO.send(sender, plugin.getVersion(), plugin.getDatastore().getName());
+    }
 
-        Util.sendPluginMessage(sender, "&6Running &bLuckPerms " + plugin.getVersion() + "&6.");
-        Util.sendPluginMessage(sender, "&eAuthor: &6Luck");
-        Util.sendPluginMessage(sender, "&eStorage Method: &6" + plugin.getDatastore().getName());
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
     }
 
     @Override
     public List<? extends SubCommand> getSubCommands() {
-        return new ArrayList<>();
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.INFO.isAuthorized(sender);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/misc/SyncCommand.java

@@ -4,29 +4,35 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public class SyncCommand extends MainCommand {
     public SyncCommand() {
-        super("Sync", "/perms sync", 0);
+        super("Sync", "/%s 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.");
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        Message.UPDATE_TASK_RUN.send(sender);
         plugin.runUpdateTask();
     }
 
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
     @Override
     public List<? extends SubCommand> getSubCommands() {
-        return new ArrayList<>();
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.SYNC.isAuthorized(sender);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java

@@ -0,0 +1,68 @@
+package me.lucko.luckperms.commands.track;
+
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.Collections;
+import java.util.List;
+
+public class CreateTrack extends MainCommand {
+    public CreateTrack() {
+        super("CreateTrack", "/%s createtrack <track>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() == 0) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        String trackName = args.get(0).toLowerCase();
+
+        if (trackName.length() > 36) {
+            Message.TRACK_NAME_TOO_LONG.send(sender, trackName);
+            return;
+        }
+
+        if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
+            Message.TRACK_INVALID_ENTRY.send(sender);
+            return;
+        }
+
+        plugin.getDatastore().loadTrack(trackName, success -> {
+            if (success) {
+                Message.TRACK_ALREADY_EXISTS.send(sender);
+            } else {
+                plugin.getDatastore().createAndLoadTrack(trackName, success1 -> {
+                    if (!success1) {
+                        Message.CREATE_TRACK_ERROR.send(sender);
+                    } else {
+                        Message.CREATE_SUCCESS.send(sender, trackName);
+                        plugin.runUpdateTask();
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.CREATE_TRACK.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java

@@ -0,0 +1,76 @@
+package me.lucko.luckperms.commands.track;
+
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DeleteTrack extends MainCommand {
+    public DeleteTrack() {
+        super("DeleteTrack", "/%s deletetrack <track>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() == 0) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        String trackName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadTrack(trackName, success -> {
+            if (!success) {
+                Message.TRACK_DOES_NOT_EXIST.send(sender);
+            } else {
+
+                Track track = plugin.getTrackManager().getTrack(trackName);
+                if (track == null) {
+                    Message.TRACK_LOAD_ERROR.send(sender);
+                } else {
+                    plugin.getDatastore().deleteTrack(track, success1 -> {
+                        if (!success1) {
+                            Message.DELETE_TRACK_ERROR.send(sender);
+                        } else {
+                            Message.DELETE_SUCCESS.send(sender, trackName);
+                            plugin.runUpdateTask();
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> tracks = new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return tracks;
+            }
+
+            return tracks.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.DELETE_TRACK.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java

@@ -0,0 +1,45 @@
+package me.lucko.luckperms.commands.track;
+
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ListTracks extends MainCommand {
+    public ListTracks() {
+        super("ListTracks", "/%s listtracks", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        plugin.getDatastore().loadAllTracks(success -> {
+            if (!success) {
+                Message.TRACKS_LOAD_ERROR.send(sender);
+            } else {
+                Message.TRACKS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getTrackManager().getTracks().keySet())));
+            }
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean canUse(Sender sender) {
+        return Permission.LIST_TRACKS.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java

@@ -0,0 +1,94 @@
+package me.lucko.luckperms.commands.track;
+
+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.constants.Message;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class TrackMainCommand extends MainCommand {
+
+    private final List<TrackSubCommand> subCommands = new ArrayList<>();
+
+    public TrackMainCommand() {
+        super("Track", "/%s track <track>", 2);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < 2) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        Optional<TrackSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+
+        if (!o.isPresent()) {
+            Message.COMMAND_NOT_RECOGNISED.send(sender);
+            return;
+        }
+
+        final TrackSubCommand sub = o.get();
+        if (!sub.isAuthorized(sender)) {
+            Message.COMMAND_NO_PERMISSION.send(sender);
+            return;
+        }
+
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        if (sub.isArgLengthInvalid(strippedArgs.size())) {
+            sub.sendUsage(sender, label);
+            return;
+        }
+
+        final String trackName = args.get(0).toLowerCase();
+        plugin.getDatastore().loadTrack(trackName, success -> {
+            if (!success) {
+                Message.TRACK_NOT_FOUND.send(sender);
+                return;
+            }
+
+            Track track = plugin.getTrackManager().getTrack(trackName);
+            if (track == null) {
+                Message.TRACK_NOT_FOUND.send(sender);
+                return;
+            }
+
+            sub.execute(plugin, sender, track, strippedArgs, label);
+        });
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> tracks = new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return tracks;
+            }
+
+            return tracks.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return onAbstractTabComplete(sender, args, plugin);
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return subCommands;
+    }
+
+    public void registerSubCommand(TrackSubCommand subCommand) {
+        subCommands.add(subCommand);
+    }
+
+}

common/src/main/java/me/lucko/luckperms/commands/track/TrackSubCommand.java

@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.track;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+
+public abstract class TrackSubCommand extends SubCommand {
+    public TrackSubCommand(String name, String description, String usage, Permission permission) {
+        super(name, description, usage, permission);
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label);
+
+    protected void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveTrack(track, success -> {
+            if (success) {
+                Message.TRACK_SAVE_SUCCESS.send(sender);
+            } else {
+                Message.TRACK_SAVE_ERROR.send(sender);
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java

@@ -0,0 +1,55 @@
+package me.lucko.luckperms.commands.track.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+
+public class TrackAppend extends TrackSubCommand {
+    public TrackAppend() {
+        super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>", Permission.TRACK_APPEND);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_DOES_NOT_EXIST.send(sender);
+            } else {
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Message.GROUP_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                try {
+                    track.appendGroup(group);
+                    Message.TRACK_APPEND_SUCCESS.send(sender, group.getName(), track.getName());
+                    Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), group.getName()));
+                    saveTrack(track, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Message.TRACK_ALREADY_CONTAINS.send(sender, track.getName(), group.getName());
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java

@@ -0,0 +1,28 @@
+package me.lucko.luckperms.commands.track.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+
+public class TrackClear extends TrackSubCommand {
+    public TrackClear() {
+        super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+        track.clearGroups();
+        Message.TRACK_CLEAR.send(sender, track.getName());
+        saveTrack(track, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java

@@ -0,0 +1,27 @@
+package me.lucko.luckperms.commands.track.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+
+public class TrackInfo extends TrackSubCommand {
+    public TrackInfo() {
+        super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+        Message.TRACK_INFO.send(sender, track.getName(), Util.listToArrowSep(track.getGroups()));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java

@@ -0,0 +1,65 @@
+package me.lucko.luckperms.commands.track.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+
+public class TrackInsert extends TrackSubCommand {
+    public TrackInsert() {
+        super("insert", "Inserts a group at a given position along the track",
+                "/%s track <track> insert <group> <position>", Permission.TRACK_INSERT);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+        int pos;
+        try {
+            pos = Integer.parseInt(args.get(1));
+        } catch (NumberFormatException e) {
+            Message.TRACK_INSERT_ERROR_NUMBER.send(sender, args.get(1));
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_DOES_NOT_EXIST.send(sender);
+            } else {
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Message.GROUP_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                try {
+                    track.insertGroup(group, pos - 1);
+                    Message.TRACK_INSERT_SUCCESS.send(sender, group.getName(), track.getName(), pos);
+                    Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), group.getName()));
+                    saveTrack(track, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Message.TRACK_ALREADY_CONTAINS.send(sender, track.getName(), group.getName());
+                } catch (IndexOutOfBoundsException e) {
+                    Message.TRACK_INSERT_ERROR_INVALID_POS.send(sender, pos);
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java

@@ -0,0 +1,39 @@
+package me.lucko.luckperms.commands.track.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.track.TrackSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.tracks.Track;
+
+import java.util.List;
+
+public class TrackRemove extends TrackSubCommand {
+    public TrackRemove() {
+        super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+        try {
+            track.removeGroup(groupName);
+            Message.TRACK_REMOVE_SUCCESS.send(sender, groupName, track.getName());
+            saveTrack(track, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), groupName);
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java

@@ -5,49 +5,40 @@ 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.constants.Message;
 import me.lucko.luckperms.users.User;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
-public class UserMainCommand extends MainCommand{
+public class UserMainCommand extends MainCommand {
 
     private final List<UserSubCommand> subCommands = new ArrayList<>();
 
     public UserMainCommand() {
-        super("User", "/perms user <user>", 2);
+        super("User", "/%s user <user>", 2);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
-        if (args.size() <= 1) {
-            sendUsage(sender);
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < 2) {
+            sendUsage(sender, label);
             return;
         }
 
-        // The first argument is the name of the user, the second is the command
-        String command = args.get(1);
-        UserSubCommand tempSub = null;
+        Optional<UserSubCommand> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
 
-        // 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.");
+        if (!o.isPresent()) {
+            Message.COMMAND_NOT_RECOGNISED.send(sender);
             return;
         }
 
+        final UserSubCommand sub = o.get();
         if (!sub.isAuthorized(sender)) {
-            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            Message.COMMAND_NO_PERMISSION.send(sender);
             return;
         }
 
@@ -57,50 +48,63 @@ public class UserMainCommand extends MainCommand{
             strippedArgs.addAll(args.subList(2, args.size()));
         }
 
-        String user = args.get(0);
+        if (sub.isArgLengthInvalid(strippedArgs.size())) {
+            sub.sendUsage(sender, label);
+            return;
+        }
 
+        final String user = args.get(0);
         UUID u = Util.parseUuid(user);
         if (u != null) {
-            runSub(plugin, sender, u, sub, strippedArgs);
+            runSub(plugin, sender, u, sub, strippedArgs, label);
             return;
         }
 
         if (user.length() <= 16) {
-            Util.sendPluginMessage(sender, "&7(Attempting UUID lookup, since you specified a user)");
+            Message.USER_ATTEMPTING_LOOKUP.send(sender);
 
             plugin.getDatastore().getUUID(user, uuid -> {
                 if (uuid == null) {
-                    Util.sendPluginMessage(sender, "&eUser could not be found.");
+                    Message.USER_NOT_FOUND.send(sender);
                     return;
                 }
-                runSub(plugin, sender, uuid, sub, strippedArgs);
+                runSub(plugin, sender, uuid, sub, strippedArgs, label);
             });
             return;
         }
 
-        Util.sendPluginMessage(sender, "&d" + user + "&c is not a valid username/uuid.");
+        Message.USER_INVALID_ENTRY.send(sender, user);
     }
 
-    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List<String> strippedArgs) {
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> onlinePlayers = plugin.getPlayerList();
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return onlinePlayers;
+            }
+
+            return onlinePlayers.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return onAbstractTabComplete(sender, args, plugin);
+    }
+
+    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List<String> strippedArgs, String label) {
         plugin.getDatastore().loadUser(uuid, success -> {
             if (!success) {
-                Util.sendPluginMessage(sender, "&eUser could not be found.");
+                Message.USER_NOT_FOUND.send(sender);
                 return;
             }
 
-            User user1 = plugin.getUserManager().getUser(uuid);
-
-            if (user1 == null) {
-                Util.sendPluginMessage(sender, "&eUser could not be found.");
+            User user = plugin.getUserManager().getUser(uuid);
+            if (user == null) {
+                Message.USER_NOT_FOUND.send(sender);
             }
 
-            if (command.isArgLengthInvalid(strippedArgs.size())) {
-                command.sendUsage(sender);
-                return;
-            }
-
-            command.execute(plugin, sender, user1, strippedArgs);
-            plugin.getUserManager().cleanupUser(user1);
+            command.execute(plugin, sender, user, strippedArgs, label);
+            plugin.getUserManager().cleanupUser(user);
         });
     }
 

common/src/main/java/me/lucko/luckperms/commands/user/UserSubCommand.java

@@ -3,26 +3,27 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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) {
+    protected UserSubCommand(String name, String description, String usage, Permission permission) {
         super(name, description, usage, permission);
     }
 
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args);
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label);
 
     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)");
+                Message.USER_SAVE_SUCCESS.send(sender);
             } else {
-                Util.sendPluginMessage(sender, "There was an error whilst saving the user.");
+                Message.USER_SAVE_ERROR.send(sender);
             }
         });
     }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java

@@ -0,0 +1,65 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserAddGroup extends UserSubCommand {
+    public UserAddGroup() {
+        super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server]", Permission.USER_ADDGROUP);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_DOES_NOT_EXIST.send(sender);
+            } else {
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Message.GROUP_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                try {
+                    if (args.size() == 2) {
+                        final String server = args.get(1).toLowerCase();
+                        user.addGroup(group, server);
+                        Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                    } else {
+                        user.addGroup(group);
+                        Message.USER_ADDGROUP_SUCCESS.send(sender, user.getName(), groupName);
+                    }
+
+                    saveUser(user, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Message.USER_ALREADY_MEMBER_OF.send(sender, user.getName(), group.getName());
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroupCommand.java

@@ -1,49 +0,0 @@
-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);
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java

@@ -0,0 +1,81 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+
+public class UserAddTempGroup extends UserSubCommand {
+    public UserAddTempGroup() {
+        super("addtempgroup", "Adds the user to a group temporarily", "/%s user <user> addtempgroup <group> <duration> [server]",
+                Permission.USER_ADDTEMPGROUP);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        long duration;
+        try {
+            duration = DateUtil.parseDateDiff(args.get(1), true);
+        } catch (DateUtil.IllegalDateException e) {
+            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
+            return;
+        }
+
+        if (DateUtil.shouldExpire(duration)) {
+            Message.PAST_DATE_ERROR.send(sender);
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Message.GROUP_DOES_NOT_EXIST.send(sender);
+            } else {
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Message.GROUP_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                try {
+                    if (args.size() == 3) {
+                        final String server = args.get(2).toLowerCase();
+                        user.addGroup(group, server, duration);
+                        Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
+                                DateUtil.formatDateDiff(duration));
+                    } else {
+                        user.addGroup(group, duration);
+                        Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), groupName, DateUtil.formatDateDiff(duration));
+                    }
+
+                    saveUser(user, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, user.getName(), group.getName());
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 2 && argLength != 3);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserClear.java

@@ -2,23 +2,23 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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");
+public class UserClear extends UserSubCommand {
+    public UserClear() {
+        super("clear", "Clears a users permissions and groups", "/%s user <user> clear", Permission.USER_CLEAR);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         user.clearNodes();
-        user.getNodes().put(plugin.getConfiguration().getDefaultGroupNode(), true);
-        Util.sendPluginMessage(sender, "&b" + user.getName() + "&a's permissions were cleared.");
+        plugin.getUserManager().giveDefaults(user);
+        Message.CLEAR_SUCCESS.send(sender, user.getName());
 
         saveUser(user, sender, plugin);
     }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserDemote.java

@@ -0,0 +1,91 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserDemote extends UserSubCommand {
+    public UserDemote() {
+        super("demote", "Demotes a user along a track", "/%s user <user> demote <track>", Permission.USER_DEMOTE);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        final String trackName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadTrack(trackName, success -> {
+            if (!success) {
+                Message.TRACK_DOES_NOT_EXIST.send(sender);
+            } else {
+                Track track = plugin.getTrackManager().getTrack(trackName);
+                if (track == null) {
+                    Message.TRACK_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                if (track.getSize() <= 1) {
+                    Message.TRACK_EMPTY.send(sender);
+                    return;
+                }
+
+                final String old = user.getPrimaryGroup();
+                final String previous;
+                try {
+                    previous = track.getPrevious(old);
+                } catch (ObjectLacksException e) {
+                    Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), old);
+                    Message.USER_DEMOTE_ERROR_NOT_CONTAIN_GROUP.send(sender);
+                    return;
+                }
+
+                if (previous == null) {
+                    Message.USER_DEMOTE_ERROR_ENDOFTRACK.send(sender, track.getName());
+                    return;
+                }
+
+                plugin.getDatastore().loadGroup(previous, success1 -> {
+                    if (!success1) {
+                        Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
+                    } else {
+                        Group previousGroup = plugin.getGroupManager().getGroup(previous);
+                        if (previousGroup == null) {
+                            Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
+                            return;
+                        }
+
+                        try {
+                            user.unsetPermission("group." + old);
+                            user.addGroup(previousGroup);
+                            user.setPrimaryGroup(previousGroup.getName());
+                        } catch (ObjectLacksException | ObjectAlreadyHasException ignored) {}
+
+                        Message.USER_DEMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, previousGroup.getName());
+                        Message.USER_DEMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, previousGroup.getName(), previousGroup.getName());
+                        Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), previousGroup.getName(), old, true));
+                        saveUser(user, sender, plugin);
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getTrackTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserGetUUID.java

@@ -2,20 +2,21 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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");
+public class UserGetUUID extends UserSubCommand {
+    public UserGetUUID() {
+        super("getuuid", "Get the UUID of a user", "/%s user <user> getuuid", Permission.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.");
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        Message.USER_GETUUID.send(sender, user.getName(), user.getUuid().toString());
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserHasPerm.java

@@ -4,18 +4,19 @@ 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.constants.Permission;
 import me.lucko.luckperms.users.User;
 
 import java.util.List;
 
-public class UserHasPermCommand extends UserSubCommand {
-    public UserHasPermCommand() {
+public class UserHasPerm extends UserSubCommand {
+    public UserHasPerm() {
         super("haspermission", "Checks to see if a user has a certain permission node",
-                "/perms user <user> haspermission <node> [server]", "luckperms.user.haspermission");
+                "/%s user <user> haspermission <node> [server]", Permission.USER_HASPERMISSION);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         if (args.size() >= 2) {
             Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1)));
         } else {
@@ -25,6 +26,6 @@ public class UserHasPermCommand extends UserSubCommand {
 
     @Override
     public boolean isArgLengthInvalid(int argLength) {
-        return argLength == 0;
+        return argLength != 1 && argLength != 2;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfo.java

@@ -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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserInfo extends UserSubCommand {
+    public UserInfo() {
+        super("info", "Gives info about the user", "/%s user <user> info", Permission.USER_INFO);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        Message.USER_INFO.send(sender, user.getName(), user.getUuid(), plugin.getPlayerStatus(user.getUuid()),
+                Util.listToCommaSep(user.getGroupNames()), user.getPrimaryGroup(),
+                user.getPermanentNodes().keySet().size(), user.getTemporaryNodes().keySet().size(), label, user.getName()
+        );
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfoCommand.java

@@ -1,34 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInheritsPerm.java

@@ -0,0 +1,31 @@
+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.constants.Permission;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserInheritsPerm extends UserSubCommand {
+    public UserInheritsPerm() {
+        super("inheritspermission", "Checks to see if a user inherits a certain permission node",
+                "/%s user <user> inheritspermission <node> [server]", Permission.USER_INHERITSPERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        if (args.size() >= 2) {
+            Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1)));
+        } else {
+            Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true));
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserListNodes.java

@@ -4,20 +4,21 @@ 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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
 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");
+public class UserListNodes extends UserSubCommand {
+    public UserListNodes() {
+        super("listnodes", "Lists the permission nodes the user has", "/%s user <user> listnodes", Permission.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())));
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        Message.LISTNODES.send(sender, user.getName(), Util.permNodesToString(user.getPermanentNodes()));
+        Message.LISTNODES_TEMP.send(sender, user.getName(), Util.tempNodesToString(user.getTemporaryNodes()));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserPromote.java

@@ -0,0 +1,91 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserPromote extends UserSubCommand {
+    public UserPromote() {
+        super("promote", "Promotes the user along a track", "/%s user <user> promote <track>", Permission.USER_PROMOTE);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        final String trackName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadTrack(trackName, success -> {
+            if (!success) {
+                Message.TRACK_DOES_NOT_EXIST.send(sender);
+            } else {
+                Track track = plugin.getTrackManager().getTrack(trackName);
+                if (track == null) {
+                    Message.TRACK_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                if (track.getSize() <= 1) {
+                    Message.TRACK_EMPTY.send(sender);
+                    return;
+                }
+
+                final String old = user.getPrimaryGroup();
+                final String next;
+                try {
+                    next = track.getNext(old);
+                } catch (ObjectLacksException e) {
+                    Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), old);
+                    Message.USER_PROMOTE_ERROR_NOT_CONTAIN_GROUP.send(sender);
+                    return;
+                }
+
+                if (next == null) {
+                    Message.USER_PROMOTE_ERROR_ENDOFTRACK.send(sender, track.getName());
+                    return;
+                }
+
+                plugin.getDatastore().loadGroup(next, success1 -> {
+                    if (!success1) {
+                        Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
+                    } else {
+                        Group nextGroup = plugin.getGroupManager().getGroup(next);
+                        if (nextGroup == null) {
+                            Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
+                            return;
+                        }
+
+                        try {
+                            user.unsetPermission("group." + old);
+                            user.addGroup(nextGroup);
+                            user.setPrimaryGroup(nextGroup.getName());
+                        } catch (ObjectLacksException | ObjectAlreadyHasException ignored) {}
+
+                        Message.USER_PROMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, nextGroup.getName());
+                        Message.USER_PROMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, nextGroup.getName(), nextGroup.getName());
+                        Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), old, nextGroup.getName(), false));
+                        saveUser(user, sender, plugin);
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getTrackTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroup.java

@@ -0,0 +1,58 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserRemoveGroup extends UserSubCommand {
+    public UserRemoveGroup() {
+        super("removegroup", "Removes a user from a group", "/%s user <user> removegroup <group> [server]", Permission.USER_REMOVEGROUP);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if ((args.size() == 1 || (args.size() == 2 && args.get(1).equalsIgnoreCase("global")))
+                && user.getPrimaryGroup().equalsIgnoreCase(groupName)) {
+            Message.USER_REMOVEGROUP_ERROR_PRIMARY.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                user.unsetPermission("group." + groupName, server);
+                Message.USER_REMOVEGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+            } else {
+                user.unsetPermission("group." + groupName);
+                Message.USER_REMOVEGROUP_SUCCESS.send(sender, user.getName(), groupName);
+            }
+
+            saveUser(user, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.USER_NOT_MEMBER_OF.send(sender, user.getName(), groupName);
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroupCommand.java

@@ -1,49 +0,0 @@
-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);
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempGroup.java

@@ -0,0 +1,52 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserRemoveTempGroup extends UserSubCommand {
+    public UserRemoveTempGroup() {
+        super("removetempgroup", "Removes a user from a temporary group", "/%s user <user> removetempgroup <group> [server]", Permission.USER_REMOVETEMPGROUP);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.contains("/") || groupName.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                user.unsetPermission("group." + groupName, server, true);
+                Message.USER_REMOVETEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+            } else {
+                user.unsetPermission("group." + groupName, true);
+                Message.USER_REMOVETEMPGROUP_SUCCESS.send(sender, user.getName(), groupName);
+            }
+
+            saveUser(user, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.USER_NOT_TEMP_MEMBER_OF.send(sender, user.getName(), groupName);
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermission.java

@@ -0,0 +1,67 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class UserSetPermission extends UserSubCommand {
+    public UserSetPermission() {
+        super("set", "Sets a permission for a user",
+                "/%s user <user> set <node> <true|false> [server]", Permission.USER_SETPERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String node = args.get(0);
+        String bool = args.get(1).toLowerCase();
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.USER_USE_ADDGROUP.send(sender);
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        try {
+            if (args.size() == 3) {
+                final String server = args.get(2).toLowerCase();
+                user.setPermission(node, b, server);
+                Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server);
+            } else {
+                user.setPermission(node, b);
+                Message.SETPERMISSION_SUCCESS.send(sender, node, bool, user.getName());
+            }
+
+            saveUser(user, sender, plugin);
+        } catch (ObjectAlreadyHasException e) {
+            Message.ALREADY_HASPERMISSION.send(sender, user.getName());
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getBoolTabComplete(args);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 2 && argLength != 3;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermissionCommand.java

@@ -1,60 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPrimaryGroup.java

@@ -0,0 +1,52 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserSetPrimaryGroup extends UserSubCommand {
+    public UserSetPrimaryGroup() {
+        super("setprimarygroup", "Sets a users primary group",
+                "/%s user <user> setprimarygroup <group>", Permission.USER_SETPRIMARYGROUP);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        Group group = plugin.getGroupManager().getGroup(args.get(0).toLowerCase());
+        if (group == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return;
+        }
+
+        if (user.getPrimaryGroup().equalsIgnoreCase(group.getName())) {
+            Message.USER_PRIMARYGROUP_ERROR_ALREADYHAS.send(sender);
+            return;
+        }
+
+        if (!user.isInGroup(group)) {
+            Message.USER_PRIMARYGROUP_ERROR_NOTMEMBER.send(sender, label);
+            return;
+        }
+
+        user.setPrimaryGroup(group.getName());
+        Message.USER_PRIMARYGROUP_SUCCESS.send(sender, user.getName(), group.getName());
+
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getGroupTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetTempPermission.java

@@ -0,0 +1,81 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.DateUtil;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class UserSetTempPermission extends UserSubCommand {
+    public UserSetTempPermission() {
+        super("settemp", "Sets a temporary permission for a user",
+                "/%s user <user> settemp <node> <true|false> <duration> [server]", Permission.USER_SET_TEMP_PERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String node = args.get(0);
+        String bool = args.get(1).toLowerCase();
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.USER_USE_ADDGROUP.send(sender);
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        long duration;
+        try {
+            duration = DateUtil.parseDateDiff(args.get(2), true);
+        } catch (DateUtil.IllegalDateException e) {
+            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
+            return;
+        }
+
+        if (DateUtil.shouldExpire(duration)) {
+            Message.PAST_DATE_ERROR.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 4) {
+                final String server = args.get(3).toLowerCase();
+                user.setPermission(node, b, server, duration);
+                Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server, DateUtil.formatDateDiff(duration));
+            } else {
+                user.setPermission(node, b, duration);
+                Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, user.getName(), DateUtil.formatDateDiff(duration));
+            }
+
+            saveUser(user, sender, plugin);
+        } catch (ObjectAlreadyHasException e) {
+            Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, user.getName());
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getBoolTabComplete(args);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 3 && argLength != 4;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowPos.java

@@ -0,0 +1,57 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserShowPos extends UserSubCommand {
+    public UserShowPos() {
+        super("showpos", "Shows a users position on a track", "/%s user <user> showpos <track>", Permission.USER_SHOWPOS);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        final String trackName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadTrack(trackName, success -> {
+            if (!success) {
+                Message.TRACK_DOES_NOT_EXIST.send(sender);
+            } else {
+                Track track = plugin.getTrackManager().getTrack(trackName);
+                if (track == null) {
+                    Message.TRACK_DOES_NOT_EXIST.send(sender);
+                    return;
+                }
+
+                if (track.getSize() <= 1) {
+                    Message.TRACK_EMPTY.send(sender);
+                    return;
+                }
+
+                if (!track.containsGroup(user.getPrimaryGroup())) {
+                    Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), user.getPrimaryGroup());
+                    return;
+                }
+
+                Message.USER_SHOWPOS.send(sender, user.getName(), track.getName(), Util.listToArrowSep(track.getGroups(), user.getPrimaryGroup()));
+            }
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return getTrackTabComplete(args, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowTracks.java

@@ -0,0 +1,39 @@
+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.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class UserShowTracks extends UserSubCommand {
+    public UserShowTracks() {
+        super("showtracks", "Lists the tracks that this user's primary group features on", "/%s user <user> showtracks",
+                Permission.USER_SHOWTRACKS);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        plugin.getDatastore().loadAllTracks(success -> {
+            if (!success) {
+                Message.TRACKS_LOAD_ERROR.send(sender);
+                return;
+            }
+
+            Message.USER_SHOWTRACKS_INFO.send(sender, user.getPrimaryGroup(), user.getName());
+            Message.TRACKS_LIST.send(sender, Util.listToCommaSep(
+                    plugin.getTrackManager().getApplicableTracks(user.getPrimaryGroup()).stream().map(Track::getName).collect(Collectors.toList())));
+        });
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermission.java

@@ -0,0 +1,54 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class UserUnSetPermission extends UserSubCommand {
+    public UserUnSetPermission() {
+        super("unset", "Unsets a permission for a user",
+                "/%s user <user> unset <node> [server]", Permission.USER_UNSETPERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String node = args.get(0);
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.USER_USE_REMOVEGROUP.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                user.unsetPermission(node, server);
+                Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+            } else {
+                user.unsetPermission(node);
+                Message.UNSETPERMISSION_SUCCESS.send(sender, node, user.getName());
+            }
+
+            saveUser(user, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.DOES_NOT_HAVEPERMISSION.send(sender, user.getName());
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermissionCommand.java

@@ -1,51 +0,0 @@
-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;
-    }
-}

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnsetTempPermission.java

@@ -0,0 +1,54 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.List;
+
+public class UserUnsetTempPermission extends UserSubCommand {
+    public UserUnsetTempPermission() {
+        super("unsettemp", "Unsets a temporary permission for a user",
+                "/%s user <user> unsettemp <node> [server]", Permission.USER_UNSET_TEMP_PERMISSION);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        String node = args.get(0);
+
+        if (node.contains("/") || node.contains("$")) {
+            sendUsage(sender, label);
+            return;
+        }
+
+        if (Patterns.GROUP_MATCH.matcher(node).matches()) {
+            Message.USER_USE_REMOVEGROUP.send(sender);
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                user.unsetPermission(node, server, true);
+                Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+            } else {
+                user.unsetPermission(node, true);
+                Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, user.getName());
+            }
+
+            saveUser(user, sender, plugin);
+        } catch (ObjectLacksException e) {
+            Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, user.getName());
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength != 1 && argLength != 2;
+    }
+}

common/src/main/java/me/lucko/luckperms/constants/Message.java

@@ -0,0 +1,219 @@
+package me.lucko.luckperms.constants;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+
+@SuppressWarnings("SpellCheckingInspection")
+@AllArgsConstructor
+public enum Message {
+
+    /**
+     * General & Commands
+     */
+    PREFIX("&7&l[&b&lL&a&lP&7&l] &c", false),
+    EMPTY("%s", true),
+
+    COMMAND_NOT_RECOGNISED("Command not recognised.", true),
+    COMMAND_NO_PERMISSION("You do not have permission to use this command!", true),
+    INFO_BRIEF("&6Running &bLuckPerms %s&6.", true),
+
+    ALREADY_HASPERMISSION("%s already has this permission!", true),
+    DOES_NOT_HAVEPERMISSION("%s does not have this permission set.", true),
+    ALREADY_HAS_TEMP_PERMISSION("%s already has this permission set temporarily!", true),
+    DOES_NOT_HAVE_TEMP_PERMISSION("%s does not have this permission set temporarily.", true),
+
+
+
+    /**
+     * Loading / Saving
+     */
+    USER_NOT_FOUND("&eUser could not be found.", true),
+    USER_SAVE_SUCCESS("&7(User data was saved to the datastore)", true),
+    USER_SAVE_ERROR("There was an error whilst saving the user.", true),
+    USER_ATTEMPTING_LOOKUP("&7(Attempting UUID lookup, since you specified a username)", true),
+
+    GROUP_NOT_FOUND("&eGroup could not be found.", true),
+    GROUP_SAVE_SUCCESS("&7(Group data was saved to the datastore)", true),
+    GROUP_SAVE_ERROR("There was an error whilst saving the group.", true),
+
+    TRACK_NOT_FOUND("&eTrack could not be found.", true),
+    TRACK_SAVE_SUCCESS("&7(Track data was saved to the datastore)", true),
+    TRACK_SAVE_ERROR("There was an error whilst saving the track.", true),
+
+
+
+    /**
+     * Command Syntax
+     */
+    USER_USE_ADDGROUP("Use the addgroup command instead of specifying the node.", true),
+    USER_USE_REMOVEGROUP("Use the removegroup command instead of specifying the node.", true),
+    USER_INVALID_ENTRY("&d%s&c is not a valid username/uuid.", true),
+
+    GROUP_USE_INHERIT("Use the setinherit command instead of specifying the node.", true),
+    GROUP_USE_UNINHERIT("Use the unsetinherit command instead of specifying the node.", true),
+    GROUP_INVALID_ENTRY("Group names can only contain alphanumeric charcters.", true),
+
+    TRACK_INVALID_ENTRY("Track names can only contain alphanumeric charcters.", true),
+
+
+    /**
+     * Commands
+     */
+    CREATE_SUCCESS("&b%s&a was successfully created.", true),
+    DELETE_SUCCESS("&b%s&a was successfully deleted.", true),
+
+    USER_ALREADY_MEMBER_OF("%s is already a member of '%s'.", true),
+    USER_NOT_MEMBER_OF("%s is not a member of '%s'.", true),
+    GROUP_ALREADY_INHERITS("%s already inherits '%s'.", true),
+    GROUP_DOES_NOT_INHERIT("%s does not inherit '%s'.", true),
+
+    USER_ALREADY_TEMP_MEMBER_OF("%s is already a temporary member of '%s'.", true),
+    USER_NOT_TEMP_MEMBER_OF("%s is not a temporary member of '%s'.", true),
+    GROUP_ALREADY_TEMP_INHERITS("%s already temporarily inherits '%s'.", true),
+    GROUP_DOES_NOT_TEMP_INHERIT("%s does not temporarily inherit '%s'.", true),
+
+    TRACK_ALREADY_CONTAINS("Track %s already contains the group '%s'.", true),
+    TRACK_DOES_NOT_CONTAIN("Track %s does not contain the group '%s'.", true),
+
+    GROUP_ALREADY_EXISTS("That group already exists!", true),
+    GROUP_DOES_NOT_EXIST("That group does not exist!", true),
+    GROUP_NAME_TOO_LONG("Group name '%s' exceeds the maximum length of 36 characters.", true),
+    GROUP_LOAD_ERROR("An unexpected error occurred. Group not loaded.", true),
+    GROUPS_LOAD_ERROR("An unexpected error occurred. Unable to load all groups.", true),
+
+    TRACK_ALREADY_EXISTS("That track already exists!", true),
+    TRACK_DOES_NOT_EXIST("That track does not exist!", true),
+    TRACK_NAME_TOO_LONG("Track name '%s' exceeds the maximum length of 36 characters.", true),
+    TRACK_LOAD_ERROR("An unexpected error occurred. Track not loaded.", true),
+    TRACKS_LOAD_ERROR("An unexpected error occurred. Unable to load all tracks.", true),
+    TRACK_EMPTY("The track cannot be used as it is empty or contains only one group.", true),
+
+    UPDATE_TASK_RUN("&bRunning update task for all online users.", true),
+    INFO(
+            PREFIX + "&6Running &bLuckPerms %s&6." + "\n" +
+            PREFIX + "&eAuthor: &6Luck" + "\n" +
+            PREFIX + "&eStorage Method: &6%s",
+            false
+    ),
+    DEBUG(
+            PREFIX + "&d&l> &dDebug Info" + "\n" +
+            PREFIX + "&eOnline Players: &6%s" + "\n" +
+            PREFIX + "&eLoaded Users: &6%s" + "\n" +
+            PREFIX + "&eLoaded Groups: &6%s" + "\n" +
+            PREFIX + "&eLoaded Tracks: &6%s",
+            false
+    ),
+
+    CREATE_GROUP_ERROR("There was an error whilst creating the group.", true),
+    DELETE_GROUP_ERROR("There was an error whilst deleting the group.", true),
+    DELETE_GROUP_ERROR_DEFAULT("You cannot delete the default group.", true),
+    GROUPS_LIST("&aGroups: %s", true),
+
+    CREATE_TRACK_ERROR("There was an error whilst creating the track.", true),
+    DELETE_TRACK_ERROR("There was an error whilst deleting the track.", true),
+    TRACKS_LIST("&aTracks: %s", true),
+
+    LISTNODES("&e%s's Nodes:" + "\n" + "%s", true),
+    LISTNODES_TEMP("&e%s's Temporary Nodes:" + "\n" + "%s", true),
+    SETPERMISSION_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a.", true),
+    SETPERMISSION_SERVER_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a.", true),
+    SETPERMISSION_TEMP_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a for a duration of &b%s&a.", true),
+    SETPERMISSION_TEMP_SERVER_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
+    UNSETPERMISSION_SUCCESS("&aUnset &b%s&a for &b%s&a.", true),
+    UNSETPERMISSION_SERVER_SUCCESS("&aUnset &b%s&a for &b%s&a on server &b%$s&a.", true),
+    UNSET_TEMP_PERMISSION_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a.", true),
+    UNSET_TEMP_PERMISSION_SERVER_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a on server &b%$s&a.", true),
+    CLEAR_SUCCESS("&b%s&a's permissions were cleared.", true),
+    ILLEGAL_DATE_ERROR("Could not parse date '%s'.", true),
+    PAST_DATE_ERROR("You cannot set a date in the past!", true),
+
+    USER_INFO(
+            PREFIX + "&d-> &eUser: &6%s" + "\n" +
+            PREFIX + "&d-> &eUUID: &6%s" + "\n" +
+            PREFIX + "&d-> &eStatus: %s" + "\n" +
+            PREFIX + "&d-> &eGroups: &6%s" + "\n" +
+            PREFIX + "&d-> &ePrimary Group: &6%s" + "\n" +
+            PREFIX + "&d-> &ePermissions: &6%s" + "\n" +
+            PREFIX + "&d-> &eTemporary Permissions: &6%s" + "\n" +
+            PREFIX + "&d-> &bUse &a/%s user %s listnodes &bto see all permissions.",
+            false
+    ),
+    USER_GETUUID("&bThe UUID of &e%s&b is &e%s&b.", true),
+    USER_ADDGROUP_SUCCESS("&b%s&a successfully added to group &b%s&a.", true),
+    USER_ADDGROUP_SERVER_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a.", true),
+    USER_ADDTEMPGROUP_SUCCESS("&b%s&a successfully added to group &b%s&a for a duration of &b%s&a.", true),
+    USER_ADDTEMPGROUP_SERVER_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
+    USER_REMOVEGROUP_SUCCESS("&b%s&a was removed from group &b%s&a.", true),
+    USER_REMOVEGROUP_SERVER_SUCCESS("&b%s&a was removed from group &b%s&a on server &b%s&a.", true),
+    USER_REMOVETEMPGROUP_SUCCESS("&b%s&a was removed from temproary group &b%s&a.", true),
+    USER_REMOVETEMPGROUP_SERVER_SUCCESS("&b%s&a was removed from temporary group &b%s&a on server &b%s&a.", true),
+    USER_REMOVEGROUP_ERROR_PRIMARY("You cannot remove a user from their primary group.", true),
+    USER_PRIMARYGROUP_SUCCESS("&b%s&a's primary group was set to &b%s&a.", true),
+    USER_PRIMARYGROUP_ERROR_ALREADYHAS("The user already has this group set as their primary group.", true),
+    USER_PRIMARYGROUP_ERROR_NOTMEMBER("The user must be a member of the group first! Use &4/%s user <user> addgroup <group>", true),
+    USER_SHOWTRACKS_INFO("&aShowing tracks that contain the group '&b%s&a' (%s's primary group)", true),
+    USER_PROMOTE_SUCCESS_PROMOTE("&aPromoting user along track &b%s&a from &b%s&a to &b%s&a.", true),
+    USER_PROMOTE_SUCCESS_REMOVE("&b%s&a was removed from &b%s&a, added to &b%s&a, and their primary group was set to &b%s&a.", true),
+    USER_PROMOTE_ERROR_ENDOFTRACK("The end of track &4%s&c was reached. Unable to promote user.", true),
+    USER_PROMOTE_ERROR_MALFORMED(
+            PREFIX + "The next group on the track, %s, no longer exists. Unable to promote user." + "\n" +
+            PREFIX + "Either create the group, or remove it from the track and try again.",
+            false
+    ),
+    USER_PROMOTE_ERROR_NOT_CONTAIN_GROUP("Promotions are done based on primary groups. The users primary group is not on the track specified.", true),
+    USER_DEMOTE_SUCCESS_PROMOTE("&aDemoting user along track &b%s&a from &b%s&a to &b%s&a.", true),
+    USER_DEMOTE_SUCCESS_REMOVE("&b%s&a was removed from &b%s&a, added to &b%s&a, and their primary group was set to &b%s&a.", true),
+    USER_DEMOTE_ERROR_ENDOFTRACK("The end of track &4%s&c was reached. Unable to demote user.", true),
+    USER_DEMOTE_ERROR_MALFORMED(
+            PREFIX + "The previous group on the track, %s, no longer exists. Unable to demote user." + "\n" +
+            PREFIX + "Either create the group, or remove it from the track and try again.",
+            false
+    ),
+    USER_DEMOTE_ERROR_NOT_CONTAIN_GROUP("Demotions are done based on primary groups. The users primary group is not on the track specified.", true),
+    USER_SHOWPOS("&aShowing &b%s&a's position on track &b%s&a.\n%s", true),
+
+    GROUP_INFO(
+            PREFIX + "&d-> &eGroup: &6%s" + "\n" +
+            PREFIX + "&d-> &ePermissions: &6%s" + "\n" +
+            PREFIX + "&d-> &eTemporary Permissions: &6%s" + "\n" +
+            PREFIX + "&d-> &bUse &a/%s group %s listnodes &bto see all permissions.",
+            false
+    ),
+    GROUP_SETINHERIT_SUCCESS("&b%s&a now inherits permissions from &b%s&a.", true),
+    GROUP_SETINHERIT_SERVER_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a.", true),
+    GROUP_SET_TEMP_INHERIT_SUCCESS("&b%s&a now inherits permissions from &b%s&a for a duration of &b%s&a.", true),
+    GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
+    GROUP_UNSETINHERIT_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a.", true),
+    GROUP_UNSETINHERIT_SERVER_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a on server &b%s&a.", true),
+    GROUP_UNSET_TEMP_INHERIT_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a.", true),
+    GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a on server &b%s&a.", true),
+
+    TRACK_INFO(
+            PREFIX + "&d-> &eTrack: &6%s" + "\n" +
+            PREFIX + "&d-> &ePath: &6%s",
+            false
+    ),
+    TRACK_CLEAR("&b%s&a's groups track was cleared.", true),
+    TRACK_APPEND_SUCCESS("&aGroup &b%s&a was successfully appended to track &b%s&a.", true),
+    TRACK_INSERT_SUCCESS("&aGroup &b%s&a was successfully inserted into to track &b%s&a at position &b%s&a.", true),
+    TRACK_INSERT_ERROR_NUMBER("Expected number but instead received: %s", true),
+    TRACK_INSERT_ERROR_INVALID_POS("Unable to insert at position %s. Index out of bounds.", true),
+    TRACK_REMOVE_SUCCESS("&aGroup &b%s&a was successfully removed from track &b%s&a.", true);
+
+    private String message;
+    private boolean showPrefix;
+
+    @Override
+    public String toString() {
+        return message;
+    }
+
+    public void send(Sender sender, Object... objects) {
+        if (showPrefix) {
+            sender.sendMessage(Util.color(PREFIX + String.format(message, objects)));
+        } else {
+            sender.sendMessage(Util.color(String.format(message, objects)));
+        }
+    }
+}

common/src/main/java/me/lucko/luckperms/constants/Permission.java

@@ -0,0 +1,93 @@
+package me.lucko.luckperms.constants;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import me.lucko.luckperms.commands.Sender;
+
+@SuppressWarnings("SpellCheckingInspection")
+@AllArgsConstructor
+public enum Permission {
+
+    SYNC("sync", null),
+    INFO("info", null),
+    DEBUG("debug", null),
+
+    CREATE_GROUP("creategroup", null),
+    DELETE_GROUP("deletegroup", null),
+    LIST_GROUPS("listgroups", null),
+
+    CREATE_TRACK("createtrack", null),
+    DELETE_TRACK("deletetrack", null),
+    LIST_TRACKS("listtracks", null),
+
+    USER_INFO("info", PermissionGroup.USER),
+    USER_GETUUID("getuuid", PermissionGroup.USER),
+    USER_LISTNODES("listnodes", PermissionGroup.USER),
+    USER_HASPERMISSION("haspermission", PermissionGroup.USER),
+    USER_INHERITSPERMISSION("inheritspermission", PermissionGroup.USER),
+    USER_SETPERMISSION("setpermission", PermissionGroup.USER),
+    USER_UNSETPERMISSION("unsetpermission", PermissionGroup.USER),
+    USER_ADDGROUP("addgroup", PermissionGroup.USER),
+    USER_REMOVEGROUP("removegroup", PermissionGroup.USER),
+    USER_SET_TEMP_PERMISSION("settemppermission", PermissionGroup.USER),
+    USER_UNSET_TEMP_PERMISSION("unsettemppermission", PermissionGroup.USER),
+    USER_ADDTEMPGROUP("addtempgroup", PermissionGroup.USER),
+    USER_REMOVETEMPGROUP("removetempgroup", PermissionGroup.USER),
+    USER_SETPRIMARYGROUP("setprimarygroup", PermissionGroup.USER),
+    USER_SHOWTRACKS("showtracks", PermissionGroup.USER),
+    USER_PROMOTE("promote", PermissionGroup.USER),
+    USER_DEMOTE("demote", PermissionGroup.USER),
+    USER_SHOWPOS("showpos", PermissionGroup.USER),
+    USER_CLEAR("clear", PermissionGroup.USER),
+
+    GROUP_INFO("info", PermissionGroup.GROUP),
+    GROUP_LISTNODES("listnodes", PermissionGroup.GROUP),
+    GROUP_HASPERMISSION("haspermission", PermissionGroup.GROUP),
+    GROUP_INHERITSPERMISSION("inheritspermission", PermissionGroup.GROUP),
+    GROUP_SETPERMISSION("setpermission", PermissionGroup.GROUP),
+    GROUP_UNSETPERMISSION("unsetpermission", PermissionGroup.GROUP),
+    GROUP_SETINHERIT("setinherit", PermissionGroup.GROUP),
+    GROUP_UNSETINHERIT("unsetinherit", PermissionGroup.GROUP),
+    GROUP_SET_TEMP_PERMISSION("settemppermission", PermissionGroup.GROUP),
+    GROUP_UNSET_TEMP_PERMISSION("unsettemppermission", PermissionGroup.GROUP),
+    GROUP_SET_TEMP_INHERIT("settempinherit", PermissionGroup.GROUP),
+    GROUP_UNSET_TEMP_INHERIT("unsettempinherit", PermissionGroup.GROUP),
+    GROUP_SHOWTRACKS("showtracks", PermissionGroup.GROUP),
+    GROUP_CLEAR("clear", PermissionGroup.GROUP),
+
+    TRACK_INFO("info", PermissionGroup.TRACK),
+    TRACK_APPEND("append", PermissionGroup.TRACK),
+    TRACK_INSERT("insert", PermissionGroup.TRACK),
+    TRACK_REMOVE("remove", PermissionGroup.TRACK),
+    TRACK_CLEAR("clear", PermissionGroup.TRACK);
+
+    private String node;
+    private PermissionGroup group;
+
+    public boolean isAuthorized(Sender sender) {
+        if (sender.hasPermission("luckperms.*")) {
+            return true;
+        }
+
+        if (group != null) {
+            return group.isAuthorized(sender) || sender.hasPermission("luckperms." + group.getNode() + "." + node);
+        }
+
+        return sender.hasPermission("luckperms." + node);
+    }
+
+    @Getter
+    @AllArgsConstructor
+    private enum PermissionGroup {
+        USER("user"),
+        GROUP("group"),
+        TRACK("track");
+
+        private String node;
+
+        private boolean isAuthorized(Sender sender) {
+            return sender.hasPermission("luckperms." + node + ".*");
+        }
+    }
+
+}

common/src/main/java/me/lucko/luckperms/data/Datastore.java

@@ -4,6 +4,7 @@ import lombok.Getter;
 import lombok.Setter;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.users.User;
 
 import java.util.UUID;
@@ -12,16 +13,16 @@ public abstract class Datastore {
     protected final LuckPermsPlugin plugin;
 
     @Getter
-    public String name;
+    public final String name;
 
     @Getter
     @Setter
     private boolean acceptingLogins;
 
-    public Datastore(LuckPermsPlugin plugin, String name) {
+    protected Datastore(LuckPermsPlugin plugin, String name) {
         this.plugin = plugin;
         this.name = name;
-        this.acceptingLogins = true;
+        this.acceptingLogins = false;
     }
 
     /**
@@ -45,9 +46,10 @@ public abstract class Datastore {
     }
 
     /*
-        These methods will block the thread that they're ran on.
+        These methods are called immediately and in the same thread as they are called in.
      */
-    public abstract void init(DatastoreConfiguration configuration);
+    public abstract void init();
+    public abstract void shutdown();
     public abstract boolean loadOrCreateUser(UUID uuid, String username);
     public abstract boolean loadUser(UUID uuid);
     public abstract boolean saveUser(User user);
@@ -56,16 +58,19 @@ public abstract class Datastore {
     public abstract boolean loadAllGroups();
     public abstract boolean saveGroup(Group group);
     public abstract boolean deleteGroup(Group group);
+    public abstract boolean createAndLoadTrack(String name);
+    public abstract boolean loadTrack(String name);
+    public abstract boolean loadAllTracks();
+    public abstract boolean saveTrack(Track track);
+    public abstract boolean deleteTrack(Track track);
     public abstract boolean saveUUIDData(String username, UUID uuid);
     public abstract UUID getUUID(String username);
 
 
 
     /*
-        These methods will return as soon as they are called. The callback will be ran when the task is complete
-        They therefore will not block the thread that they're ran on
-
-        Callbacks are ran on the main server thread (if applicable)
+        These methods will schedule the operation to run async. The callback will be ran when the task is complete.
+        Callbacks are ran on the main Bukkit server thread (if applicable)
      */
     public void loadOrCreateUser(UUID uuid, String username, Callback callback) {
         doAsync(() -> runCallback(loadOrCreateUser(uuid, username), callback));
@@ -99,6 +104,26 @@ public abstract class Datastore {
         doAsync(() -> runCallback(deleteGroup(group), callback));
     }
 
+    public void createAndLoadTrack(String name, Callback callback) {
+        doAsync(() -> runCallback(createAndLoadTrack(name), callback));
+    }
+
+    public void loadTrack(String name, Callback callback) {
+        doAsync(() -> runCallback(loadTrack(name), callback));
+    }
+
+    public void loadAllTracks(Callback callback) {
+        doAsync(() -> runCallback(loadAllTracks(), callback));
+    }
+
+    public void saveTrack(Track track, Callback callback) {
+        doAsync(() -> runCallback(saveTrack(track), callback));
+    }
+
+    public void deleteTrack(Track track, Callback callback) {
+        doAsync(() -> runCallback(deleteTrack(track), callback));
+    }
+
     public void saveUUIDData(String username, UUID uuid, Callback callback) {
         doAsync(() -> runCallback(saveUUIDData(username, uuid), callback));
     }