First commit (1.0.0)

src/main/java/me/monster/ranks/Main.java

@@ -0,0 +1,62 @@
+package me.monster.ranks;
+
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.config.configManager;
+import me.monster.ranks.utils.defaultGroups;
+import me.monster.ranks.utils.loaders.loadCommands;
+import me.monster.ranks.utils.loaders.loadListeners;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.sql.SQLException;
+
+public final class Main extends JavaPlugin {
+
+    public static Main plugin;
+    public static Plugin getPlugin() { return plugin; }
+    private static dbManager database;
+
+    @Override
+    public void onEnable() {
+        plugin = this;
+        // Plugin startup logic
+
+//        Config file creation and loading
+        new configManager().createConfigFiles();
+
+
+//        Database connection etc
+        database = new dbManager();
+        try {
+            database.initializeDatabase();
+        } catch (SQLException e) {
+            e.printStackTrace();
+            Main.getLogger("Could not initialize database. (" + e.getMessage() + ")");
+        }
+
+        new defaultGroups().createDefaultGroups();
+
+//        Load event listeners and commands
+
+        loadListeners.load();
+        loadCommands.load();
+    }
+
+
+
+    @Override
+    public void onDisable() {
+        // Plugin shutdown logic
+        Main.getLogger("Shutting down plugin");
+
+    }
+
+    public static void getLogger(String string) {
+        plugin.getLogger().info(string);
+    }
+
+    public static dbManager getDatabase() {
+        return database;
+    }
+
+}

src/main/java/me/monster/ranks/commands/test.java

@@ -0,0 +1,32 @@
+package me.monster.ranks.commands;
+
+import me.monster.ranks.utils.updatePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.SQLException;
+
+public class test implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String @NotNull [] args) {
+        if (sender.hasPermission("ranks.test")) {
+            if (sender instanceof Player p) {
+                try {
+                    new updatePlayer(p);
+                    return true;
+                } catch (SQLException e) {
+                    throw new RuntimeException(e);
+                }
+            } else {
+                sender.sendMessage("You must be a player to use this command");
+                return false;
+            }
+        } else {
+            sender.sendMessage("You don't have permission to use this command");
+            return false;
+        }
+    }
+}

src/main/java/me/monster/ranks/config/configManager.java

@@ -0,0 +1,41 @@
+package me.monster.ranks.config;
+
+import me.monster.ranks.Main;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+
+public class configManager {
+    static Plugin plugin = Main.getPlugin();
+
+
+    public void createConfigFiles() {
+
+        Main.getLogger("Creating config files...");
+        File configFile = new File(plugin.getDataFolder(), "config.yml");
+
+        if (!configFile.exists()) {
+            plugin.saveResource("config.yml", false);
+        }
+        Main.getLogger("Created config files");
+
+    }
+
+    static File configFile = new File(plugin.getDataFolder(), "config.yml");
+    public static @NotNull YamlConfiguration configFile() { return YamlConfiguration.loadConfiguration(configFile); }
+
+    public static void saveConfigFiles() {
+        Main.getLogger("Saving config");
+        plugin.saveConfig();
+    }
+
+    public void reloadConfigFiles() {
+        Main.getLogger("Reloading config");
+        plugin.reloadConfig();
+    }
+
+
+
+}

src/main/java/me/monster/ranks/database/dbManager.java

