Massive cleaning of SQL, ladder loading

Author: Innectic

API/src/main/java/me/innectic/permissify/api/database/DatabaseHandler.java

@@ -43,6 +43,7 @@ public abstract class DatabaseHandler {
     @Getter protected Map<UUID, List<Permission>> cachedPermissions = new HashMap<>();
     @Getter protected Map<String, PermissionGroup> cachedGroups = new HashMap<>();
     @Getter protected Optional<PermissionGroup> defaultGroup = Optional.empty();
+    @Getter protected Map<String, AbstractLadder> cachedLadders = new HashMap<>();
     @Getter protected final Optional<ConnectionInformation> connectionInformation;
     @Getter protected List<UUID> superAdmins = new ArrayList<>();
     // Revisit: Maybe different default formatters?
@@ -72,6 +73,21 @@ public DatabaseHandler(ConnectionInformation connectionInformation) {
      */
     public abstract void reload(List<UUID> onlinePlayers);
 
+    /**
+     * Load all groups
+     */
+    protected abstract void loadGroups();
+
+    /**
+     * Load all ladders
+     */
+    protected abstract void loadLadders();
+
+    /**
+     * Load all super admins
+     */
+    protected abstract void loadSuperAdmins();
+
     /**
      * Drop all values from the handler.
      */
@@ -240,6 +256,13 @@ public DatabaseHandler(ConnectionInformation connectionInformation) {
      */
     public abstract boolean isSuperAdmin(UUID uuid);
 
+    /***
+     * Remove a superadmin.
+     *
+     * @param uuid the uuid of the player to remove
+     */
+    public abstract void removeSuperAdmin(UUID uuid);
+
     /**
      * Set the format for chat messages
      *
@@ -277,6 +300,19 @@ public DatabaseHandler(ConnectionInformation connectionInformation) {
      */
     public abstract void setDefaultGroup(PermissionGroup group);
 
+    /**
+     * Set the ladder of a group.
+     *
+     * @param group  the name of the group
+     * @param ladder the ladder to add to the group
+     */
     public abstract void setGroupLadder(String group, AbstractLadder ladder);
+
+    /**
+     * Get the current ladder of a group.
+     *
+     * @param group the name of the group to get the ladder from
+     * @return      the ladder, if present.
+     */
     public abstract Optional<AbstractLadder> getGroupLadder(String group);
 }

API/src/main/java/me/innectic/permissify/api/database/handlers/SQLHandler.java

@@ -31,7 +31,9 @@
 import me.innectic.permissify.api.database.ConnectionInformation;
 import me.innectic.permissify.api.group.group.PermissionGroup;
 import me.innectic.permissify.api.group.ladder.AbstractLadder;
+import me.innectic.permissify.api.group.ladder.LadderLevel;
 import me.innectic.permissify.api.group.ladder.impl.DefaultLadder;
+import me.innectic.permissify.api.group.ladder.impl.LadderBuilder;
 import me.innectic.permissify.api.profile.PermissifyProfile;
 import me.innectic.permissify.api.util.FormatterType;
 
@@ -55,7 +57,6 @@ public SQLHandler(ConnectionInformation connectionInformation) {
 
         if(connectionInformation.getMeta().containsKey("sqlite")) {
             type = "sqlite";
-            // TODO: It would be nice to give this types...
             Map sqliteData = (Map) connectionInformation.getMeta().get("sqlite");
             databaseUrl = (String) sqliteData.get("file");
             isUsingSqlite = true;
@@ -93,23 +94,25 @@ public void initialize() {
             else connection = Optional.ofNullable(DriverManager.getConnection(baseConnectionURL, connectionInformation.get().getUsername(), connectionInformation.get().getPassword()));
             if (!connection.isPresent()) return;
             String database = connectionInformation.get().getDatabase();
-            if (!database.equals("")) database += ".";
+            if (!database.equals("")) database = ".";
             // TODO: This should all be prepared statements, but that breaks for some reason
             if (!isUsingSqlite) {
                 PreparedStatement databaseStatement = connection.get().prepareStatement("CREATE DATABASE IF NOT EXISTS " + database);
                 databaseStatement.execute();
                 databaseStatement.close();
             }
 
-            PreparedStatement groupMembersStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database + "groupMembers (uuid VARCHAR(767) NOT NULL, `group` VARCHAR(700) NOT NULL, `primary` TINYINT NOT NULL)");
+            PreparedStatement groupMembersStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database +
+                    "groupMembers (uuid VARCHAR(767) NOT NULL, `group` VARCHAR(700) NOT NULL, `primary` TINYINT NOT NULL, ladderPosition INTEGER NOT NULL)");
             groupMembersStatement.execute();
             groupMembersStatement.close();
 
             PreparedStatement groupPermissionsStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database +"groupPermissions (groupName VARCHAR(767) NOT NULL, permission VARCHAR(767) NOT NULL)");
             groupPermissionsStatement.execute();
             groupPermissionsStatement.close();
 
-            PreparedStatement groupsStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database + "groups (name VARCHAR(100) NOT NULL UNIQUE, prefix VARCHAR(100) NOT NULL, suffix VARCHAR(100) NOT NULL, chatcolor VARCHAR(4) NOT NULL, defaultGroup TINYINT NOT NULL)");
+            PreparedStatement groupsStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database +
+                    "groups (name VARCHAR(100) NOT NULL UNIQUE, prefix VARCHAR(100) NOT NULL, suffix VARCHAR(100) NOT NULL, chatcolor VARCHAR(4) NOT NULL, defaultGroup TINYINT NOT NULL, ladder VARCHAR(767))");
             groupsStatement.execute();
             groupsStatement.close();
 
