Brigadier

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>simplexity</groupId>
     <artifactId>SimplePMs</artifactId>
-    <version>2.3.1</version>
+    <version>2.4.0</version>
     <packaging>jar</packaging>
 
     <name>SimplePMs</name>
@@ -90,5 +90,10 @@
             <version>2.11.6</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>6.3.0</version>
+        </dependency>
     </dependencies>
 </project>

src/main/java/simplexity/simplepms/SimplePMs.java

@@ -1,8 +1,8 @@
 package simplexity.simplepms;
 
+import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
 import simplexity.simplepms.commands.Block;
@@ -14,50 +14,85 @@
 import simplexity.simplepms.commands.SocialSpy;
 import simplexity.simplepms.commands.Unblock;
 import simplexity.simplepms.config.ConfigHandler;
-import simplexity.simplepms.listeners.LoginListener;
+import simplexity.simplepms.listeners.JoinListener;
 import simplexity.simplepms.listeners.PreCommandListener;
 import simplexity.simplepms.listeners.QuitListener;
+import simplexity.simplepms.logic.Constants;
+import simplexity.simplepms.saving.SqlHandler;
 
-import java.util.HashSet;
-import java.util.Objects;
-import java.util.Set;
-
+@SuppressWarnings("UnstableApiUsage")
 public final class SimplePMs extends JavaPlugin {
 
     private static Plugin instance;
     private static final MiniMessage miniMessage = MiniMessage.miniMessage();
     private static boolean papiEnabled = false;
-    private static final HashSet<Player> players = new HashSet<>();
-    private static final HashSet<Player> spyingPlayers = new HashSet<>();
     private static ConsoleCommandSender consoleSender;
 
-    public static HashSet<Player> getPlayers() {
-        return players;
-    }
-
-    public static Set<Player> getSpyingPlayers() {
-        return spyingPlayers;
-    }
 
     @Override
     public void onEnable() {
         instance = this;
-        registerCommands();
-        this.getServer().getPluginManager().registerEvents(new LoginListener(), this);
-        this.getServer().getPluginManager().registerEvents(new QuitListener(), this);
-        this.getServer().getPluginManager().registerEvents(new PreCommandListener(), this);
-        if (this.getServer().getPluginManager().getPlugin("PlaceholderAPI") != null) {
+        consoleSender = getServer().getConsoleSender();
+        if (getServer().getPluginManager().getPlugin("PlaceholderAPI") != null) {
             papiEnabled = true;
-        } else {
-            this.getLogger().info("You do not have PlaceholderAPI loaded on your server. Any PlaceholderAPI placeholders used in this plugin's messages, will not work.");
         }
-        consoleSender = this.getServer().getConsoleSender();
-        this.saveDefaultConfig();
+        SqlHandler.getInstance().init();
+        loadConfigStuff();
+        registerListeners();
+        registerCommands();
+        registerPermissions();
+    }
+
+    private void registerListeners() {
+        getServer().getPluginManager().registerEvents(new QuitListener(), this);
+        getServer().getPluginManager().registerEvents(new PreCommandListener(), this);
+        getServer().getPluginManager().registerEvents(new JoinListener(), this);
+    }
+
+    private void loadConfigStuff() {
+        saveDefaultConfig();
         getConfig().options().copyDefaults(true);
         saveConfig();
         ConfigHandler.getInstance().loadConfigValues();
     }
 
+    private void registerCommands() {
+        getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, commands -> {
+            commands.registrar().register(PrivateMessage.createCommand());
+            commands.registrar().register(PrivateMessage.createTellAlias());
+            commands.registrar().register(PrivateMessage.createWhisperAlias());
+            commands.registrar().register(Reply.createCommand());
+            commands.registrar().register(Reply.createAlias());
+            commands.registrar().register(Block.createCommand());
+            commands.registrar().register(Unblock.createCommand());
+            commands.registrar().register(MessageToggle.createCommand());
+            commands.registrar().register(SocialSpy.createCommand());
+            commands.registrar().register(SocialSpy.createAlias());
+            commands.registrar().register(Reload.createCommand());
+            commands.registrar().register(Blocklist.createCommand());
+        });
+    }
+
+    private void registerPermissions() {
+        getServer().getPluginManager().addPermission(Constants.MESSAGE_BASIC);
+        getServer().getPluginManager().addPermission(Constants.MESSAGE_ADMIN);
+        getServer().getPluginManager().addPermission(Constants.MESSAGE_SEND);
+        getServer().getPluginManager().addPermission(Constants.MESSAGE_RECEIVE);
+        getServer().getPluginManager().addPermission(Constants.MESSAGE_TOGGLE);
+        getServer().getPluginManager().addPermission(Constants.MESSAGE_BLOCK);
+        getServer().getPluginManager().addPermission(Constants.PLUGIN_RELOAD);
+        getServer().getPluginManager().addPermission(Constants.ADMIN_OVERRIDE);
+        getServer().getPluginManager().addPermission(Constants.ADMIN_SOCIAL_SPY);
+        getServer().getPluginManager().addPermission(Constants.ADMIN_CONSOLE_SPY);
+        getServer().getPluginManager().addPermission(Constants.BYPASS_SOCIAL_SPY);
+        getServer().getPluginManager().addPermission(Constants.BYPASS_COMMAND_SPY);
+    }
+
+    @Override
+    public void onDisable() {
+        SqlHandler.getInstance().shutdownConnection();
+    }
+
     public static MiniMessage getMiniMessage() {
         return miniMessage;
     }
@@ -74,15 +109,4 @@ public static ConsoleCommandSender getPMConsoleSender() {
         return consoleSender;
     }
 
-    private void registerCommands() {
-        Objects.requireNonNull(this.getCommand("msg")).setExecutor(new PrivateMessage());
-        Objects.requireNonNull(this.getCommand("reply")).setExecutor(new Reply());
-        Objects.requireNonNull(this.getCommand("socialspy")).setExecutor(new SocialSpy());
-        Objects.requireNonNull(this.getCommand("spmreload")).setExecutor(new Reload());
-        Objects.requireNonNull(this.getCommand("block")).setExecutor(new Block());
-        Objects.requireNonNull(this.getCommand("unblock")).setExecutor(new Unblock());
-        Objects.requireNonNull(this.getCommand("blocklist")).setExecutor(new Blocklist());
-        Objects.requireNonNull(this.getCommand("msgtoggle")).setExecutor(new MessageToggle());
-    }
-
 }