@@ -0,0 +1,117 @@
+package me.monster.ranks.database;
+
+import me.monster.ranks.Main;
+import me.monster.ranks.database.managers.groups;
+import me.monster.ranks.database.managers.permissions;
+import me.monster.ranks.database.managers.players;
+import me.monster.ranks.database.models.groupPermissions;
+import me.monster.ranks.config.configManager;
+import me.monster.ranks.database.models.ranks;
+import me.monster.ranks.database.models.userInfo;
+
+import java.sql.*;
+import java.util.List;
+
+public class dbManager {
+
+    private static Connection connection;
+
+    public static Connection getConnection() throws SQLException {
+
+        if(connection != null){
+            return connection;
+        }
+
+        String port = configManager.configFile().getString("mysql.port");
+        String host = configManager.configFile().getString("mysql.host");
+        String user = configManager.configFile().getString("mysql.user");
+        String password = configManager.configFile().getString("mysql.password");
+        String database = configManager.configFile().getString("mysql.database");
+        String url = "jdbc:mysql://" + host + ":" + port + "/" + database + "?autoReconnect=true";
+
+        Connection connection = DriverManager.getConnection(url, user, password);
+
+        dbManager.connection = connection;
+
+        Main.getLogger("Connected to database.");
+
+        return connection;
+    }
+
+    public void initializeDatabase() throws SQLException {
+
+        Statement statement = getConnection().createStatement();
+
+        String player_infoSQL = "CREATE TABLE IF NOT EXISTS player_info (uuid varchar(36), playerRank TEXT, temp INT, date DATETIME)";
+        String groupsSQL = "CREATE TABLE IF NOT EXISTS groups (groupName TEXT, groupPrefix TEXT, groupSuffix TEXT, groupWeight INT, groupParent TEXT)";
+        String groupsPermissionsSQL = "CREATE TABLE IF NOT EXISTS group_permissions (groupName TEXT, permission TEXT, value INT, context TEXT)";
+
+
+        statement.execute(player_infoSQL);
+        statement.execute(groupsSQL);
+        statement.execute(groupsPermissionsSQL);
+
+        statement.close();
+
+    }
+
+    //################################################
+    //########### Player Info Section ################
+    //################################################
+
+    public static userInfo findPlayerGroupByUUID(String string) throws SQLException {
+        return players.findPlayerGroupByUUID(string);
+    }
+    public static List<userInfo> findPlayerGroups(String uuid) throws SQLException {
+        return players.findPlayerGroups(uuid);
+    }
+    public static void deletePlayerGroups(userInfo databaseModel) throws SQLException {
+        players.deletePlayerGroups(databaseModel);
+    }
+    public static void updatePlayerGroups(userInfo databaseModel) throws SQLException {
+        players.updatePlayerGroups(databaseModel);
+    }
+    public static void createPlayer(userInfo databaseModel) throws SQLException {
+        players.createPlayer(databaseModel);
+    }
+
+    //################################################
+    //############# Groups  Section ##################
+    //################################################
+
+    public static void createGroup(ranks databaseModel) throws SQLException {
+        groups.createGroup(databaseModel);
+    }
+
+    public static void updateGroup(ranks databaseModel) throws SQLException {
+        groups.updateGroup(databaseModel);
+    }
+
+    public static void deleteGroup(ranks databaseModel) throws SQLException {
+        groups.deleteGroup(databaseModel);
+    }
+    public static ranks findGroupByName(String groupName) throws SQLException {
+        return groups.findGroupByName(groupName);
+    }
+
+    //################################################
+    //########### Permission  Section ################
+    //################################################
+
+    public static List<groupPermissions> fetchGroupPermissions(String groupName) throws SQLException {
+        return permissions.fetchGroupPermissions(groupName);
+    }
+
+    public static void updateGroupPermission(groupPermissions permission) throws SQLException {
+        permissions.updateGroupPermission(permission);
+    }
+
+    public static void addGroupPermission(groupPermissions permission) throws SQLException {
+        permissions.addGroupPermission(permission);
+    }
+
+    public static void deleteGroupPermission(String groupName, String permission, String context) throws SQLException {
+        permissions.deleteGroupPermission(groupName, permission, context);
+    }
+
+}

src/main/java/me/monster/ranks/database/managers/groups.java

