Add Api

common/src/main/java/me/lucko/luckperms/api/implementation/ApiProvider.java

@@ -0,0 +1,90 @@
+package me.lucko.luckperms.api.implementation;
+
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.implementation.internal.DatastoreLink;
+import me.lucko.luckperms.api.implementation.internal.GroupLink;
+import me.lucko.luckperms.api.implementation.internal.TrackLink;
+import me.lucko.luckperms.api.implementation.internal.UserLink;
+
+import java.util.UUID;
+
+/**
+ * Provides static access to LuckPerms
+ */
+@AllArgsConstructor
+public class ApiProvider implements LuckPermsApi {
+    private final LuckPermsPlugin plugin;
+
+    @Override
+    public void runUpdateTask() {
+        plugin.runUpdateTask();
+    }
+
+    @Override
+    public String getVersion() {
+        return plugin.getVersion();
+    }
+
+    @Override
+    public Datastore getDatastore() {
+        return new DatastoreLink(plugin.getDatastore());
+    }
+
+    @Override
+    public User getUser(@NonNull UUID uuid) {
+        final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(uuid);
+        if (user == null) {
+            return null;
+        }
+
+        return new UserLink(user);
+    }
+
+    @Override
+    public User getUser(@NonNull String name) {
+        final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(name);
+        if (user == null) {
+            return null;
+        }
+
+        return new UserLink(user);
+    }
+
+    @Override
+    public boolean isUserLoaded(@NonNull UUID uuid) {
+        return plugin.getUserManager().isLoaded(uuid);
+    }
+
+    @Override
+    public Group getGroup(@NonNull String name) {
+        final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().getGroup(name);
+        if (group == null) {
+            return null;
+        }
+
+        return new GroupLink(group);
+    }
+
+    @Override
+    public boolean isGroupLoaded(@NonNull String name) {
+        return plugin.getGroupManager().isLoaded(name);
+    }
+
+    @Override
+    public Track getTrack(@NonNull String name) {
+        final me.lucko.luckperms.tracks.Track track = plugin.getTrackManager().getTrack(name);
+        if (track == null) {
+            return null;
+        }
+
+        return new TrackLink(track);
+    }
+
+    @Override
+    public boolean isTrackLoaded(@NonNull String name) {
+        return plugin.getTrackManager().isLoaded(name);
+    }
+}

common/src/main/java/me/lucko/luckperms/api/implementation/internal/DatastoreLink.java