@@ -121,6 +124,14 @@ public void initialize() {
             superAdminStatement.execute();
             superAdminStatement.close();
 
+            PreparedStatement ladderStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database + "ladders (name VARCHAR(767))");
+            ladderStatement.execute();
+            ladderStatement.close();
+
+            PreparedStatement ladderLevelStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database + "ladderLevels (ladder VARCHAR(767), name VARCHAR(767), power INTEGER)");
+            ladderLevelStatement.execute();
+            ladderLevelStatement.close();
+
             if (!hasFormattingTable(connection.get(), database)) {
                 PreparedStatement formattingStatement = connection.get().prepareStatement("CREATE TABLE IF NOT EXISTS " + database + "formatting (`format` VARCHAR(400) NOT NULL, formatter VARCHAR(200) NOT NULL)");
                 formattingStatement.execute();
@@ -163,59 +174,131 @@ public void reload(List<UUID> onlinePlayers) {
         cachedGroups = new HashMap<>();
         cachedPermissions = new HashMap<>();
         superAdmins = new ArrayList<>();
+        cachedLadders = new HashMap<>();
 
         chatFormat = getChatFormat(true);
         whisperFormat = getWhisperFormat(true);
 
+        loadSuperAdmins();
+        loadLadders();
+        loadGroups();
+
+        onlinePlayers.forEach(this::getPermissions);
+    }
+
+    @Override
+    protected void loadGroups() {
         Optional<Connection> connection = getConnection();
-        if (connection.isPresent()) {
-            try {
-                // Load all super admins
-                PreparedStatement adminStatement = connection.get().prepareStatement("SELECT uuid FROM superAdmin");
-                ResultSet adminResults = adminStatement.executeQuery();
-                while (adminResults.next()) {
-                    superAdmins.add(UUID.fromString(adminResults.getString("uuid")));
+        if (!connection.isPresent()) {
+            PermissifyAPI.get().ifPresent(api -> api.getDisplayUtil().displayError(ConnectionError.REJECTED, Optional.empty()));
+            return;
+        }
+
+        try {
+            PreparedStatement groupStatement = connection.get().prepareStatement("SELECT * from groups");
+            ResultSet groupResults = groupStatement.executeQuery();
+            while (groupResults.next()) {
+                String groupName = groupResults.getString("name");
+                PermissionGroup group = new PermissionGroup(groupName,
+                        groupResults.getString("chatcolor"),
+                        groupResults.getString("prefix"),
+                        groupResults.getString("suffix"), getGroupLadder(groupName).orElse(new DefaultLadder()));
+                String ladder = groupResults.getString("ladder");
+                ladder = ladder == null || ladder.equals("") ? null : ladder;
+
+                PreparedStatement groupPermissionsStatement = connection.get().prepareStatement("SELECT * FROM groupPermissions WHERE groupName=?");
+                groupPermissionsStatement.setString(1, group.getName());
+                ResultSet groupPermissionsResult = groupPermissionsStatement.executeQuery();
+
+                while (groupPermissionsResult.next()) {
+                    group.addPermission(groupPermissionsResult.getString("permission"));
                 }
-                adminResults.close();
-                adminStatement.close();
-
-                // Load all group names
-                PreparedStatement groupStatement = connection.get().prepareStatement("SELECT * from groups");
-                ResultSet groupResults = groupStatement.executeQuery();
-                while (groupResults.next()) {
-                    String groupName = groupResults.getString("name");
-                    PermissionGroup group = new PermissionGroup(groupName,
-                            groupResults.getString("chatcolor"),
-                            groupResults.getString("prefix"),
-                            groupResults.getString("suffix"), getGroupLadder(groupName).orElse(new DefaultLadder()));
-                    PreparedStatement groupPermissionsStatement = connection.get().prepareStatement("SELECT  * FROM groupPermissions WHERE groupName=?");
-                    groupPermissionsStatement.setString(1, group.getName());
-                    ResultSet groupPermissionsResult = groupPermissionsStatement.executeQuery();
-                    while (groupPermissionsResult.next()) {
-                        group.addPermission(groupPermissionsResult.getString("permission"));
-                    }
-                    groupPermissionsResult.close();
-                    groupPermissionsStatement.close();
-
-                    PreparedStatement groupMembersStatement = connection.get().prepareStatement("SELECT uuid,`primary` FROM groupMembers WHERE `group`=?");
-                    groupMembersStatement.setString(1, group.getName());
-                    ResultSet groupMembersResults = groupMembersStatement.executeQuery();
-                    while (groupMembersResults.next()) {
-                        group.addPlayer(UUID.fromString(groupMembersResults.getString("uuid")), groupMembersResults.getBoolean("primary"));
-                    }
-                    groupMembersResults.close();
-                    groupMembersStatement.close();
-                    cachedGroups.put(groupName, group);
-                    if (groupResults.getBoolean("defaultGroup")) defaultGroup = Optional.of(group);
+                groupPermissionsResult.close();
+                groupPermissionsStatement.close();
+
+                PreparedStatement groupMembersStatement = connection.get().prepareStatement("SELECT uuid,`primary` FROM groupMembers WHERE `group`=?");
+                groupMembersStatement.setString(1, group.getName());
+
+                ResultSet groupMembersResults = groupMembersStatement.executeQuery();
+                while (groupMembersResults.next()) {
+                    group.addPlayer(UUID.fromString(groupMembersResults.getString("uuid")), groupMembersResults.getBoolean("primary"));
                 }
-                groupStatement.close();
-                groupResults.close();
-                connection.get().close();
-            } catch (SQLException e) {
-                PermissifyAPI.get().ifPresent(api -> api.getDisplayUtil().displayError(ConnectionError.REJECTED, Optional.of(e)));
+
+                if (ladder == null) {
+                    // Default ladder
+                    group.setLadder(new DefaultLadder());
+                } else {
+                    // Get the built ladder
+                    group.setLadder(cachedLadders.getOrDefault(ladder, new DefaultLadder()));
+                }
+
+                groupMembersResults.close();
+                groupMembersStatement.close();
+                cachedGroups.put(groupName, group);
+
+                if (groupResults.getBoolean("defaultGroup")) defaultGroup = Optional.of(group);
             }
-        } else PermissifyAPI.get().ifPresent(api -> api.getDisplayUtil().displayError(ConnectionError.REJECTED, Optional.empty()));
-        onlinePlayers.forEach(this::getPermissions);
+            groupResults.close();
+            groupStatement.close();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    protected void loadLadders() {
+        Optional<Connection> connection = getConnection();
+        if (!connection.isPresent()) {
+            PermissifyAPI.get().ifPresent(api -> api.getDisplayUtil().displayError(ConnectionError.REJECTED, Optional.empty()));
+            return;
+        }
+
+        try {
+            PreparedStatement ladderNameStatements = connection.get().prepareStatement("SELECT * FROM ladders");
+            ResultSet ladderNameResults = ladderNameStatements.executeQuery();
+
+            while (ladderNameResults.next()) {
+                String ladderName = ladderNameResults.getString("name");
+
+                List<LadderLevel> levels = new ArrayList<>();
+                PreparedStatement ladderLevelsStatement = connection.get().prepareStatement("SELECT * FROM ladderLevels where ladder=?");
+                ResultSet ladderLevelsResults = ladderLevelsStatement.executeQuery();
+
+                while (ladderLevelsResults.next()) {
+                    String levelName = ladderLevelsResults.getString("name");
+                    int levelPower = ladderLevelsResults.getInt("power");
+
+                    levels.add(new LadderLevel(levelPower, Optional.of(levelName)));
+                }
+
+                LadderBuilder ladderBuilder = new LadderBuilder(new HashMap<>(), levels);
+                cachedLadders.put(ladderName, ladderBuilder);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    protected void loadSuperAdmins() {
+        Optional<Connection> connection = getConnection();
+        if (!connection.isPresent()) {
+            PermissifyAPI.get().ifPresent(api -> api.getDisplayUtil().displayError(ConnectionError.REJECTED, Optional.empty()));
+            return;
+        }
+        try {
+            // Load all super admins
+            PreparedStatement adminStatement = connection.get().prepareStatement("SELECT uuid FROM superAdmin");
+            ResultSet adminResults = adminStatement.executeQuery();
+            while (adminResults.next()) {
+                superAdmins.add(UUID.fromString(adminResults.getString("uuid")));
+            }
+            adminResults.close();
+            adminStatement.close();
+            connection.get().close();
+        } catch (SQLException e) {
+            PermissifyAPI.get().ifPresent(api -> api.getDisplayUtil().displayError(ConnectionError.REJECTED, Optional.of(e)));
+        }
     }
 
     @Override
@@ -678,6 +761,11 @@ public boolean isSuperAdmin(UUID uuid) {
         return superAdmins.contains(uuid);
     }
 
+    @Override
+    public void removeSuperAdmin(UUID uuid) {
+
+    }
+
     @Override
     public void setChatFormat(String format) {
         this.chatFormat = format;

API/src/main/java/me/innectic/permissify/api/group/ladder/AbstractLadder.java

@@ -33,21 +33,31 @@
  * @since 9/1/2017
  */
 public abstract class AbstractLadder {
-    @Getter protected Map<UUID, LadderLevel> players = new HashMap<>();
+    @Getter protected Map<UUID, Integer> players = new HashMap<>();
     @Getter protected List<LadderLevel> levels = new ArrayList<>();
 
     public final void reset() {
         drop();
         registerLadders();
     }
 
-    public final void drop() {
+    private void drop() {
         players = new HashMap<>();
         levels = new ArrayList<>();
     }
 
     public abstract void registerLadders();
 
+    public final void addPlayer(UUID uuid, int position) {
+        players.put(uuid, position);
+        // TODO: Apply extra permissions
+    }
+
+    public final void removePlayer(UUID uuid) {
+        if (players.containsKey(uuid)) players.remove(uuid);
+        // TODO: Remove extra permissions
+    }
+
     @Override
     public String toString() {
         return "AbstractLadder [" +

API/src/main/java/me/innectic/permissify/api/group/ladder/LadderAdapter.java

@@ -34,22 +34,22 @@
 public class LadderAdapter implements JsonSerializer<AbstractLadder>, JsonDeserializer<AbstractLadder> {
 
     @Override
-    public JsonElement serialize(AbstractLadder src, Type typeOfSrc, JsonSerializationContext context) {
+    public JsonElement serialize(AbstractLadder ladder, Type type, JsonSerializationContext context) {
         JsonObject result = new JsonObject();
-        result.add("type", new JsonPrimitive(src.getClass().getSimpleName()));
-        result.add("data", context.serialize(src, src.getClass()));
+        result.add("type", new JsonPrimitive(ladder.getClass().getSimpleName()));
+        result.add("data", context.serialize(ladder, ladder.getClass()));
         return result;
     }
 
     @Override
-    public AbstractLadder deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+    public AbstractLadder deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
         JsonObject jsonObject = json.getAsJsonObject();
-        String type = jsonObject.get("type").getAsString();
+        String typeName = jsonObject.get("type").getAsString();
         JsonElement element = jsonObject.get("data");
         try {
             return context.deserialize(element, Class.forName("me.innectic.permissify.api.group.ladder.impl." + type));
         } catch (ClassNotFoundException e) {
-            throw new JsonParseException("Unknown element type: " + type, e);
+            throw new JsonParseException("Unknown element: " + typeName, e);
         }
     }
 }

API/src/main/java/me/innectic/permissify/api/group/ladder/impl/DefaultLadder.java

@@ -21,7 +21,8 @@
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
- */package me.innectic.permissify.api.group.ladder.impl;
+ */
+package me.innectic.permissify.api.group.ladder.impl;
 
 import me.innectic.permissify.api.group.ladder.AbstractLadder;
 import me.innectic.permissify.api.group.ladder.LadderLevel;
@@ -38,9 +39,6 @@ public class DefaultLadder extends AbstractLadder {
 
     @Override
     public void registerLadders() {
-        // Default ladders will only have 2 levels: default, admin. I don't care about display differences.
-        // TODO: Should I actually care about having names for the default ladders?
-
         this.levels.add(new LadderLevel(0, Optional.empty()));
         this.levels.add(new LadderLevel(1, Optional.empty()));
     }