@@ -0,0 +1,71 @@
+package me.monster.ranks.database.managers;
+
+import me.monster.ranks.Main;
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.ranks;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class groups extends dbManager {
+
+    public static void createGroup(ranks databaseModel) throws SQLException {
+
+        PreparedStatement statement = getConnection()
+                .prepareStatement("INSERT INTO groups (groupName, groupPrefix, groupSuffix, groupWeight, groupParent) VALUES (?, ?, ?, ?, ?)");
+        statement.setString(1, databaseModel.getGroupName());
+        statement.setString(2, databaseModel.getGroupPrefix());
+        statement.setString(3, databaseModel.getGroupSuffix());
+        statement.setInt(4, databaseModel.getGroupWeight());
+        statement.setString(5, databaseModel.getGroupParent());
+        statement.executeUpdate();
+        Main.getLogger("[Permissions Manager] Created group: " + databaseModel.getGroupName());
+        statement.close();
+
+    }
+
+    public static void updateGroup(ranks databaseModel) throws SQLException {
+
+        PreparedStatement statement = getConnection()
+                .prepareStatement("UPDATE groups SET groupName = ?, groupPrefix = ?, groupSuffix = ?, groupWeight = ?, groupParent = ? WHERE groupName = ?");
+        statement.setString(1, databaseModel.getGroupName());
+        statement.setString(2, databaseModel.getGroupPrefix());
+        statement.setString(3, databaseModel.getGroupSuffix());
+        statement.setInt(4, databaseModel.getGroupWeight());
+        statement.setString(5, databaseModel.getGroupParent());
+        statement.setString(6, databaseModel.getGroupName());
+        statement.executeUpdate();
+        Main.getLogger("[Permissions Manager] Updated group: " + databaseModel.getGroupName());
+        statement.close();
+    }
+
+    public static void deleteGroup(ranks databaseModel) throws SQLException {
+
+        PreparedStatement statement = getConnection().prepareStatement("DELETE FROM groups WHERE groupName = ?");
+        statement.setString(1, databaseModel.getGroupName());
+
+        statement.executeUpdate();
+
+        Main.getLogger("[Permissions Manager] Deleted group: " + databaseModel.getGroupName());
+        statement.close();
+    }
+
+
+    public static ranks findGroupByName(String groupName) throws SQLException {
+        PreparedStatement statement = getConnection().prepareStatement("SELECT * FROM groups WHERE groupName = ?");
+        statement.setString(1, groupName);
+        ResultSet resultSet = statement.executeQuery();
+        ranks databaseModel;
+        if(resultSet.next()){
+            databaseModel = new ranks(resultSet.getString("groupName"), resultSet.getString("groupPrefix"), resultSet.getString("groupSuffix"), resultSet.getInt("groupWeight"), resultSet.getString("groupParent"));
+            statement.close();
+            return databaseModel;
+        }
+        statement.close();
+        return null;
+    }
+
+
+
+}

src/main/java/me/monster/ranks/database/managers/permissions.java

@@ -0,0 +1,76 @@
+package me.monster.ranks.database.managers;
+
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.groupPermissions;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class permissions extends dbManager {
+
+    public static List<groupPermissions> fetchGroupPermissions(String groupName) throws SQLException {
+        String query = "SELECT * FROM group_permissions WHERE groupName = ?";
+        PreparedStatement statement = getConnection().prepareStatement(query);
+        statement.setString(1, groupName);
+
+        ResultSet resultSet = statement.executeQuery();
+        List<groupPermissions> permissions = new ArrayList<>();
+
+
+        while (resultSet.next()) {
+            groupPermissions permission = new groupPermissions(
+                    resultSet.getString("groupName"),
+                    resultSet.getString("permission"),
+                    resultSet.getInt("value"),
+                    resultSet.getString("context")
+            );
+            permissions.add(permission);
+        }
+
+        statement.close();
+        return permissions;
+    }
+
+    public static void updateGroupPermission(groupPermissions permission) throws SQLException {
+        String query = "UPDATE group_permissions SET permission = ?, value = ?, context = ? WHERE groupName = ? AND permission = ? AND context = ?";
+        PreparedStatement statement = getConnection().prepareStatement(query);
+
+        statement.setString(1, permission.getPermission());
+        statement.setInt(2, permission.getValue());
+        statement.setString(3, permission.getContext());
+        statement.setString(4, permission.getGroupName());
+        statement.setString(5, permission.getPermission());
+        statement.setString(6, permission.getContext());
+
+        statement.executeUpdate();
+        statement.close();
+    }
+
+    public static void addGroupPermission(groupPermissions permission) throws SQLException {
+        String query = "INSERT INTO group_permissions (groupName, permission, value, context) VALUES (?, ?, ?, ?)";
+        PreparedStatement statement = getConnection().prepareStatement(query);
+
+        statement.setString(1, permission.getGroupName());
+        statement.setString(2, permission.getPermission());
+        statement.setInt(3, permission.getValue());
+        statement.setString(4, permission.getContext());
+
+        statement.executeUpdate();
+        statement.close();
+    }
+
+    public static void deleteGroupPermission(String groupName, String permission, String context) throws SQLException {
+        String query = "DELETE FROM group_permissions WHERE groupName = ? AND permission = ? AND context = ?";
+        PreparedStatement statement = getConnection().prepareStatement(query);
+
+        statement.setString(1, groupName);
+        statement.setString(2, permission);
+        statement.setString(3, context);
+
+        statement.executeUpdate();
+        statement.close();
+    }
+}

