Plugins/permission-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed some issues, added a way to manage players groups with in game commands

Browse Source
This commit is contained in:
41ms_
2025-11-07 23:36:40 +01:00
parent c3f4f868f6
commit 0557ffd20f
11 changed files with 251 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
build.gradle
View File

@@ -19,6 +19,7 @@ repositories {
dependencies {
compileOnly("io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT")
implementation(files("libs/redmc-API-1.0.jar"))
implementation("com.mysql:mysql-connector-j:9.4.0")
}

12
src/main/java/me/monster/ranks/Main.java
View File

@@ -1,5 +1,7 @@
package me.monster.ranks;
import me.monster.ranks.command.permSubcommands.GroupSub;
import me.monster.ranks.command.permSubcommands.UserSub;
import me.monster.ranks.database.DbManager;
import me.monster.ranks.config.ConfigManager;
import me.monster.ranks.utils.DefaultGroups;
@@ -10,8 +12,11 @@ import org.bukkit.plugin.java.JavaPlugin;
import java.sql.SQLException;
import static me.monster.commands.CommandManager.createCoreCommand;
public final class Main extends JavaPlugin {
public static Main plugin;
public static Plugin getPlugin() { return plugin; }
private static DbManager database;
@@ -39,6 +44,13 @@ public final class Main extends JavaPlugin {
LoadListener.load();
LoadCommands.load();
try {
createCoreCommand(Main.plugin, "permission", "Command to manage players, ranks, and permissions", "/perm", null, UserSub.class, GroupSub.class);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
@Override

48
src/main/java/me/monster/ranks/command/permSubcommands/GroupSub.java Normal file
View File

@@ -0,0 +1,48 @@
package me.monster.ranks.command.permSubcommands;
import me.monster.commands.SubCommand;
import me.monster.ranks.database.DbManager;
import me.monster.ranks.database.models.Groups;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.sql.SQLException;
import java.util.List;
public class GroupSub extends SubCommand {
@Override
public String getName() {
return "group";
}
@Override
public List<String> getAliases() {
return List.of("group", "groups", "rank", "ranks");
}
@Override
public String getDescription() {
return "Manage Groups";
}
@Override
public String getSyntax() {
return "/perm group <groupname>";
}
@Override
public void perform(CommandSender commandSender, String[] strings) {
commandSender.sendMessage("Test");
}
@Override
public List<String> getSubcommandArguments(Player player, String[] strings) {
try {
return List.of(DbManager.getAllGroups().stream().map(Groups::getGroupName).toArray(String[]::new));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}

116
src/main/java/me/monster/ranks/command/permSubcommands/UserSub.java Normal file
View File

@@ -0,0 +1,116 @@
package me.monster.ranks.command.permSubcommands;
import me.monster.colors.ColorUtils;
import me.monster.commands.SubCommand;
import me.monster.ranks.database.DbManager;
import me.monster.ranks.database.models.Groups;
import me.monster.ranks.utils.PlayerUpdater;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.sql.SQLException;
import java.util.List;
public class UserSub extends SubCommand {
@Override
public String getName() {
return "user";
}
@Override
public List<String> getAliases() {
return List.of("user", "player");
}
@Override
public String getDescription() {
return "Manage Player Groups";
}
@Override
public String getSyntax() {
return "&c/perm user <user>";
}
@Override
public void perform(CommandSender sender, String[] args) {
if (sender.hasPermission("ranks.manage.user")) {
if (args.length == 1) {
sender.sendMessage(ColorUtils.translateColorCodes(getSyntax()));
} else if (args.length == 2) {
sender.sendMessage(ColorUtils.translateColorCodes("&c/perm user " + args[1] + " <add/remove/set/update> [group]"));
} else {
try {
manageSystem(List.of(args), sender);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
} else {
sender.sendMessage(ColorUtils.translateColorCodes("&cYou do not have permission to use this command."));
}
}
public void manageSystem(List<String> args, CommandSender sender) throws SQLException {
Player target = Bukkit.getPlayer(args.get(1));
assert target != null;
target.sendMessage(String.valueOf(args));
String uuid = target.getUniqueId().toString();
if (args.size() >= 3) {
if (args.get(2).equalsIgnoreCase("add")) {
if (getGroupNames().contains(args.get(3))) {
DbManager.addPlayerGroup(new me.monster.ranks.database.models.User(uuid, args.get(3), 0, null));
new PlayerUpdater(target);
} else if (!getGroupNames().contains(args.get(3))) {
sender.sendMessage(ColorUtils.translateColorCodes("&cGroup does not exist."));
}
} else if (args.get(2).equalsIgnoreCase("remove")) {
if (getGroupNames().contains(args.get(3))) {
DbManager.deletePlayerGroups(new me.monster.ranks.database.models.User(uuid, args.get(3), 0, null));
new PlayerUpdater(target);
} else {
sender.sendMessage(ColorUtils.translateColorCodes("&cGroup does not exist."));
}
} else if (args.get(2).equalsIgnoreCase("set")) {
if (getGroupNames().contains(args.get(3))) {
DbManager.updatePlayerGroups(new me.monster.ranks.database.models.User(uuid, args.get(3), 0, null));
new PlayerUpdater(target);
} else {
sender.sendMessage(ColorUtils.translateColorCodes("&cGroup does not exist."));
}
} else if (args.get(2).equalsIgnoreCase("update")) {
new PlayerUpdater(target);
}
}
}
public List<String> getGroupNames() {
try {
return DbManager.getAllGroups().stream().map(Groups::getGroupName).toList();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public List<String> getSubcommandArguments(Player player, String[] strings){
if (player.hasPermission("ranks.manage.user")){
if (strings.length == 2) {
return List.of(Bukkit.getServer().getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new));
} else if (strings.length == 3) {
return List.of("add", "remove", "set", "update");
} else if (strings.length == 4) {
try {
return List.of(DbManager.getAllGroups().stream().map(Groups::getGroupName).toArray(String[]::new));
} catch (SQLException e) {
throw new RuntimeException(e);
}
} else {
return null;
}
}
return null;
}
}

35
src/main/java/me/monster/ranks/commands/TestCommand.java
View File

@@ -1,35 +0,0 @@
package me.monster.ranks.commands;
import me.monster.ranks.utils.PlayerUpdater;
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;
import static me.monster.ranks.permission.PermissionManager.clearPlayerPermissions;
public class TestCommand 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 player) {
try {
clearPlayerPermissions(player);
new PlayerUpdater(player);
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;
}
}
}

9
src/main/java/me/monster/ranks/database/DbManager.java
View File

@@ -4,6 +4,7 @@ import me.monster.ranks.Main;
import me.monster.ranks.database.managers.GroupManager;
import me.monster.ranks.database.managers.PermissionsManager;
import me.monster.ranks.database.managers.PlayerManager;
import me.monster.ranks.database.models.Groups;
import me.monster.ranks.database.models.GroupsPermissions;
import me.monster.ranks.config.ConfigManager;
import me.monster.ranks.database.models.User;
@@ -73,6 +74,9 @@ public class DbManager {
public static void createPlayer(User databaseModel) throws SQLException {
PlayerManager.createPlayer(databaseModel);
}
public static void addPlayerGroup(User databaseModel) throws SQLException {
PlayerManager.addPlayerGroup(databaseModel);
}
//################################################
//############# Groups Section ##################
@@ -89,6 +93,11 @@ public class DbManager {
public static void deleteGroup(me.monster.ranks.database.models.Groups databaseModel) throws SQLException {
GroupManager.deleteGroup(databaseModel);
}
public static List<Groups> getAllGroups() throws SQLException {
return GroupManager.getAllGroups();
}
public static me.monster.ranks.database.models.Groups findGroupByName(String groupName) throws SQLException {
return GroupManager.findGroupByName(groupName);
}

25
src/main/java/me/monster/ranks/database/managers/GroupManager.java
View File

@@ -2,10 +2,13 @@ package me.monster.ranks.database.managers;
import me.monster.ranks.Main;
import me.monster.ranks.database.DbManager;
import me.monster.ranks.database.models.Groups;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class GroupManager extends DbManager {
@@ -50,6 +53,28 @@ public class GroupManager extends DbManager {
statement.close();
}
public static List<Groups> getAllGroups() throws SQLException{
PreparedStatement statement = getConnection().prepareStatement("SELECT * FROM groups");
ResultSet resultSet = statement.executeQuery();
List<Groups> groups = new ArrayList<>();
while (resultSet.next()) {
Groups group = new Groups(
resultSet.getString("groupName"),
resultSet.getString("groupPrefix"),
resultSet.getString("groupSuffix"),
resultSet.getInt("groupWeight"),
resultSet.getString("groupParent")
);
groups.add(group);
}
statement.close();
return groups;
}
public static me.monster.ranks.database.models.Groups findGroupByName(String groupName) throws SQLException {
PreparedStatement statement = getConnection().prepareStatement("SELECT * FROM groups WHERE groupName = ?");

16
src/main/java/me/monster/ranks/database/managers/PlayerManager.java
View File

@@ -75,13 +75,27 @@ public class PlayerManager extends DbManager {
}
public static void deletePlayerGroups(User 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();
if (findPlayerGroups(databaseModel.getPlayerUUID()) == null) {
createPlayer(databaseModel);
}
}
public static void addPlayerGroup(User databaseModel) throws SQLException{
PreparedStatement statement = getConnection().prepareStatement("INSERT INTO player_info (uuid, playerRank, temp, date) VALUES (?, ?, ?, ?)");
statement.setString(1, databaseModel.getPlayerUUID());
statement.setString(2, databaseModel.getPlayerRank());
statement.setInt(3, databaseModel.getPlayerRankTemp());
statement.setDate(4, (Date) databaseModel.getDate());
statement.executeUpdate();
statement.close();
}

32
src/main/java/me/monster/ranks/permission/PermissionManager.java
View File

@@ -27,7 +27,11 @@ public class PermissionManager {
public static void loadAndApplyPermissions(Player player) {
try {
// denyRemovedPermissions(player, getHierarchyPermissions(player));
applyPermissionsToPlayer(player, getHierarchyPermissions(player));
if (GroupsPriority.getHighestGroup(player).getGroupName().equals("default")) {
applyPermissionsToPlayer(player, DbManager.fetchGroupPermissions("default"));
} else {
applyPermissionsToPlayer(player, getHierarchyPermissions(player));
}
} catch (SQLException e) {
e.printStackTrace(); // Log or handle the exception as needed
}
@@ -100,32 +104,6 @@ public class PermissionManager {
}
}
// public static void denyRemovedPermissions(Player player, List<GroupsPermissions> currentPermissions) {
// // Retrieve the player's current permission attachment
// PermissionAttachment attachment = perms.get(player.getUniqueId());
//
// if (attachment == null) {
// return; // If no permissions are set, nothing to deny
// }
//
// // Get the existing permissions the player has
// Set<String> currentPerms = new HashSet<>(attachment.getPermissions().keySet());
//
// // Get the permissions the player should have after group modification
// Set<String> newPerms = new HashSet<>();
// for (GroupsPermissions perm : currentPermissions) {
// newPerms.add(perm.getPermission());
// }
//
// // Loop through current permissions, and deny those that are no longer present
// for (String perm : currentPerms) {
// if (!newPerms.contains(perm)) {
// // Deny this permission for the player (remove it from the attachment)
// attachment.setPermission(perm, false);
// }
// }
// }
public static void clearPlayerPermissions(Player player) {
// Ensure the player has a permission attachment
if (perms.containsKey(player.getUniqueId())) {

17
src/main/java/me/monster/ranks/utils/PlayerUpdater.java
View File

@@ -1,6 +1,8 @@
package me.monster.ranks.utils;
import me.monster.ranks.database.DbManager;
import me.monster.ranks.database.models.Groups;
import me.monster.ranks.database.models.User;
import me.monster.ranks.permission.PermissionManager;
import org.bukkit.entity.Player;
@@ -9,10 +11,15 @@ import java.sql.SQLException;
public class PlayerUpdater {
public PlayerUpdater(Player player) throws SQLException {
Groups highestGroup = GroupsPriority.getHighestGroup(player);
player.setPlayerListName(highestGroup.getGroupPrefix() + " " + player.getName() + highestGroup.getGroupSuffix());
PermissionManager.loadAndApplyPermissions(player);
player.recalculatePermissions();
player.updateCommands();
try {
Groups highestGroup = GroupsPriority.getHighestGroup(player);
player.setPlayerListName(highestGroup.getGroupPrefix() + " " + player.getName() + highestGroup.getGroupSuffix());
PermissionManager.loadAndApplyPermissions(player);
player.recalculatePermissions();
player.updateCommands();
} catch (SQLException e) {
DbManager.addPlayerGroup(new User(player.getUniqueId().toString(), "default", 0, null));
new PlayerUpdater(player);
}
}
}

11
src/main/resources/plugin.yml
View File

@@ -6,7 +6,12 @@ prefix: Ranks
load: STARTUP
authors: [ 41ms_ ]
website: 41ms.fr
depend: [RedMC-API]
permissions:
ranks.manage:
description: Manage permissions, groups and players
default: op
children:
ranks.manage.user: true
commands:
test:
description: test command