@@ -0,0 +1,252 @@
+package me.lucko.luckperms.api.implementation.internal;
+
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Datastore;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.UUID;
+
+/**
+ * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.data.Datastore}
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+public class DatastoreLink implements Datastore {
+
+    private final me.lucko.luckperms.data.Datastore master;
+    private final Async async;
+    private final Sync sync;
+
+    public DatastoreLink(@NonNull me.lucko.luckperms.data.Datastore master) {
+        this.master = master;
+        this.async = new Async(master);
+        this.sync = new Sync(master);
+    }
+
+    private static String checkUsername(String s) {
+        if (s.length() > 16 || Patterns.NON_USERNAME.matcher(s).find()) {
+            throw new IllegalArgumentException("Invalid username entry '" + s + "'. Usernames must be less than 16 chars" +
+                    " and only contain 'a-z A-Z 1-9 _'.");
+        }
+        return s;
+    }
+
+    private static String checkName(String s) {
+        if (s.length() > 36 || Patterns.NON_ALPHA_NUMERIC.matcher(s).find()) {
+            throw new IllegalArgumentException("Invalid name entry '" + s + "'. Names must be less than 37 chars" +
+                    " and only contain 'a-z A-Z 1-9'.");
+        }
+        return s.toLowerCase();
+    }
+
+    private static Callback checkCallback(Callback c) {
+        // If no callback was given, just send an empty one
+        if (c == null) {
+            c = success -> {};
+        }
+        return c;
+    }
+
+    private static Callback.GetUUID checkCallback(Callback.GetUUID c) {
+        // If no callback was given, just send an empty one
+        if (c == null) {
+            c = success -> {};
+        }
+        return c;
+    }
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public boolean isAcceptingLogins() {
+        return master.isAcceptingLogins();
+    }
+
+    @Override
+    public Async async() {
+        return async;
+    }
+
+    @Override
+    public Sync sync() {
+        return sync;
+    }
+
+    @AllArgsConstructor
+    public class Async implements Datastore.Async {
+        private final me.lucko.luckperms.data.Datastore master;
+
+        @Override
+        public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback callback) {
+            master.loadOrCreateUser(uuid, checkUsername(username), checkCallback(callback));
+        }
+
+        @Override
+        public void loadUser(@NonNull UUID uuid, Callback callback) {
+            master.loadUser(uuid, checkCallback(callback));
+        }
+
+        @Override
+        public void saveUser(@NonNull User user, Callback callback) {
+            Utils.checkUser(user);
+            master.saveUser(((UserLink) user).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void createAndLoadGroup(@NonNull String name, Callback callback) {
+            master.createAndLoadGroup(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadGroup(@NonNull String name, Callback callback) {
+            master.loadGroup(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadAllGroups(Callback callback) {
+            master.loadAllGroups(checkCallback(callback));
+        }
+
+        @Override
+        public void saveGroup(@NonNull Group group, Callback callback) {
+            Utils.checkGroup(group);
+            master.saveGroup(((GroupLink) group).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void deleteGroup(@NonNull Group group, Callback callback) {
+            Utils.checkGroup(group);
+            master.deleteGroup(((GroupLink) group).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void createAndLoadTrack(@NonNull String name, Callback callback) {
+            master.createAndLoadTrack(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadTrack(@NonNull String name, Callback callback) {
+            master.loadTrack(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadAllTracks(Callback callback) {
+            master.loadAllTracks(checkCallback(callback));
+        }
+
+        @Override
+        public void saveTrack(@NonNull Track track, Callback callback) {
+            Utils.checkTrack(track);
+            master.saveTrack(((TrackLink) track).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void deleteTrack(@NonNull Track track, Callback callback) {
+            Utils.checkTrack(track);
+            master.deleteTrack(((TrackLink) track).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void saveUUIDData(@NonNull String username, @NonNull UUID uuid, Callback callback) {
+            master.saveUUIDData(checkUsername(username), uuid, checkCallback(callback));
+        }
+
+        @Override
+        public void getUUID(@NonNull String username, Callback.GetUUID callback) {
+            master.getUUID(checkUsername(username), checkCallback(callback));
+        }
+    }
+
+    @AllArgsConstructor
+    public class Sync implements Datastore.Sync {
+        private final me.lucko.luckperms.data.Datastore master;
+
+        @Override
+        public boolean loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
+            return master.loadOrCreateUser(uuid, checkUsername(username));
+        }
+
+        @Override
+        public boolean loadUser(@NonNull UUID uuid) {
+            return master.loadUser(uuid);
+        }
+
+        @Override
+        public boolean saveUser(@NonNull User user) {
+            Utils.checkUser(user);
+            return master.saveUser(((UserLink) user).getMaster());
+        }
+
+        @Override
+        public boolean createAndLoadGroup(@NonNull String name) {
+            return master.createAndLoadGroup(checkName(name));
+        }
+
+        @Override
+        public boolean loadGroup(@NonNull String name) {
+            return master.loadGroup(checkName(name));
+        }
+
+        @Override
+        public boolean loadAllGroups() {
+            return master.loadAllGroups();
+        }
+
+        @Override
+        public boolean saveGroup(@NonNull Group group) {
+            Utils.checkGroup(group);
+            return master.saveGroup(((GroupLink) group).getMaster());
+        }
+
+        @Override
+        public boolean deleteGroup(@NonNull Group group) {
+            Utils.checkGroup(group);
+            return master.deleteGroup(((GroupLink) group).getMaster());
+        }
+
+        @Override
+        public boolean createAndLoadTrack(@NonNull String name) {
+            return master.createAndLoadTrack(checkName(name));
+        }
+
+        @Override
+        public boolean loadTrack(@NonNull String name) {
+            return master.loadTrack(checkName(name));
+        }
+
+        @Override
+        public boolean loadAllTracks() {
+            return master.loadAllTracks();
+        }
+
+        @Override
+        public boolean saveTrack(@NonNull Track track) {
+            Utils.checkTrack(track);
+            return master.saveTrack(((TrackLink) track).getMaster());
+        }
+
+        @Override
+        public boolean deleteTrack(@NonNull Track track) {
+            Utils.checkTrack(track);
+            return master.deleteTrack(((TrackLink) track).getMaster());
+        }
+
+        @Override
+        public boolean saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
+            return master.saveUUIDData(checkUsername(username), uuid);
+        }
+
+        @Override
+        public UUID getUUID(@NonNull String username) {
+            return master.getUUID(checkUsername(username));
+        }
+    }
+
+}

common/src/main/java/me/lucko/luckperms/api/implementation/internal/GroupLink.java

@@ -0,0 +1,31 @@
+package me.lucko.luckperms.api.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Group;
+
+/**
+ * Provides a link between {@link Group} and {@link me.lucko.luckperms.groups.Group}
+ */
+@SuppressWarnings("unused")
+public class GroupLink extends PermissionObjectLink implements Group {
+
+    @Getter(AccessLevel.PACKAGE)
+    private final me.lucko.luckperms.groups.Group master;
+
+    public GroupLink(@NonNull me.lucko.luckperms.groups.Group master) {
+        super(master);
+        this.master = master;
+    }
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public void clearNodes() {
+        master.clearNodes();
+    }
+}