src/main/java/me/monster/ranks/database/managers/players.java

@@ -0,0 +1,88 @@
+package me.monster.ranks.database.managers;
+
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.userInfo;
+
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class players extends dbManager {
+
+    public static userInfo findPlayerGroupByUUID(String uuid) throws SQLException {
+
+        PreparedStatement statement = getConnection().prepareStatement("SELECT * FROM player_info WHERE uuid = ?");
+        statement.setString(1, uuid);
+
+        ResultSet resultSet = statement.executeQuery();
+
+        userInfo databaseModel;
+
+        if(resultSet.next()){
+
+            databaseModel = new userInfo(resultSet.getString("uuid"), resultSet.getString("playerRank"), resultSet.getInt("temp"), resultSet.getDate("date"));
+            statement.close();
+            return databaseModel;
+        }
+
+        statement.close();
+
+        return null;
+    }
+
+    public static List<userInfo> findPlayerGroups(String uuid) throws SQLException {
+
+        PreparedStatement statement = getConnection().prepareStatement("SELECT * FROM player_info WHERE uuid = ?");
+        statement.setString(1, uuid);
+
+        ResultSet resultSet = statement.executeQuery();
+
+        List<userInfo> databaseModel = new ArrayList<>();  // Use ArrayList to hold all results
+
+        while (resultSet.next()) {
+            userInfo user = new userInfo(resultSet.getString("uuid"), resultSet.getString("playerRank"), resultSet.getInt("temp"), resultSet.getTimestamp("date"));
+            databaseModel.add(user);
+        }
+
+        statement.close();
+
+        return databaseModel.isEmpty() ? null : databaseModel;  // Return null if the list is empty
+    }
+
+
+    public static void createPlayer(userInfo databaseModel) throws SQLException {
+        PreparedStatement statement = getConnection()
+                .prepareStatement("INSERT INTO player_info (uuid, playerRank, temp, date) VALUES (?, ?, ?, ?)");
+        statement.setString(1, databaseModel.getPlayerUUID());
+        statement.setString(2, "default");
+        statement.setInt(3, 0);
+        statement.setDate(4, null);
+        statement.executeUpdate();
+        statement.close();
+    }
+
+    public static void updatePlayerGroups(userInfo databaseModel) throws SQLException {
+        PreparedStatement statement = getConnection().prepareStatement("UPDATE player_info SET playerRank = ?, temp = ?, date = ? WHERE uuid = ?");
+        statement.setString(1, databaseModel.getPlayerRank());
+        statement.setInt(2, databaseModel.getPlayerRankTemp());
+        statement.setDate(3, (Date) databaseModel.getDate());
+        statement.setString(4, databaseModel.getPlayerUUID());
+        statement.executeUpdate();
+        statement.close();
+    }
+
+    public static void deletePlayerGroups(userInfo databaseModel) throws SQLException {
+
+        PreparedStatement statement = getConnection().prepareStatement("DELETE FROM player_info WHERE uuid = ? AND playerRank = ?");
+        statement.setString(1, databaseModel.getPlayerUUID());
+        statement.setString(2, databaseModel.getPlayerRank());
+
+        statement.executeUpdate();
+
+        statement.close();
+    }
+
+}

src/main/java/me/monster/ranks/database/models/groupPermissions.java

@@ -0,0 +1,48 @@
+package me.monster.ranks.database.models;
+
+public class groupPermissions {
+
+    private String groupName;
+    private String permission;
+    private Integer value;
+    private String context;
+
+    public groupPermissions(String groupName, String permission, Integer value, String context) {
+        this.groupName = groupName;
+        this.permission = permission;
+        this.value = value;
+        this.context = context;
+    }
+
+    public String getGroupName() {
+        return groupName;
+    }
+
+    public void setGroupName(String groupName) {
+        this.groupName = groupName;
+    }
+
+    public String getPermission() {
+        return permission;
+    }
+
+    public void setPermission(String permission) {
+        this.permission = permission;
+    }
+
+    public Integer getValue() {
+        return value;
+    }
+
+    public void setValue(Integer value) {
+        this.value = value;
+    }
+
+    public String getContext() {
+        return context;
+    }
+
+    public void setContext(String context) {
+        this.context = context;
+    }
+}