src/main/java/simplexity/simplepms/commands/Block.java

@@ -1,45 +1,70 @@
 package simplexity.simplepms.commands;
 
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
-import simplexity.simplepms.config.Message;
-import simplexity.simplepms.logic.Util;
-import simplexity.simplepms.objects.PlayerBlock;
-import simplexity.simplepms.saving.Cache;
-
-import java.util.Arrays;
-
-public class Block implements CommandExecutor {
-    @Override
-    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
-        if (!(sender instanceof Player player)) {
-            sender.sendRichMessage(Message.ONLY_PLAYER.getMessage());
-            return false;
-        }
-        if (args.length == 0) {
-            player.sendRichMessage(Message.NO_USER_PROVIDED.getMessage());
-            return false;
-        }
-        String playerToBlockString = args[0];
-        Player playerToBlock = Util.getInstance().getPlayer(playerToBlockString);
-        if (playerToBlock == null) {
-            sender.sendRichMessage(Message.RECIPIENT_NOT_EXIST.getMessage(),
-                    Placeholder.parsed("name", playerToBlockString));
-            return false;
-        }
-        String blockReason = String.join(" ", Arrays.copyOfRange(args, 1, args.length));
-        PlayerBlock playerBlock = new PlayerBlock(
-                player.getUniqueId(),
-                playerToBlock.getName(),
-                playerToBlock.getUniqueId(),
-                blockReason);
-        Cache.addBlockedUser(player.getUniqueId(), playerBlock);
-        player.sendRichMessage(Message.BLOCKED_PLAYER.getMessage(),
-                Placeholder.parsed("name", playerToBlockString));
-        return true;
+import simplexity.simplepms.commands.arguments.OfflinePlayerArgument;
+import simplexity.simplepms.commands.util.Exceptions;
+import simplexity.simplepms.config.LocaleMessage;
+import simplexity.simplepms.logic.BlockHandler;
+import simplexity.simplepms.logic.Constants;
+
+@SuppressWarnings("UnstableApiUsage")
+public class Block {
+
+    public static LiteralCommandNode<CommandSourceStack> createCommand() {
+        OfflinePlayerArgument offlinePlayerArg = new OfflinePlayerArgument();
+
+        return Commands.literal("block")
+                .requires(Block::canExecute)
+                .then(Commands.argument("target", offlinePlayerArg)
+                        .suggests(offlinePlayerArg::suggestOnlinePlayers)
+                        .executes(Block::execute)
+                        .then(Commands.argument("reason", StringArgumentType.greedyString())
+                                .executes(Block::executeWithReason))).build();
+
     }
+
+    private static boolean canExecute(CommandSourceStack css) {
+        if (!(css.getSender() instanceof Player)) return false;
+        return css.getSender().hasPermission(Constants.MESSAGE_BLOCK);
+    }
+
+    private static int execute(CommandContext<CommandSourceStack> ctx) throws CommandSyntaxException {
+        CommandSender sender = ctx.getSource().getSender();
+        if (!(sender instanceof Player playerSender)) throw Exceptions.ERROR_MUST_BE_PLAYER.create();
+        OfflinePlayer target = ctx.getArgument("target", OfflinePlayer.class);
+        BlockHandler.addBlockedPlayer(playerSender, target, null);
+        sendSuccessMessage(playerSender, target);
+        return Command.SINGLE_SUCCESS;
+    }
+
+    private static int executeWithReason(CommandContext<CommandSourceStack> ctx) throws CommandSyntaxException {
+        CommandSender sender = ctx.getSource().getSender();
+        if (!(sender instanceof Player playerSender)) throw Exceptions.ERROR_MUST_BE_PLAYER.create();
+        OfflinePlayer target = ctx.getArgument("target", OfflinePlayer.class);
+        String reason = ctx.getArgument("reason", String.class);
+        BlockHandler.addBlockedPlayer(playerSender, target, reason);
+        sendSuccessMessage(playerSender, target);
+        return Command.SINGLE_SUCCESS;
+    }
+
+    private static void sendSuccessMessage(@NotNull Player sender, @NotNull OfflinePlayer blockedPlayer) {
+        String blockedPlayerName = blockedPlayer.getName();
+        if (blockedPlayerName == null) blockedPlayerName = "[NO NAME FOUND]"; // Attempting to make intellij shut up
+        sender.sendRichMessage(
+                LocaleMessage.BLOCKED_PLAYER.getMessage(),
+                Placeholder.parsed("name", blockedPlayerName)
+        );
+    }
+
 }

src/main/java/simplexity/simplepms/commands/Blocklist.java

@@ -1,49 +1,56 @@
 package simplexity.simplepms.commands;
 
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.tree.LiteralCommandNode;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
-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 simplexity.simplepms.SimplePMs;
-import simplexity.simplepms.config.Message;
-import simplexity.simplepms.objects.PlayerBlock;
+import simplexity.simplepms.config.LocaleMessage;
+import simplexity.simplepms.logic.Constants;
 import simplexity.simplepms.saving.Cache;
+import simplexity.simplepms.saving.objects.PlayerBlock;
 
 import java.util.List;
 import java.util.UUID;
 
-public class Blocklist implements CommandExecutor {
+@SuppressWarnings("UnstableApiUsage")
+public class Blocklist {
 
-    private final MiniMessage miniMessage = SimplePMs.getMiniMessage();
+    private static final MiniMessage miniMessage = SimplePMs.getMiniMessage();
 
-    @Override
-    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
-        if (!(sender instanceof Player player)) {
-            sender.sendMessage(Message.ONLY_PLAYER.getMessage());
-            return false;
-        }
-        UUID uuid = player.getUniqueId();
-        List<PlayerBlock> blockList = Cache.getBlockList(uuid);
-        if (blockList == null || blockList.isEmpty()) {
-            player.sendRichMessage(Message.BLOCKLIST_EMPTY.getMessage());
-            return true;
-        }
-        Component message = miniMessage.deserialize(Message.BLOCKLIST_HEADER.getMessage());
-        for (PlayerBlock block : blockList) {
-            message = message.appendNewline();
-            message = message.append(miniMessage.deserialize(
-                    Message.BLOCKLIST_NAME.getMessage(),
-                    Placeholder.parsed("name", block.blockedPlayerName())
-            ));
-            if (block.blockReason() == null || block.blockReason().isEmpty()) continue;
-            message = message.append(miniMessage.deserialize(Message.BLOCKLIST_REASON.getMessage(),
-                    Placeholder.parsed("reason", block.blockReason())));
-        }
-        sender.sendMessage(message);
-        return true;
+    public static LiteralCommandNode<CommandSourceStack> createCommand() {
+        return Commands.literal("blocklist")
+                .requires(Blocklist::canExecute)
+                .executes(ctx -> {
+                    Player player = (Player) ctx.getSource().getSender();
+                    UUID uuid = player.getUniqueId();
+                    List<PlayerBlock> blockList = Cache.getBlockList(uuid);
+                    if (blockList == null || blockList.isEmpty()) {
+                        player.sendRichMessage(LocaleMessage.BLOCKLIST_EMPTY.getMessage());
+                        return Command.SINGLE_SUCCESS;
+                    }
+                    Component message = miniMessage.deserialize(LocaleMessage.BLOCKLIST_HEADER.getMessage());
+                    for (PlayerBlock block : blockList) {
+                        message = message.appendNewline();
+                        message = message.append(miniMessage.deserialize(
+                                LocaleMessage.BLOCKLIST_NAME.getMessage(),
+                                Placeholder.parsed("name", block.getBlockedPlayerName())
+                        ));
+                        if (block.getBlockReason() == null || block.getBlockReason().isEmpty()) continue;
+                        message = message.append(miniMessage.deserialize(LocaleMessage.BLOCKLIST_REASON.getMessage(),
+                                Placeholder.parsed("reason", block.getBlockReason())));
+                    }
+                    player.sendMessage(message);
+                    return Command.SINGLE_SUCCESS;
+                }).build();
+    }
+
+    private static boolean canExecute(CommandSourceStack css) {
+        if (!(css.getSender() instanceof Player)) return false;
+        return css.getSender().hasPermission(Constants.MESSAGE_BLOCK);
     }
 }