Initialize work for #11

Add a base structure for all commands

Author: JvstvsHD

gradle/libs.versions.toml

@@ -43,6 +43,7 @@ adventure-api = { group = "net.kyori", name = "adventure-api", version.ref = "ad
 adventure-text-minimessage = { group = "net.kyori", name = "adventure-text-minimessage", version.ref = "adventure" }
 cloud-core = { group = "org.incendo", name = "cloud-core", version.ref = "cloud" }
 cloud-annotations = { group = "org.incendo", name = "cloud-annotations", version.ref = "cloud" }
+cloud-velocity = { group = "org.incendo", name = "cloud-velocity", version.ref = "cloud" }
 jetbrains-annotations = { group = "org.jetbrains", name = "annotations", version.ref = "jetbrains-annotations" }
 eventbus = { group = "org.greenrobot", name = "eventbus-java", version.ref = "eventbus" }
 slf4j-api = { group = "org.slf4j", name = "slf4j-api", version.ref = "slf4j" }

plugin-common/src/main/java/de/jvstvshd/necrify/common/AbstractNecrifyPlugin.java

@@ -26,10 +26,14 @@
 
 import de.jvstvshd.necrify.api.Necrify;
 import de.jvstvshd.necrify.api.user.NecrifyUser;
+import de.jvstvshd.necrify.common.commands.NecrifyCommand;
 import de.jvstvshd.necrify.common.punishment.NecrifyKick;
 import net.kyori.adventure.text.Component;
+import org.incendo.cloud.CommandManager;
+import org.incendo.cloud.annotations.AnnotationParser;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
 
@@ -41,9 +45,6 @@ public AbstractNecrifyPlugin(ExecutorService executorService) {
         this.executorService = executorService;
     }
 
-    public AbstractNecrifyPlugin() {
-    }
-
     @Override
     public @NotNull ExecutorService getExecutor() {
         return executorService;
@@ -55,4 +56,23 @@ public AbstractNecrifyPlugin() {
     }
 
     public abstract NecrifyKick createKick(Component reason, NecrifyUser user, UUID punishmentUuid);
+
+    /**
+     * Registers commands for the plugin via the {@link AnnotationParser} from the cloud framework. It is possible to only
+     * register the commands of the /necrify root, but also the top-level ones (e.g. /ban, /kick, etc.).
+     *
+     * @param manager          the command manager to register the commands to.
+     * @param topLevelCommands whether to register top-level commands (/ban, /kick, etc.) or not (i.e. only /necrify commands).
+     */
+    public final void registerCommands(CommandManager<NecrifyUser> manager, boolean topLevelCommands) {
+        AnnotationParser<NecrifyUser> parser = new AnnotationParser<>(manager, NecrifyUser.class);
+        final var oldExtractor = parser.commandExtractor();
+        if (!topLevelCommands) {
+            parser.commandExtractor(instance -> {
+                var commands = new ArrayList<>(oldExtractor.extractCommands(instance));
+                return commands.stream().filter(commandDescriptor -> commandDescriptor.commandToken().startsWith("necrify")).toList();
+            });
+        }
+        parser.parse(new NecrifyCommand(this));
+    }
 }

plugin-common/src/main/java/de/jvstvshd/necrify/common/commands/NecrifyCommand.java

@@ -24,7 +24,25 @@
 
 package de.jvstvshd.necrify.common.commands;
 
+import de.jvstvshd.necrify.common.AbstractNecrifyPlugin;
+import org.incendo.cloud.annotations.Command;
+
 public class NecrifyCommand {
 
+    private final AbstractNecrifyPlugin plugin;
+
+    public NecrifyCommand(AbstractNecrifyPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Command("necrify ban")
+    @Command("ban")
+    public void banCommand() {
+
+    }
+
+    @Command("necrify kick")
+    public void kickCommand() {
 
+    }
 }

plugin/build.gradle.kts

@@ -14,6 +14,7 @@ repositories {
 
 dependencies {
     api(projects.pluginCommon)
+    api(libs.cloud.velocity)
     annotationProcessor(libs.velocity.api)
     compileOnly(libs.velocity.api)
     compileOnly(libs.luckperms.api)

plugin/src/main/java/de/jvstvshd/necrify/velocity/NecrifyVelocityPlugin.java

@@ -28,12 +28,18 @@
 import com.google.common.base.Joiner;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.TypeLiteral;
 import com.velocitypowered.api.command.CommandManager;
+import com.velocitypowered.api.command.CommandSource;
 import com.velocitypowered.api.event.EventManager;
 import com.velocitypowered.api.event.Subscribe;
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.plugin.Plugin;
 import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import com.velocitypowered.api.proxy.ConsoleCommandSource;
+import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
 import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
@@ -73,6 +79,10 @@
 import de.jvstvshd.necrify.velocity.user.VelocityUser;
 import de.jvstvshd.necrify.velocity.user.VelocityUserManager;
 import net.kyori.adventure.text.Component;
+import org.incendo.cloud.SenderMapper;
+import org.incendo.cloud.execution.ExecutionCoordinator;
+import org.incendo.cloud.velocity.CloudInjectionModule;
+import org.incendo.cloud.velocity.VelocityCommandManager;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 
@@ -105,6 +115,9 @@ public class NecrifyVelocityPlugin extends AbstractNecrifyPlugin {
     private final MessagingChannelCommunicator communicator;
     private EventDispatcher eventDispatcher;
 
+    @Inject
+    private Injector injector;
+
     /**
      * Since 1.19.1, cancelling chat messages on proxy is not possible anymore. Therefore, we have to listen to the chat event on the actual game server. This means
      * that there has to be a spigot/paper extension to this plugin which is not yet available unless there's a possibility. Therefore all mute related features are disabled for now.
@@ -178,6 +191,14 @@ private void setup(CommandManager commandManager, EventManager eventManager) {
         commandManager.register(TempmuteCommand.tempmuteCommand(this));
         commandManager.register(KickCommand.kickCommand(this));
         commandManager.register(WhitelistCommand.whitelistCommand(this));
+
+        final Injector childInjector = injector.createChildInjector(
+                new CloudInjectionModule<>(
+                        NecrifyUser.class,
+                        ExecutionCoordinator.simpleCoordinator(),
+                        SenderMapper.create(this::createUser, this::getCommandSource)));
+        registerCommands(childInjector.getInstance(Key.get(new TypeLiteral<VelocityCommandManager<NecrifyUser>>() {
+        })), getConfig().getConfiguration().isAllowTopLevelCommands());
     }
 
     @SuppressWarnings({"unchecked", "UnstableApiUsage"})
@@ -278,19 +299,54 @@ public void setUserManager(@NotNull UserManager userManager) {
     public <T extends Punishment> CompletableFuture<Optional<T>> getPunishment(@NotNull UUID punishmentId) {
         return Util.executeAsync(() -> (Optional<T>) Query.query("SELECT u.* FROM punishment.necrify_user u " + "INNER JOIN punishment.necrify_punishment p ON u.uuid = p.uuid " + "WHERE p.punishment_id = ?;").single(Call.of().bind(punishmentId, Adapters.UUID_ADAPTER)).map(row -> {
             var userId = row.getObject(1, UUID.class);
-            var cachedUser = getUserManager().getUser(userId);
-            if (cachedUser.isPresent()) {
-                return cachedUser.get().getPunishment(punishmentId).orElse(null);
-            }
-            var user = new VelocityUser(row.getObject(1, UUID.class), row.getString(2), row.getBoolean(3), this);
-            getExecutor().execute(() -> {
-                Query.query("SELECT type, expiration, reason, punishment_id FROM punishment.necrify_punishment WHERE uuid = ?;").single(Call.of().bind(userId, Adapters.UUID_ADAPTER)).map(user::addPunishment).all();
-                getEventDispatcher().dispatch(new UserLoadedEvent(user).setOrigin(EventOrigin.ofClass(getClass())));
-            });
-            return user.getPunishment(punishmentId).orElse(null);
+            return createUser(userId).getPunishment(punishmentId).orElse(null);
         }).first(), getExecutor());
     }
 
+    public NecrifyUser createUser(CommandSource source) {
+        if (source instanceof Player) {
+            return createUser(((Player) source).getUniqueId());
+        } else if (source instanceof ConsoleCommandSource) {
+            return new VelocityUser(new UUID(0, 0), "CONSOLE", true, this);
+        } else {
+            return new VelocityUser(UUID.randomUUID(), "unknown_source", false, this);
+        }
+    }
+
+    /**
+     * Creates a user with the given UUID. If the user is already cached, the cached user is returned.
+     * <p>Note: this user does not hold any valid data besides his uuid and maybe player instance (if online). After returning
+     * the value, the missing user data will be loaded, whereafter the {@link UserLoadedEvent} will be fired.</p>
+     *
+     * @param userId the UUID of the user to create.
+     * @return the created user.
+     */
+    public NecrifyUser createUser(UUID userId) {
+        var cachedUser = getUserManager().getUser(userId);
+        if (cachedUser.isPresent()) {
+            return cachedUser.get();
+        }
+        var user = new VelocityUser(userId, "unknown", false, this);
+        getExecutor().execute(() -> {
+            Query.query("SELECT type, expiration, reason, punishment_id FROM punishment.necrify_punishment WHERE uuid = ?;").single(Call.of().bind(userId, Adapters.UUID_ADAPTER)).map(user::addPunishment).all();
+            getEventDispatcher().dispatch(new UserLoadedEvent(user).setOrigin(EventOrigin.ofClass(getClass())));
+        });
+        return user;
+    }
+
+    public CommandSource getCommandSource(NecrifyUser user) {
+        if (user instanceof VelocityUser velocityUser) {
+            var player = velocityUser.getPlayer();
+            if (player != null) {
+                return player;
+            }
+        }
+        if ("console".equalsIgnoreCase(user.getUsername()) && user.getUuid().equals(new UUID(0, 0))) {
+            return server.getConsoleCommandSource();
+        }
+        return server.getPlayer(user.getUuid()).orElse(null);
+    }
+
     @Override
     public @NotNull EventDispatcher getEventDispatcher() {
         return eventDispatcher;

plugin/src/main/java/de/jvstvshd/necrify/velocity/config/ConfigData.java

@@ -42,14 +42,19 @@ public class ConfigData {
     @JsonAlias("whitelistActivated")
     private boolean whitelistActivated;
 
-    public ConfigData(DataBaseData dataBaseData, Locale defaultLanguage, boolean whitelistActivated) {
+    @JsonProperty("allow-top-level-commands")
+    @JsonAlias("allowTopLevelCommands")
+    private boolean allowTopLevelCommands;
+
+    public ConfigData(DataBaseData dataBaseData, Locale defaultLanguage, boolean whitelistActivated, boolean allowTopLevelCommands) {
         this.dataBaseData = dataBaseData;
         this.defaultLanguage = defaultLanguage;
         this.whitelistActivated = whitelistActivated;
+        this.allowTopLevelCommands = allowTopLevelCommands;
     }
 
     public ConfigData() {
-        this(new DataBaseData(), Locale.ENGLISH, false);
+        this(new DataBaseData(), Locale.ENGLISH, false, true);
     }
 
     public final DataBaseData getDataBaseData() {
@@ -67,4 +72,12 @@ public boolean isWhitelistActivated() {
     public void setWhitelistActivated(boolean whitelistActivated) {
         this.whitelistActivated = whitelistActivated;
     }
+
+    public boolean isAllowTopLevelCommands() {
+        return allowTopLevelCommands;
+    }
+
+    public void setAllowTopLevelCommands(boolean allowTopLevelCommands) {
+        this.allowTopLevelCommands = allowTopLevelCommands;
+    }
 }