Finishing Up Gangs

src/main/java/me/nvus/nvus_prison_setup/Database/DatabaseManager.java

@@ -9,20 +9,42 @@ import java.sql.Statement;
 import java.util.UUID;
 import java.io.File;
 
+import me.nvus.nvus_prison_setup.Configs.ConfigManager;
+import org.bukkit.configuration.file.FileConfiguration;
+
 public class DatabaseManager {
 
+    private ConfigManager configManager;
     private String url;
-    public DatabaseManager(File dataFolder) {
+
-        // Construct the file path for the SQLite database
+    public DatabaseManager(ConfigManager configManager) {
-        File databaseFile = new File(dataFolder, "nvus_prison.db");
+        this.configManager = configManager;
-        this.url = "jdbc:sqlite:" + databaseFile.getAbsolutePath();
+        loadDatabaseConfig();
         initializeDatabase();
     }
 
+//    public DatabaseManager(File dataFolder) {
+//        // Construct the file path for the SQLite database
+//        File databaseFile = new File(dataFolder, "nvus_prison.db");
+//        this.url = "jdbc:sqlite:" + databaseFile.getAbsolutePath();
+//        initializeDatabase();
+//    }
+
     public DatabaseManager() {
         initializeDatabase();
     }
 
+    private void loadDatabaseConfig() {
+        FileConfiguration config = configManager.getConfig("config.yml");
+        String host = config.getString("host", "localhost");
+        int port = config.getInt("port", 3306);
+        String database = config.getString("database", "nvus_prison");
+        String username = config.getString("username", "root");
+        String password = config.getString("password", "");
+
+        // Adjust this URL format according to your DBMS (MySQL in this case)
+        this.url = "jdbc:mysql://" + host + ":" + port + "/" + database + "?user=" + username + "&password=" + password;
+    }
 
     private Connection connect() {
         Connection conn = null;
@@ -184,6 +206,22 @@ public class DatabaseManager {
         return true;
     }
 
+    public String getMemberRank(UUID playerUuid, String gangName) {
+        String sql = "SELECT m.rank FROM members m INNER JOIN gangs g ON m.gang_id = g.id WHERE m.uuid = ? AND g.name = ?";
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, playerUuid.toString());
+            pstmt.setString(2, gangName);
+            ResultSet rs = pstmt.executeQuery();
+            if (rs.next()) {
+                return rs.getString("rank");
+            }
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+        return null; // Return null if the member's rank was not found or an error occurs
+    }
+
     public boolean updateMemberRank(UUID playerUuid, String gangName, String newRank) {
         String sql = "UPDATE members SET rank = ? WHERE uuid = ? AND gang_id = (SELECT id FROM gangs WHERE name = ?)";
 
@@ -218,6 +256,4 @@ public class DatabaseManager {
     }
 
 
-
-
 }

src/main/java/me/nvus/nvus_prison_setup/Gangs/GangCommands.java

@@ -16,6 +16,7 @@ public class GangCommands implements CommandExecutor {
         this.gangManager = new GangManager(dbManager);
     }
 
+    @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (!(sender instanceof Player)) {
             sender.sendMessage("Only players can execute this command.");
@@ -23,31 +24,98 @@ public class GangCommands implements CommandExecutor {
         }
 
         Player player = (Player) sender;
-        UUID playerUuid = player.getUniqueId();
 
-        if (args.length == 0 || (args.length == 1 && args[0].equalsIgnoreCase("gang"))) {
+        // Display help if no arguments are provided or if the first argument is "help"
-            // No subcommand specified, or only "gang" was specified
+        if (args.length == 0 || (args.length == 1 && args[0].equalsIgnoreCase("help"))) {
             sendGangCommandHelp(player);
             return true;
-        } else if (args.length >= 1 && args[0].equalsIgnoreCase("gang")) {
+        }
-            // A subcommand is specified, handle it accordingly
+
-            switch (args[1].toLowerCase()) {
+        switch (args[0].toLowerCase()) {
             case "create":
                 return handleGangCreate(player, args);
             case "invite":
                 return handleGangInvite(sender, args);
             case "accept":
-                    return handleGangAccept(player, playerUuid);
+                return handleGangAccept(player, player.getUniqueId());
             case "deny":
-                    return handleGangDeny(player, playerUuid);
+                return handleGangDeny(player, player.getUniqueId());
             case "leave":
-                    return handleGangLeave(player, playerUuid);
+                return handleGangLeave(player, player.getUniqueId());
+            case "promote":
+                return handleGangPromote(sender, args);
+            case "kick":
+                return handleGangKick(sender, args);
             default:
-                    player.sendMessage("Invalid gang command.");
+                player.sendMessage(ChatColor.RED + "Invalid gang command. Use /gang help for a list of commands.");
                 return true;
         }
     }
-        return false;
+
+    private boolean handleGangPromote(CommandSender sender, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage("Only players can execute this command.");
+            return true;
+        }
+        if (args.length != 3) {
+            sender.sendMessage(ChatColor.RED + "Usage: /gang promote <player>");
+            return true;
+        }
+
+        Player player = (Player) sender;
+        Player targetPlayer = player.getServer().getPlayer(args[2]);
+        if (targetPlayer == null) {
+            player.sendMessage(ChatColor.RED + "Player not found: " + args[2]);
+            return true;
+        }
+
+        String gangName = gangManager.getCurrentGangName(player.getUniqueId());
+        if (gangName == null) {
+            player.sendMessage(ChatColor.RED + "You are not in a gang.");
+            return true;
+        }
+
+        boolean success = gangManager.promoteMember(player.getUniqueId(), targetPlayer.getUniqueId(), gangName);
+        if (success) {
+            player.sendMessage(ChatColor.GREEN + "Successfully promoted " + targetPlayer.getName() + ".");
+        } else {
+            player.sendMessage(ChatColor.RED + "Failed to promote " + targetPlayer.getName() + ".");
+        }
+
+        return true;
+    }
+
+    private boolean handleGangKick(CommandSender sender, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage("Only players can execute this command.");
+            return true;
+        }
+        if (args.length != 3) {
+            sender.sendMessage(ChatColor.RED + "Usage: /gang kick <player>");
+            return true;
+        }
+
+        Player player = (Player) sender;
+        Player targetPlayer = player.getServer().getPlayer(args[2]);
+        if (targetPlayer == null) {
+            player.sendMessage(ChatColor.RED + "Player not found: " + args[2]);
+            return true;
+        }
+
+        String gangName = gangManager.getCurrentGangName(player.getUniqueId());
+        if (gangName == null) {
+            player.sendMessage(ChatColor.RED + "You are not in a gang.");
+            return true;
+        }
+
+        boolean success = gangManager.kickMember(player.getUniqueId(), targetPlayer.getUniqueId(), gangName);
+        if (success) {
+            player.sendMessage(ChatColor.GREEN + "Successfully kicked " + targetPlayer.getName() + " from the gang.");
+        } else {
+            player.sendMessage(ChatColor.RED + "Failed to kick " + targetPlayer.getName() + ".");
+        }
+
+        return true;
     }
 
     private void sendGangCommandHelp(Player player) {
@@ -73,8 +141,14 @@ public class GangCommands implements CommandExecutor {
 
 
     private boolean handleGangCreate(Player player, String[] args) {
+        // Check if the player has the required permission
+        if (!player.hasPermission("nvus.gang.create")) {
+            player.sendMessage(ChatColor.RED + "You do not have permission to create a gang.");
+            return true;
+        }
+
         if (args.length != 2) {
-            player.sendMessage("Usage: /gang create <gangName>");
+            player.sendMessage(ChatColor.RED + "Usage: /gang create <gangName>");
             return true;
         }
 
@@ -83,19 +157,20 @@ public class GangCommands implements CommandExecutor {
         // Check if the player already belongs to a gang
         String currentGang = gangManager.getCurrentGangName(player.getUniqueId());
         if (currentGang != null) {
-            player.sendMessage("You already belong to a gang.");
+            player.sendMessage(ChatColor.RED + "You already belong to a gang.");
             return true;
         }
 
         // Create the gang
         if (gangManager.createGang(gangName, player)) {
-            player.sendMessage("Gang created successfully!");
+            player.sendMessage(ChatColor.GREEN + "Gang created successfully!");
         } else {
-            player.sendMessage("Failed to create gang. The gang may already exist.");
+            player.sendMessage(ChatColor.RED + "Failed to create gang. The gang may already exist.");
         }
         return true;
     }
 
+
     private boolean handleGangInvite(CommandSender sender, String[] args) {
         if (args.length != 3) {
             sender.sendMessage("Usage: /nvus gang invite <playerName> <gangName>");

src/main/java/me/nvus/nvus_prison_setup/Gangs/GangManager.java

@@ -6,98 +6,95 @@ import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
 public class GangManager {
-
     private final DatabaseManager dbManager;
 
     public GangManager(DatabaseManager dbManager) {
         this.dbManager = dbManager;
     }
 
-    public boolean createGang(String gangName, Player owner) {
+    public enum GangRank {
-        UUID ownerUuid = owner.getUniqueId();
+        OWNER,
-        String ownerUuidString = ownerUuid.toString();
+        CAPO,
-
+        MEMBER
-        // Check if the gang already exists
-        if (dbManager.getGangIdByName(gangName) != null) {
-            return false;
     }
 
-        // Create the gang in the database
+    // Assuming a simplified model where the next rank is simply the next ordinal in the enum
-        dbManager.createGang(gangName, ownerUuidString);
+    public String getNextRank(String currentRank) {
+        try {
+            GangRank current = GangRank.valueOf(currentRank.toUpperCase());
+            int nextOrdinal = current.ordinal() + 1;
+            if (nextOrdinal < GangRank.values().length) {
+                return GangRank.values()[nextOrdinal].name();
+            }
+        } catch (IllegalArgumentException e) {
+            // Handle invalid rank input
+        }
+        return currentRank;
+    }
+
+    public boolean createGang(String gangName, Player owner) {
+        if (dbManager.getGangIdByName(gangName) != null) return false;
+        dbManager.createGang(gangName, owner.getUniqueId().toString());
         return true;
     }
 
-
-    // Method to add a member to a gang
     public boolean addMemberToGang(String username, UUID uuid, String gangName, String rank) {
         Integer gangId = dbManager.getGangIdByName(gangName);
-        if (gangId == null) {
+        if (gangId == null) return false;
-            // Gang does not exist
+        return dbManager.addMember(uuid.toString(), username, gangId, rank);
-            return false;
-        }
-        // Add the member to the gang with the specified rank
-        dbManager.addMember(uuid.toString(), username, gangId, rank);
-        return true;
     }
 
-    // Check if a player can invite others to the gang
     public boolean canInvite(UUID playerUuid) {
-        // Implement logic to check if the player has the rank of Owner or Capo
+        String rank = dbManager.getMemberRank(playerUuid, getCurrentGangName(playerUuid));
-        // This requires a method in DatabaseManager to check the player's rank in their gang
+        return GangRank.OWNER.name().equalsIgnoreCase(rank) || GangRank.CAPO.name().equalsIgnoreCase(rank);
-        return dbManager.canInvite(playerUuid.toString());
     }
 
-    // Add an invitation to the gang
+    public boolean canKickOrPromote(UUID playerUuid, String gangName) {
-    public boolean addInvitation(UUID playerUuid, String gangName) {
+        String rank = dbManager.getMemberRank(playerUuid, gangName);
-        // For simplicity, this example directly adds the player to the gang
+        return GangRank.OWNER.name().equalsIgnoreCase(rank) || GangRank.CAPO.name().equalsIgnoreCase(rank);
-        // You might want to implement a more complex invitation system
-        Integer gangId = dbManager.getGangIdByName(gangName);
-        if (gangId == null) {
-            // Gang does not exist
-            return false;
     }
-        // Assume a default rank for new invites, e.g., "Pending" or "Member"
+
-        String username = resolveUsername(playerUuid); // You need to implement this method
+    public boolean addInvitation(UUID playerUuid, String gangName) {
+        Integer gangId = dbManager.getGangIdByName(gangName);
+        if (gangId == null) return false;
+        String username = resolveUsername(playerUuid);
+        if (username == null) return false;
         return dbManager.addMember(playerUuid.toString(), username, gangId, "Pending");
     }
 
-    // Method for a player to accept a gang invitation
     public boolean acceptInvitation(UUID playerUuid, String gangName) {
-        return dbManager.updateMemberRank(playerUuid, gangName, "Member");
+        return dbManager.updateMemberRank(playerUuid, gangName, GangRank.MEMBER.name());
     }
 
-    // Method for a player to deny a gang invitation or to be removed from the gang
     public boolean denyInvitation(UUID playerUuid, String gangName) {
         return dbManager.removeMember(playerUuid, gangName);
     }
 
-
+    public boolean kickMember(UUID playerUuid, UUID targetUuid, String gangName) {
-    private String resolveUsername(UUID uuid) {
+        if (canKickOrPromote(playerUuid, gangName)) {
-        Player player = Bukkit.getPlayer(uuid);
+            return dbManager.removeMember(targetUuid, gangName);
-        if (player != null) {
-            return player.getName();
-        } else {
-            // The player might be offline or the UUID might not correspond to a known player.
-            // Decide how you want to handle this case. For now, returning null or a placeholder.
-            return null; // Consider an alternative approach based on your plugin's requirements.
         }
+        return false;
     }
 
-    public String getCurrentGangName(UUID playerUuid) {
+    public boolean promoteMember(UUID playerUuid, UUID targetUuid, String gangName) {
-        // Call the DatabaseManager method to get the current gang name by player's UUID
+        if (!canKickOrPromote(playerUuid, gangName)) return false;
-        return dbManager.getCurrentGangByPlayerUuid(playerUuid);
+        String currentRank = dbManager.getMemberRank(targetUuid, gangName);
+        String newRank = getNextRank(currentRank);
+        if (newRank.equals(currentRank)) return false;
+        return dbManager.updateMemberRank(targetUuid, gangName, newRank);
     }
 
     public boolean leaveGang(UUID playerUuid, String gangName) {
-        // Before removing a member, you may need to get the gang's ID based on its name
-        Integer gangId = dbManager.getGangIdByName(gangName);
-        if (gangId == null) {
-            // This means the gang doesn't exist, which could indicate an issue with the provided gangName
-            return false;
-        }
-        // Proceed to remove the player from the gang
         return dbManager.removeMember(playerUuid, gangName);
     }
 
-
+    private String resolveUsername(UUID uuid) {
+        Player player = Bukkit.getPlayer(uuid);
+        return player != null ? player.getName() : null;
+    }
+
+    public String getCurrentGangName(UUID playerUuid) {
+        return dbManager.getCurrentGangByPlayerUuid(playerUuid);
+    }
 }

src/main/java/me/nvus/nvus_prison_setup/PrisonSetup.java

@@ -43,7 +43,7 @@ public final class PrisonSetup extends JavaPlugin {
         File dataFolder = getDataFolder();
 
         // Initialize the DatabaseManager with the plugin's data folder
-        dbManager = new DatabaseManager(dataFolder);
+        DatabaseManager databaseManager = new DatabaseManager(configManager);
 
         // Initialize the GangManager with the DatabaseManager
         gangManager = new GangManager(dbManager);

src/main/resources/config.yml

@@ -1,5 +1,5 @@
 #======================================================================================#
-#                                NVus PRISON SETUP                                     #
+#                             NVus PRISON GOLD EDITION                                 #
 #                                   by never2nv                                        #
 #                                www.FNGnation.net                                     #
 #                          Discord: FNGnation.net/discord                              #
@@ -29,3 +29,11 @@ PrisonerTools:
   - IRON_SHOVEL
 # When set to FALSE it will prevent Prisoner Tools from receiving damage when mining etc.
 ToolDamage: false
+
+# Database Settings
+host: 0.0.0.0
+port: 3306
+database: nvus_prison
+username: username
+password: password
+