src/main/java/me/monster/ranks/database/models/ranks.java

@@ -0,0 +1,58 @@
+package me.monster.ranks.database.models;
+
+public class ranks {
+    private String groupName;
+    private String groupPrefix;
+    private String groupSuffix;
+    private Integer groupWeight;
+    private String groupParent;
+
+    public ranks(String groupName, String groupPrefix, String groupSuffix, Integer groupWeight, String groupParent) {
+        this.groupName = groupName;
+        this.groupPrefix = groupPrefix;
+        this.groupSuffix = groupSuffix;
+        this.groupWeight = groupWeight;
+        this.groupParent = groupParent;
+    }
+
+    public String getGroupName() {
+        return groupName;
+    }
+
+    public void setGroupName(String groupName) {
+        this.groupName = groupName;
+    }
+
+    public String getGroupPrefix() {
+        return groupPrefix;
+    }
+
+    public void setGroupPrefix(String groupPrefix) {
+        this.groupPrefix = groupPrefix;
+    }
+
+    public String getGroupSuffix() {
+        return groupSuffix;
+    }
+
+    public void setGroupSuffix(String groupSuffix) {
+        this.groupSuffix = groupSuffix;
+    }
+
+    public Integer getGroupWeight() {
+        return groupWeight;
+    }
+
+    public void setGroupWeight(Integer groupWeight) {
+        this.groupWeight = groupWeight;
+    }
+
+    public String getGroupParent() {
+        return groupParent;
+    }
+
+    public void setGroupParent(String groupParent) {
+        this.groupParent = groupParent;
+    }
+
+}

src/main/java/me/monster/ranks/database/models/userInfo.java

@@ -0,0 +1,49 @@
+package me.monster.ranks.database.models;
+
+import java.util.Date;
+
+public class userInfo {
+    private String playerUUID;
+    private String playerRank;
+    private Integer temp;
+    private Date date;
+
+    public userInfo(String playerUUID, String playerRank, Integer temp, Date date) {
+        this.playerUUID = playerUUID;
+        this.playerRank = playerRank;
+        this.temp = temp;
+        this.date = date;
+    }
+
+    public String getPlayerUUID() {
+        return playerUUID;
+    }
+
+    public void setPlayerUUID(String playerUUID) {
+        this.playerUUID = playerUUID;
+    }
+
+    public String getPlayerRank() {
+        return playerRank;
+    }
+
+    public void setPlayerRank(String playerRank) {
+        this.playerRank = playerRank;
+    }
+
+    public Integer getPlayerRankTemp() {
+        return temp;
+    }
+
+    public void setPlayerRankTemp(Integer temp) {
+        this.temp = temp;
+    }
+
+    public Date getDate() {
+        return date;
+    }
+
+    public void setDate(Date date) {
+        this.date = date;
+    }
+}

src/main/java/me/monster/ranks/listeners/chatListener.java

@@ -0,0 +1,19 @@
+package me.monster.ranks.listeners;
+
+import me.monster.ranks.utils.groupsPriority;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class chatListener implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onChat(org.bukkit.event.player.AsyncPlayerChatEvent event) {
+        Player p = event.getPlayer();
+
+        event.setFormat(groupsPriority.getHighestPrefix(p) + " " + event.getPlayer().getDisplayName() + groupsPriority.getHighestSuffix(p) + ": " + event.getMessage());
+        event.setCancelled(false);
+    }
+
+}

src/main/java/me/monster/ranks/listeners/joinListener.java

@@ -0,0 +1,37 @@
+package me.monster.ranks.listeners;
+
+import me.monster.ranks.Main;
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.userInfo;
+import me.monster.ranks.utils.updatePlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import java.sql.SQLException;
+
+public class joinListener implements Listener {
+
+    public void createPlayer(Player player) throws SQLException {
+        userInfo userInfo2 = dbManager.findPlayerGroupByUUID(player.getUniqueId().toString());
+
+        if(userInfo2 == null) {
+            dbManager.createPlayer(new userInfo(player.getUniqueId().toString(), "default", 0, null));
+
+        }
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) throws SQLException {
+        Player p = event.getPlayer();
+        try {
+            createPlayer(p);
+        } catch (SQLException e) {
+            e.printStackTrace();
+            Main.getLogger("Could not update player stats after join.");
+        }
+        new updatePlayer(p);
+    }
+
+}