common/src/main/java/me/lucko/luckperms/api/implementation/internal/PermissionObjectLink.java

@@ -0,0 +1,147 @@
+package me.lucko.luckperms.api.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.api.PermissionObject;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.utils.DateUtil;
+import me.lucko.luckperms.utils.Patterns;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Provides a link between {@link PermissionObject} and {@link me.lucko.luckperms.utils.PermissionObject}
+ */
+@SuppressWarnings("unused")
+@AllArgsConstructor(access = AccessLevel.PACKAGE)
+class PermissionObjectLink implements PermissionObject {
+
+    @NonNull
+    private final me.lucko.luckperms.utils.PermissionObject master;
+
+    static String checkServer(String s) {
+        if (Patterns.NON_ALPHA_NUMERIC.matcher(s).find()) {
+            throw new IllegalArgumentException("Invalid server entry '" + s + "'. Server names can only contain alphanumeric characters.");
+        }
+        return s;
+    }
+
+    private static String checkNode(String s) {
+        if (s.contains("/") || s.contains("$")) {
+            throw new IllegalArgumentException("Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters.");
+        }
+        return s;
+    }
+
+    static long checkTime(long l) {
+        if (DateUtil.shouldExpire(l)) {
+            throw new IllegalArgumentException("Unix time '" + l + "' is invalid, as it has already passed.");
+        }
+        return l;
+    }
+
+    @Override
+    public String getObjectName() {
+        return master.getObjectName();
+    }
+
+    @Override
+    public Map<String, Boolean> getNodes() {
+        return Collections.unmodifiableMap(master.getNodes());
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b) {
+        return master.hasPermission(node, b);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server) {
+        return master.hasPermission(node, b, checkServer(server));
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
+        return master.hasPermission(node, b, temporary);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b) {
+        return master.inheritsPermission(node, b);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server) {
+        return master.inheritsPermission(node, b, checkServer(server));
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
+        return master.inheritsPermission(node, b, temporary);
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value);
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server));
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkTime(expireAt));
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server), checkTime(expireAt));
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull boolean temporary) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), temporary);
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node));
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server));
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server), temporary);
+    }
+
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
+        return master.getLocalPermissions(server, excludedGroups);
+    }
+
+    @Override
+    public Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes() {
+        return master.getTemporaryNodes();
+    }
+
+    @Override
+    public Map<String, Boolean> getPermanentNodes() {
+        return master.getPermanentNodes();
+    }
+
+    @Override
+    public void auditTemporaryPermissions() {
+        master.auditTemporaryPermissions();
+    }
+
+}

common/src/main/java/me/lucko/luckperms/api/implementation/internal/TrackLink.java

