Add Api

api/pom.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>luckperms</artifactId>
+        <groupId>me.lucko</groupId>
+        <version>1.3</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-api</artifactId>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

api/src/main/java/me/lucko/luckperms/LuckPerms.java

@@ -0,0 +1,30 @@
+package me.lucko.luckperms;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import me.lucko.luckperms.api.LuckPermsApi;
+
+/**
+ * Static access to LuckPerms
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class LuckPerms {
+
+    private static LuckPermsApi api = null;
+
+    public static LuckPermsApi getApi() {
+        if (api == null) {
+            throw new IllegalStateException("API is not loaded.");
+        }
+        return api;
+    }
+
+    static void registerProvider(LuckPermsApi luckPermsApi) {
+        api = luckPermsApi;
+    }
+
+    static void unregisterProvider() {
+        api = null;
+    }
+
+}

api/src/main/java/me/lucko/luckperms/api/Datastore.java

@@ -0,0 +1,56 @@
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.data.Callback;
+
+import java.util.UUID;
+
+/**
+ * Wrapper interface for the internal Datastore instance
+ * The implementations of this interface limit access to the datastore and add parameter checks to further prevent
+ * errors and ensure all API interactions to not damage the state of the plugin.
+ */
+@SuppressWarnings("unused")
+public interface Datastore {
+
+    String getName();
+    boolean isAcceptingLogins();
+
+    Async async();
+    Sync sync();
+
+    interface Async {
+        void loadOrCreateUser(UUID uuid, String username, Callback callback);
+        void loadUser(UUID uuid, Callback callback);
+        void saveUser(User user, Callback callback);
+        void createAndLoadGroup(String name, Callback callback);
+        void loadGroup(String name, Callback callback);
+        void loadAllGroups(Callback callback);
+        void saveGroup(Group group, Callback callback);
+        void deleteGroup(Group group, Callback callback);
+        void createAndLoadTrack(String name, Callback callback);
+        void loadTrack(String name, Callback callback);
+        void loadAllTracks(Callback callback);
+        void saveTrack(Track track, Callback callback);
+        void deleteTrack(Track track, Callback callback);
+        void saveUUIDData(String username, UUID uuid, Callback callback);
+        void getUUID(String username, Callback.GetUUID callback);
+    }
+
+    interface Sync {
+        boolean loadOrCreateUser(UUID uuid, String username);
+        boolean loadUser(UUID uuid);
+        boolean saveUser(User user);
+        boolean createAndLoadGroup(String name);
+        boolean loadGroup(String name);
+        boolean loadAllGroups();
+        boolean saveGroup(Group group);
+        boolean deleteGroup(Group group);
+        boolean createAndLoadTrack(String name);
+        boolean loadTrack(String name);
+        boolean loadAllTracks();
+        boolean saveTrack(Track track);
+        boolean deleteTrack(Track track);
+        boolean saveUUIDData(String username, UUID uuid);
+        UUID getUUID(String username);
+    }
+}

api/src/main/java/me/lucko/luckperms/api/Group.java

@@ -0,0 +1,18 @@
+package me.lucko.luckperms.api;
+
+/**
+ * Wrapper interface for internal Group instances
+ * The implementations of this interface limit access to the Group and add parameter checks to further prevent
+ * errors and ensure all API interactions to not damage the state of the group.
+ */
+@SuppressWarnings("unused")
+public interface Group extends PermissionObject {
+
+    String getName();
+
+    /**
+     * Clear all of the groups permission nodes
+     */
+    void clearNodes();
+
+}

api/src/main/java/me/lucko/luckperms/api/LuckPermsApi.java

@@ -0,0 +1,23 @@
+package me.lucko.luckperms.api;
+
+import java.util.UUID;
+
+@SuppressWarnings("unused")
+public interface LuckPermsApi {
+
+    void runUpdateTask();
+    String getVersion();
+
+    Datastore getDatastore();
+
+    User getUser(UUID uuid);
+    User getUser(String name);
+    boolean isUserLoaded(UUID uuid);
+
+    Group getGroup(String name);
+    boolean isGroupLoaded(String name);
+
+    Track getTrack(String name);
+    boolean isTrackLoaded(String name);
+
+}

api/src/main/java/me/lucko/luckperms/api/PermissionObject.java