src/main/java/me/monster/ranks/permission/permissionManager.java

@@ -0,0 +1,88 @@
+package me.monster.ranks.permission;
+
+import me.monster.ranks.Main;
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.groupPermissions;
+import me.monster.ranks.database.models.ranks;
+import me.monster.ranks.utils.groupsPriority;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import static me.monster.ranks.config.configManager.configFile;
+
+public class permissionManager {
+
+    static HashMap<UUID, PermissionAttachment> perms = new HashMap<>();
+
+    private static final YamlConfiguration config = configFile();
+
+
+    public static void loadAndApplyPermissions(Player player) {
+        try {
+            // Step 1: Get the player's group and server context
+            ranks groupName = groupsPriority.getHighestGroup(player);
+
+            // Step 2: Fetch the permissions for the group and context
+            List<groupPermissions> permissions = dbManager.fetchGroupPermissions(groupName.getGroupName());
+
+            // Step 3: Apply the permissions to the player
+            applyPermissionsToPlayer(player, permissions);
+        } catch (SQLException e) {
+            e.printStackTrace();  // Log or handle the exception as needed
+        }
+    }
+
+    private static String getServerName() {
+        return config.getString("server.name");
+    }
+
+    private static void applyPermissionsToPlayer(Player player, List<groupPermissions> permissions) {
+        PermissionAttachment attachment = player.addAttachment(Main.getPlugin());
+        removePermissions(player, attachment);
+
+        // Clear existing permissions (optional: only if you need to refresh)
+        attachment.getPermissions().clear();
+
+        // Loop through all the permissions for the player's group
+        for (groupPermissions permission : permissions) {
+            String perm = permission.getPermission();
+            boolean allow = permission.getValue() == 1;  // 1 = allow, 0 = deny
+            if (permission.getContext().equals("server=" + getServerName()) || permission.getContext().isEmpty()) {
+                perms.put(player.getUniqueId(), attachment);
+                PermissionAttachment pperms = perms.get(player.getUniqueId());
+                pperms.setPermission(perm, allow);
+            }
+            if (permission.getPermission().equals("*")) {
+                getAllPermissions(player, attachment, allow);
+            }
+        }
+    }
+
+    public static void getAllPermissions(Player player, PermissionAttachment attachment, boolean allow) {
+        Set<Permission> permissions = Main.getPlugin().getServer().getPluginManager().getPermissions();
+        for (Permission permission : permissions) {
+            perms.put(player.getUniqueId(), attachment);
+            PermissionAttachment pperms = perms.get(player.getUniqueId());
+            pperms.setPermission(permission, allow);
+        }
+    }
+
+    public static void removePermissions(Player player, PermissionAttachment attachment) {
+        for (PermissionAttachmentInfo perm : player.getEffectivePermissions()) {
+            perms.put(player.getUniqueId(), attachment);
+            PermissionAttachment pperms = perms.get(player.getUniqueId());
+            pperms.unsetPermission(String.valueOf(perm));
+
+        }
+    }
+
+}

src/main/java/me/monster/ranks/utils/defaultGroups.java