@@ -0,0 +1,90 @@
+package me.lucko.luckperms.api.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+/**
+ * Provides a link between {@link Track} and {@link me.lucko.luckperms.tracks.Track}
+ */
+@SuppressWarnings("unused")
+@AllArgsConstructor
+public class TrackLink implements Track {
+
+    @NonNull
+    @Getter(AccessLevel.PACKAGE)
+    private final me.lucko.luckperms.tracks.Track master;
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public List<String> getGroups() {
+        return master.getGroups();
+    }
+
+    @Override
+    public int getSize() {
+        return master.getSize();
+    }
+
+    @Override
+    public String getNext(@NonNull Group current) throws ObjectLacksException {
+        Utils.checkGroup(current);
+        return master.getNext(((GroupLink) current).getMaster());
+    }
+
+    @Override
+    public String getPrevious(@NonNull Group current) throws ObjectLacksException {
+        Utils.checkGroup(current);
+        return master.getPrevious(((GroupLink) current).getMaster());
+    }
+
+    @Override
+    public void appendGroup(@NonNull Group group) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.appendGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void insertGroup(@NonNull Group group, @NonNull int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException {
+        Utils.checkGroup(group);
+        master.insertGroup(((GroupLink) group).getMaster(), position);
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void removeGroup(@NonNull String group) throws ObjectLacksException {
+        master.removeGroup(group);
+    }
+
+    @Override
+    public boolean containsGroup(@NonNull Group group) {
+        Utils.checkGroup(group);
+        return master.containsGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public boolean containsGroup(@NonNull String group) {
+        return master.containsGroup(group);
+    }
+
+    @Override
+    public void clearGroups() {
+        master.clearGroups();
+    }
+}

common/src/main/java/me/lucko/luckperms/api/implementation/internal/UserLink.java

@@ -0,0 +1,136 @@
+package me.lucko.luckperms.api.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Provides a link between {@link User} and {@link me.lucko.luckperms.users.User}
+ */
+@SuppressWarnings("unused")
+public class UserLink extends PermissionObjectLink implements User {
+
+    @Getter(AccessLevel.PACKAGE)
+    private final me.lucko.luckperms.users.User master;
+
+    public UserLink(@NonNull me.lucko.luckperms.users.User master) {
+        super(master);
+        this.master = master;
+    }
+
+    @Override
+    public UUID getUuid() {
+        return master.getUuid();
+    }
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public String getPrimaryGroup() {
+        return master.getPrimaryGroup();
+    }
+
+    @Override
+    public void setPrimaryGroup(String s) throws ObjectAlreadyHasException {
+        if (getPrimaryGroup().equalsIgnoreCase(s)) {
+            throw new ObjectAlreadyHasException();
+        }
+
+        if (!getGroupNames().contains(s.toLowerCase())) {
+            throw new IllegalStateException("User is not a member of that group.");
+        }
+
+        master.setPrimaryGroup(s.toLowerCase());
+    }
+
+    @Override
+    public void refreshPermissions() {
+        master.refreshPermissions();
+    }
+
+    @Override
+    public boolean isInGroup(@NonNull Group group) {
+        Utils.checkGroup(group);
+        return master.isInGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public boolean isInGroup(@NonNull Group group, @NonNull String server) {
+        Utils.checkGroup(group);
+        return master.isInGroup(((GroupLink) group).getMaster(), server);
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        Utils.checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull boolean temporary) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), temporary);
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
+        Utils.checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
+    }
+
+    @Override
+    public void clearNodes() {
+        master.clearNodes();
+    }
+
+    @Override
+    public List<String> getGroupNames() {
+        return master.getGroupNames();
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server) {
+        return master.getLocalGroups(checkServer(server));
+    }
+
+}

common/src/main/java/me/lucko/luckperms/api/implementation/internal/Utils.java

@@ -0,0 +1,27 @@
+package me.lucko.luckperms.api.implementation.internal;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+
+class Utils {
+
+    static void checkUser(User user) {
+        if (!(user instanceof UserLink)) {
+            throw new IllegalArgumentException("User instance cannot be handled by this implementation.");
+        }
+    }
+
+    static void checkGroup(Group group) {
+        if (!(group instanceof GroupLink)) {
+            throw new IllegalArgumentException("Group instance cannot be handled by this implementation.");
+        }
+    }
+
+    static void checkTrack(Track track) {
+        if (!(track instanceof TrackLink)) {
+            throw new IllegalArgumentException("Track instance cannot be handled by this implementation.");
+        }
+    }
+
+}

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

@@ -1,7 +1,6 @@
 package me.lucko.luckperms.commands;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.experimental.UtilityClass;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.utils.DateUtil;
 
@@ -9,7 +8,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@UtilityClass
 public class Util {
 
     public static void sendPluginMessage(Sender sender, String message) {

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

@@ -5,6 +5,7 @@ import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.users.User;
@@ -42,6 +43,10 @@ public abstract class Datastore {
         doSync(() -> callback.onComplete(result));
     }
 
+    private void runCallback(UUID result, Callback.GetUUID callback) {
+        doSync(() -> callback.onComplete(result));
+    }
+
     /*
         These methods are called immediately and in the same thread as they are called in.
      */
@@ -125,15 +130,7 @@ public abstract class Datastore {
         doAsync(() -> runCallback(saveUUIDData(username, uuid), callback));
     }
 
-    public void getUUID(String username, GetUUIDCallback callback) {
-        doAsync(() -> doSync(() -> callback.onComplete(getUUID(username))));
-    }
-
-    public interface Callback {
-        void onComplete(boolean success);
-    }
-
-    public interface GetUUIDCallback {
-        void onComplete(UUID uuid);
+    public void getUUID(String username, Callback.GetUUID callback) {
+        doAsync(() -> runCallback(getUUID(username), callback));
     }
 }

common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java

@@ -66,7 +66,7 @@ abstract class SQLDatastore extends Datastore {
                 throw new IllegalStateException("SQL connection is null");
             }
 
-            @Cleanup PreparedStatement preparedStatement =  connection.prepareStatement(queryPS.getQuery());
+            @Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
             queryPS.onRun(preparedStatement);
             preparedStatement.execute();
             success = true;
@@ -389,6 +389,8 @@ abstract class SQLDatastore extends Datastore {
                 preparedStatement.setString(1, track.getName());
             }
         });
+
+        if (success) plugin.getTrackManager().unloadTrack(track);
         return success;
     }
 