@@ -0,0 +1,166 @@
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Wrapper interface for internal PermissionObject (user/group) instances
+ * The implementations of this interface limit access to the object and add parameter checks to further prevent
+ * errors and ensure all API interactions to not damage the state of the object.
+ */
+@SuppressWarnings("unused")
+public interface PermissionObject {
+
+    String getObjectName();
+
+    Map<String, Boolean> getNodes();
+
+    /**
+     * Checks to see if the object has a certain permission
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @return true if the user has the permission
+     */
+    boolean hasPermission(String node, boolean b);
+
+    /**
+     * Checks to see the the object has a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @return true if the user has the permission
+     */
+    boolean hasPermission(String node, boolean b, String server);
+
+    /**
+     * Checks to see the the object has a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param temporary if the permission is temporary
+     * @return true if the user has the permission
+     */
+    boolean hasPermission(String node, boolean b, boolean temporary);
+
+    /**
+     * Checks to see if the object inherits a certain permission
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @return true if the user inherits the permission
+     */
+    boolean inheritsPermission(String node, boolean b);
+
+    /**
+     * Checks to see the the object inherits a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @return true if the user inherits the permission
+     */
+    boolean inheritsPermission(String node, boolean b, String server);
+
+    /**
+     * Checks to see if the object inherits a certain permission
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param temporary if the permission is temporary
+     * @return true if the user inherits the permission
+     */
+    boolean inheritsPermission(String node, boolean b, boolean temporary);
+
+    /**
+     * Sets a permission for the object
+     * @param node The node to be set
+     * @param value What to set the node to - true/false(negated)
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    void setPermission(String node, boolean value) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object
+     * @param node The node to set
+     * @param value What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    void setPermission(String node, boolean value, String server) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object
+     * @param node The node to set
+     * @param value What to set the node to - true/false(negated)
+     * @param expireAt The time in unixtime when the permission will expire
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    void setPermission(String node, boolean value, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object
+     * @param node The node to set
+     * @param value What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @param expireAt The time in unixtime when the permission will expire
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    void setPermission(String node, boolean value, String server, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @param temporary if the permission being removed is temporary
+     * @throws ObjectLacksException if the node wasn't already set
+     */
+    void unsetPermission(String node, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @throws ObjectLacksException if the node wasn't already set
+     */
+    void unsetPermission(String node) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @param server The server to unset the node on
+     * @throws ObjectLacksException if the node wasn't already set
+     */
+    void unsetPermission(String node, String server) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @param server The server to unset the node on
+     * @param temporary if the permission being unset is temporary
+     * @throws ObjectLacksException if the node wasn't already set
+     */
+    void unsetPermission(String node, String server, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Gets the permissions and inherited permissions that apply to a specific server
+     * @param server The server to get nodes for (can be null)
+     * @param excludedGroups Groups that shouldn't be inherited, can be null (to prevent circular inheritance issues)
+     * @return a {@link Map} of the permissions
+     */
+    Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups);
+
+    /**
+     * Processes the objects and returns the temporary ones.
+     * @return a map of temporary nodes
+     */
+    Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes();
+
+    /**
+     * Processes the objects and returns the non-temporary ones.
+     * @return a map of permanent nodes
+     */
+    Map<String, Boolean> getPermanentNodes();
+
+    /**
+     * Removes temporary permissions that have expired
+     */
+    void auditTemporaryPermissions();
+
+}

api/src/main/java/me/lucko/luckperms/api/Track.java

@@ -0,0 +1,95 @@
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+/**
+ * Wrapper interface for internal Track instances
+ * The implementations of this interface limit access to the Track and add parameter checks to further prevent
+ * errors and ensure all API interactions to not damage the state of the track.
+ */
+@SuppressWarnings("unused")
+public interface Track {
+
+    String getName();
+
+    /**
+     * Gets an ordered list of the groups on this track
+     * @return am ordered {@link List} of the groups on this track
+     */
+    List<String> getGroups();
+
+    /**
+     * Gets the number of groups on this track
+     * @return the number of groups on this track
+     */
+    int getSize();
+
+    /**
+     * Gets the next group on the track, after the one provided
+     * @param current the group before the group being requested
+     * @return the group name, or null if the end of the track has been reached
+     * @throws ObjectLacksException if the track does not contain the group given
+     */
+    String getNext(Group current) throws ObjectLacksException;
+
+    /**
+     * Gets the group before the group provided
+     * @param current the group after the group being requested
+     * @return the group name, or null if the start of the track has been reached
+     * @throws ObjectLacksException if the track does not contain the group given
+     */
+    String getPrevious(Group current) throws ObjectLacksException;
+
+    /**
+     * Appends a group to the end of this track
+     * @param group the group to append
+     * @throws ObjectAlreadyHasException if the group is already on this track somewhere
+     */
+    void appendGroup(Group group) throws ObjectAlreadyHasException;
+
+    /**
+     * Inserts a group at a certain position on this track
+     * @param group the group to be inserted
+     * @param position the index position (a value of 0 inserts at the start)
+     * @throws ObjectAlreadyHasException if the group is already on this track somewhere
+     * @throws IndexOutOfBoundsException if the position is less than 0 or greater than the size of the track
+     */
+    void insertGroup(Group group, int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException;
+
+    /**
+     * Removes a group from this track
+     * @param group the group to remove
+     * @throws ObjectLacksException if the group is not on this track
+     */
+    void removeGroup(Group group) throws ObjectLacksException;
+
+    /**
+     * Removes a group from this track
+     * @param group the group to remove
+     * @throws ObjectLacksException if the group is not on this track
+     */
+    void removeGroup(String group) throws ObjectLacksException;
+
+    /**
+     * Checks if a group features on this track
+     * @param group the group to check
+     * @return true if the group is on this track
+     */
+    boolean containsGroup(Group group);
+
+    /**
+     * Checks if a group features on this track
+     * @param group the group to check
+     * @return true if the group is on this track
+     */
+    boolean containsGroup(String group);
+
+    /**
+     * Clear all of the groups within this track
+     */
+    void clearGroups();
+
+}

api/src/main/java/me/lucko/luckperms/api/User.java

@@ -0,0 +1,120 @@
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Wrapper interface for internal User instances
+ * The implementations of this interface limit access to the User and add parameter checks to further prevent
+ * errors and ensure all API interactions to not damage the state of the user.
+ */
+@SuppressWarnings("unused")
+public interface User extends PermissionObject {
+
+    UUID getUuid();
+    String getName();
+    String getPrimaryGroup();
+    void setPrimaryGroup(String s) throws ObjectAlreadyHasException;
+    void refreshPermissions();
+
+    /**
+     * Check to see if the user is a member of a group
+     * @param group The group to check membership of
+     * @return true if the user is a member of the group
+     */
+    boolean isInGroup(Group group);
+
+    /**
+     * Check to see if a user is a member of a group on a specific server
+     * @param group The group to check membership of
+     * @param server The server to check on
+     * @return true if the user is a member of the group
+     */
+    boolean isInGroup(Group group, String server);
+
+    /**
+     * Add a user to a group
+     * @param group The group to add the user to
+     * @throws ObjectAlreadyHasException if the user is already a member of the group
+     */
+    void addGroup(Group group) throws ObjectAlreadyHasException;
+
+    /**
+     * Add a user to a group on a specific server
+     * @param group The group to add the user to
+     * @param server The server to add the group on
+     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
+     */
+    void addGroup(Group group, String server) throws ObjectAlreadyHasException;
+
+    /**
+     * Add a user to a group on a specific server
+     * @param group The group to add the user to
+     * @param expireAt when the group should expire
+     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
+     */
+    void addGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Add a user to a group on a specific server
+     * @param group The group to add the user to
+     * @param server The server to add the group on
+     * @param expireAt when the group should expire
+     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
+     */
+    void addGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Remove the user from a group
+     * @param group the group to remove the user from
+     * @throws ObjectLacksException if the user isn't a member of the group
+     */
+    void removeGroup(Group group) throws ObjectLacksException;
+
+    /**
+     * Remove the user from a group
+     * @param group the group to remove the user from
+     * @param temporary if the group being removed is temporary
+     * @throws ObjectLacksException if the user isn't a member of the group
+     */
+    void removeGroup(Group group, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Remove the user from a group
+     * @param group The group to remove the user from
+     * @param server The server to remove the group on
+     * @throws ObjectLacksException if the user isn't a member of the group
+     */
+    void removeGroup(Group group, String server) throws ObjectLacksException;
+
+    /**
+     * Remove the user from a group
+     * @param group The group to remove the user from
+     * @param server The server to remove the group on
+     * @param temporary if the group being removed is temporary
+     * @throws ObjectLacksException if the user isn't a member of the group
+     */
+    void removeGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Clear all of the users permission nodes
+     */
+    void clearNodes();
+
+    /**
+     * Get a {@link List} of all of the groups the user is a member of, on all servers
+     * @return a {@link List} of group names
+     */
+    List<String> getGroupNames();
+
+    /**
+     * Get a {@link List} of the groups the user is a member of on a specific server
+     * @param server the server to check
+     * @return a {@link List} of group names
+     */
+    List<String> getLocalGroups(String server);
+
+}

api/src/main/java/me/lucko/luckperms/api/data/Callback.java

@@ -0,0 +1,11 @@
+package me.lucko.luckperms.api.data;
+
+import java.util.UUID;
+
+public interface Callback {
+    void onComplete(boolean success);
+
+    interface GetUUID {
+        void onComplete(UUID uuid);
+    }
+}

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

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

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

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