@@ -0,0 +1,22 @@
+package me.monster.ranks.utils;
+
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.ranks;
+
+import java.sql.SQLException;
+
+public class defaultGroups {
+    public void createDefaultGroups() {
+
+        try {
+            if (dbManager.findGroupByName("default") == null) {
+                dbManager.createGroup(new ranks("default", "Player", "", 1, "default"));
+            }
+            if (dbManager.findGroupByName("owner") == null ){
+                dbManager.createGroup(new ranks("owner", "Owner ", "", 90, "default"));
+            }
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/me/monster/ranks/utils/groupsPriority.java

@@ -0,0 +1,57 @@
+package me.monster.ranks.utils;
+
+import me.monster.ranks.database.dbManager;
+import me.monster.ranks.database.models.ranks;
+import me.monster.ranks.database.models.userInfo;
+import org.bukkit.entity.Player;
+
+import java.sql.SQLException;
+import java.util.List;
+
+public class groupsPriority {
+
+    public static ranks getHighestGroup(Player p) throws SQLException {
+        // Get the list of groups associated with the player (userInfo objects)
+        List<userInfo> test = dbManager.findPlayerGroups(p.getUniqueId().toString());
+
+        String highestGroupName = null;
+        int highestWeight = Integer.MIN_VALUE; // Start with the lowest possible weight
+
+        // Loop through the list of groups associated with the player
+        for (userInfo userInfo : test) {
+            // Assuming test.get(i) contains some identifier that can be used to fetch the group
+            String groupName = userInfo.getPlayerRank();  // Replace with the correct method or field
+            ranks group = dbManager.findGroupByName(groupName); // Retrieve the group from the database
+
+            if (group != null) {
+                // Get the weight of the group
+                int weight = group.getGroupWeight();
+
+                // If the current group weight is higher than the previous highest, update the highest group
+                if (weight > highestWeight) {
+                    highestWeight = weight;
+                    highestGroupName = group.getGroupName();  // Return the group name with the highest weight
+                }
+            }
+        }
+
+        // Return the name of the group with the highest weight
+        return dbManager.findGroupByName(highestGroupName);
+    }
+
+    public static String getHighestPrefix(Player p) {
+        try {
+            return getHighestGroup(p).getGroupPrefix();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    public static String getHighestSuffix(Player p) {
+        try {
+            return getHighestGroup(p).getGroupSuffix();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
+

src/main/java/me/monster/ranks/utils/loaders/loadCommands.java

@@ -0,0 +1,83 @@
+package me.monster.ranks.utils.loaders;
+
+import me.monster.ranks.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.IOException;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.util.Objects;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class loadCommands {
+
+    public static void load() {
+        Plugin plugin = Main.getPlugin();
+        if (!(plugin instanceof JavaPlugin javaPlugin)) {
+            Bukkit.getLogger().severe("[Commands] Plugin is not an instance of JavaPlugin!");
+            return;
+        }
+
+        String packageName = javaPlugin.getClass().getPackage().getName() + ".commands";
+        Bukkit.getLogger().info("[Commands] Loading commands from package: " + packageName);
+
+        try {
+            for (Class<?> clazz : getClassesInJar(packageName, plugin)) {
+                if (!CommandExecutor.class.isAssignableFrom(clazz)) continue;
+
+                try {
+                    Object instance;
+                    try {
+                        instance = clazz.getDeclaredConstructor(Plugin.class).newInstance(plugin);
+                    } catch (NoSuchMethodException e) {
+                        instance = clazz.getDeclaredConstructor().newInstance();
+                    }
+
+                    String commandName = clazz.getSimpleName().toLowerCase(); // assuming command name is class name
+                    PluginCommand command = javaPlugin.getCommand(commandName);
+                    if (command != null) {
+                        command.setExecutor((CommandExecutor) instance);
+                        Bukkit.getLogger().info("[Commands] Registered: " + clazz.getSimpleName());
+                    } else {
+                        Bukkit.getLogger().warning("[Commands] Command not found for class: " + clazz.getSimpleName());
+                    }
+
+                } catch (NoSuchMethodException e) {
+                    Bukkit.getLogger().warning("[Commands] No valid constructor found for " + clazz.getSimpleName());
+                }
+            }
+        } catch (Exception e) {
+            Bukkit.getLogger().severe("[Commands] Failed to load commands:");
+            e.printStackTrace();
+        }
+    }
+
+    private static Class<?>[] getClassesInJar(String packageName, Plugin plugin) throws IOException {
+        String path = packageName.replace('.', '/');
+        URL url = plugin.getClass().getClassLoader().getResource(path);
+        if (url == null) return new Class<?>[0];
+
+        JarURLConnection connection = (JarURLConnection) url.openConnection();
+        JarFile jarFile = connection.getJarFile();
+
+        return jarFile.stream()
+                .filter(e -> e.getName().startsWith(path) && e.getName().endsWith(".class"))
+                .map(JarEntry::getName)
+                .map(name -> name.replace('/', '.').substring(0, name.length() - 6))
+                .map(className -> {
+                    try {
+                        return Class.forName(className);
+                    } catch (ClassNotFoundException e) {
+                        Bukkit.getLogger().warning("[Commands] Could not load class: " + className);
+                        return null;
+                    }
+                })
+                .filter(Objects::nonNull)
+                .toArray(Class<?>[]::new);
+    }
+}

src/main/java/me/monster/ranks/utils/loaders/loadListeners.java

@@ -0,0 +1,70 @@
+package me.monster.ranks.utils.loaders;
+
+import me.monster.ranks.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.Plugin;
+
+import java.io.IOException;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.util.Objects;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class loadListeners {
+
+    public static void load() {
+        Plugin plugin = Main.getPlugin();
+        String packageName = plugin.getClass().getPackage().getName() + ".listeners";
+        Bukkit.getLogger().info("[Listeners] Loading listeners from package: " + packageName);
+
+        try {
+            for (Class<?> clazz : getClassesInJar(packageName, plugin)) {
+                if (!Listener.class.isAssignableFrom(clazz)) continue;
+
+                try {
+                    Object instance;
+                    try {
+                        instance = clazz.getDeclaredConstructor(Plugin.class).newInstance(plugin);
+                    } catch (NoSuchMethodException e) {
+                        instance = clazz.getDeclaredConstructor().newInstance();
+                    }
+
+                    Bukkit.getPluginManager().registerEvents((Listener) instance, plugin);
+                    Bukkit.getLogger().info("[Listeners] Registered: " + clazz.getSimpleName());
+
+                } catch (NoSuchMethodException e) {
+                    Bukkit.getLogger().warning("[Listeners] No valid constructor found for " + clazz.getSimpleName());
+                }
+            }
+        } catch (Exception e) {
+            Bukkit.getLogger().severe("[Listeners] Failed to load listeners:");
+            e.printStackTrace();
+        }
+    }
+
+    private static Class<?>[] getClassesInJar(String packageName, Plugin plugin) throws IOException {
+        String path = packageName.replace('.', '/');
+        URL url = plugin.getClass().getClassLoader().getResource(path);
+        if (url == null) return new Class<?>[0];
+
+        JarURLConnection connection = (JarURLConnection) url.openConnection();
+        JarFile jarFile = connection.getJarFile();
+
+        return jarFile.stream()
+                .filter(e -> e.getName().startsWith(path) && e.getName().endsWith(".class"))
+                .map(JarEntry::getName)
+                .map(name -> name.replace('/', '.').substring(0, name.length() - 6))
+                .map(className -> {
+                    try {
+                        return Class.forName(className);
+                    } catch (ClassNotFoundException e) {
+                        Bukkit.getLogger().warning("[Listeners] Could not load class: " + className);
+                        return null;
+                    }
+                })
+                .filter(Objects::nonNull)
+                .toArray(Class<?>[]::new);
+    }
+}

src/main/java/me/monster/ranks/utils/updatePlayer.java

@@ -0,0 +1,20 @@
+package me.monster.ranks.utils;
+
+import me.monster.ranks.database.models.ranks;
+import me.monster.ranks.permission.permissionManager;
+import org.bukkit.entity.Player;
+
+import java.sql.SQLException;
+
+public class updatePlayer {
+    public updatePlayer(Player player) throws SQLException {
+
+        ranks highestGroup = groupsPriority.getHighestGroup(player);
+
+        player.setPlayerListName(highestGroup.getGroupPrefix() + " " + player.getName());
+        permissionManager.loadAndApplyPermissions(player);
+        player.recalculatePermissions();
+        player.updateCommands();
+        player.sendMessage("Your group has been updated to " + highestGroup.getGroupName());
+    }
+}

src/main/resources/config.yml

@@ -0,0 +1,9 @@
+mysql:
+  host: 127.0.0.1
+  port: 3306
+  user: root
+  password: password
+  database: permission
+
+server:
+  name: "server_name"

src/main/resources/plugin.yml

@@ -0,0 +1,12 @@
+name: Ranks
+version: '1.0'
+main: me.monster.ranks.Main
+api-version: '1.21'
+prefix: Ranks
+load: STARTUP
+authors: [ 41ms_ ]
+website: 41ms.fr
+
+commands:
+  test:
+    description: test command