common/src/main/java/me/lucko/luckperms/exceptions/ObjectAlreadyHasException.java

@@ -1,4 +0,0 @@
-package me.lucko.luckperms.exceptions;
-
-public class ObjectAlreadyHasException extends Exception {
-}

common/src/main/java/me/lucko/luckperms/exceptions/ObjectLacksException.java

@@ -1,4 +0,0 @@
-package me.lucko.luckperms.exceptions;
-
-public class ObjectLacksException extends Exception {
-}

common/src/main/java/me/lucko/luckperms/utils/DateUtil.java

@@ -1,7 +1,6 @@
 package me.lucko.luckperms.utils;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.experimental.UtilityClass;
 
 import java.util.Calendar;
 import java.util.GregorianCalendar;
@@ -13,7 +12,7 @@ import java.util.regex.Pattern;
  * https://github.com/drtshock/Essentials/blob/2.x/Essentials/src/com/earth2me/essentials/utils/DateUtil.java
  * https://github.com/essentials/Essentials/blob/2.x/Essentials/src/com/earth2me/essentials/utils/DateUtil.java
  */
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@UtilityClass
 public class DateUtil {
     private static final Pattern TIME_PATTERN = Pattern.compile("(?:([0-9]+)\\s*y[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*mo[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*w[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*d[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*h[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*m[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*(?:s[a-z]*)?)?", Pattern.CASE_INSENSITIVE);
     private static final int MAX_YEARS = 100000;

common/src/main/java/me/lucko/luckperms/utils/Patterns.java

@@ -1,11 +1,10 @@
 package me.lucko.luckperms.utils;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.experimental.UtilityClass;
 
 import java.util.regex.Pattern;
 
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@UtilityClass
 public class Patterns {
     public static final Pattern SERVER_SPLIT = Pattern.compile("\\/");
     public static final Pattern TEMP_SPLIT = Pattern.compile("\\$");