fix: change wildcard to object when loading configuration

common/src/main/java/team/unnamed/creative/central/common/config/YamlConfigurationLoader.java

@@ -29,6 +29,7 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -54,14 +55,16 @@ public static Configuration load(InputStream stream) {
         Configuration config = new Configuration();
 
         // read the 'send' section
-        Map<String, ?> send = (Map<String, ?>) data.get("send");
-        Map<String, ?> request = (Map<String, ?>) send.get("request");
+        Map<String, Object> send = (Map<String, Object>) data.get("send");
+        Map<String, Object> request = (Map<String, Object>) send.get("request");
         config.send().request().required((boolean) request.get("required"));
         config.send().request().prompt((String) request.get("required"));
         config.send().delay((int) send.get("delay"));
 
         // read the feedback section
-        Map<String, ?> feedback = (Map<String, ?>) data.get("feedback");
+        Map<String, ?> feedback = data.containsKey("feedback")
+                ? (Map<String, ?>) data.get("feedback")
+                : Collections.emptyMap();
         for (Map.Entry<String, ?> entry : feedback.entrySet()) {
             String statusKey = entry.getKey();
             ResourcePackStatus status;
@@ -87,9 +90,9 @@ public static Configuration load(InputStream stream) {
         }
 
         // read the export section
-        Map<String, ?> export = (Map<String, ?>) data.get("export");
+        Map<String, Object> export = (Map<String, Object>) data.get("export");
         config.export().type((String) export.get("type"));
-        Map<String, ?> localhost = (Map<String, ?>) export.get("localhost");
+        Map<String, Object> localhost = (Map<String, Object>) export.get("localhost");
         config.export().localHost().enabled((boolean) localhost.get("enabled"));
         config.export().localHost().address((String) localhost.get("address"));
         config.export().localHost().port((int) localhost.get("port"));

common/src/main/java/team/unnamed/creative/central/common/util/Permissions.java

@@ -0,0 +1,36 @@
+/*
+ * This file is part of creative, licensed under the MIT license
+ *
+ * Copyright (c) 2021-2023 Unnamed Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package team.unnamed.creative.central.common.util;
+
+public final class Permissions {
+
+    public static final String HELP_COMMAND = "creative-central.command.help";
+    public static final String RELOAD_COMMAND = "creative-central.command.reload";
+    public static final String APPLY_COMMAND = "creative-central.command.apply";
+    public static final String APPLY_OTHERS_COMMAND = "creative-central.command.apply.others";
+
+    private Permissions() {
+    }
+
+}

minestom/src/main/java/team/unnamed/creative/central/minestom/CreativeCentralExtension.java

@@ -81,7 +81,7 @@ public void initialize() {
         getEventNode().addListener(PlayerResourcePackStatusEvent.class, statusListener::onResourcePackStatus);
 
         // register our command
-        MinecraftServer.getCommandManager().register(new MainCommand());
+        MinecraftServer.getCommandManager().register(new MainCommand(this));
 
         // load actions
         eventBus.listen(this, ResourcePackStatusEvent.class, new CreativeResourcePackStatusListener(configMonitor));

minestom/src/main/java/team/unnamed/creative/central/minestom/command/MainCommand.java

@@ -23,36 +23,128 @@
  */
 package team.unnamed.creative.central.minestom.command;
 
+import net.minestom.server.command.CommandSender;
 import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.CommandExecutor;
 import net.minestom.server.command.builder.arguments.ArgumentType;
+import net.minestom.server.command.builder.condition.CommandCondition;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.Player;
 import net.minestom.server.permission.Permission;
 import net.minestom.server.utils.entity.EntityFinder;
+import team.unnamed.creative.central.CreativeCentral;
+import team.unnamed.creative.central.common.util.Permissions;
+import team.unnamed.creative.central.request.ResourcePackRequest;
+
+import java.util.List;
 
 public class MainCommand extends Command {
 
-    private static final Permission HELP_COMMAND_PERMISSION = new Permission("creative-central.command.help");
-    private static final Permission RELOAD_COMMAND_PERMISSION = new Permission("creative-central.command.reload");
-    private static final Permission APPLY_COMMAND_PERMISSION = new Permission("creative-central.command.apply");
-    private static final Permission APPLY_OTHERS_COMMAND_PERMISSION = new Permission("creative-central.command.apply.others");
+    private static final Permission HELP_COMMAND_PERMISSION = new Permission(Permissions.HELP_COMMAND);
+    private static final Permission RELOAD_COMMAND_PERMISSION = new Permission(Permissions.RELOAD_COMMAND);
+    private static final Permission APPLY_COMMAND_PERMISSION = new Permission(Permissions.APPLY_COMMAND);
+    private static final Permission APPLY_OTHERS_COMMAND_PERMISSION = new Permission(Permissions.APPLY_OTHERS_COMMAND);
 
-    public MainCommand() {
+    public MainCommand(CreativeCentral central) {
         super("central");
 
-        addSyntax((sender, context) -> {
-        }, ArgumentType.Literal("reload"));
+        // "reload"
+        addConditionalSyntax(
+                (sender, commandString) -> {
+                    if (sender.hasPermission(RELOAD_COMMAND_PERMISSION)) {
+                        return true;
+                    } else if (commandString != null) {
+                        send(sender, "command.no-permission.reload");
+                    }
+                    return false;
+                },
+                (sender, context) -> {
+                    //central.reloadConfig();
+                    //messageCache.clear();
+                    central.generate().thenAccept(resourcePack -> send(sender, "command.feedback.reload"));
+                },
+                ArgumentType.Literal("reload")
+        );
+
+        // apply self
+        addConditionalSyntax(
+                (sender, commandString) -> {
+                    //if (sender instanceof Player && sender.hasPermission(APPLY_COMMAND_PERMISSION)) {
+                    //    return true;
+                    //} else if (commandString != null) {
+                    //    send(sender, "command.no-permission.apply.self");
+                    //}
+                    return false;
+                },
+                (sender, context) -> {
+                    // Player player = (Player) sender;
+                    ResourcePackRequest request = central.serveOptions().request();
+                    if (request == null) {
+                       // send(sender, "command.apply.no-resource-pack");
+                    }
 
+                    // send
+                    // central.requestSender().send(player, request);
+                    // send(sender, "command.feedback.apply");
+                },
+                ArgumentType.Literal("apply")
+        );
+
+        // apply others
         var targetArgument = ArgumentType.Entity("target")
                 .singleEntity(false)
                 .onlyPlayers(true)
                 .setDefaultValue(new EntityFinder()
                         .setTargetSelector(EntityFinder.TargetSelector.SELF));
-        addSyntax((sender, context) -> {
+        addConditionalSyntax(
+                (sender, commandArg) -> {
+                    if (sender.hasPermission(APPLY_OTHERS_COMMAND_PERMISSION)) {
+                        return true;
+                    } else if (commandArg != null) {
+                        send(sender, "command.no-permission.apply.others");
+                    }
+                    return false;
+                },
+                (sender, context) -> {
+                    EntityFinder entityFinder = context.get(targetArgument);
+                    List<Entity> entities = entityFinder.find(sender);
 
-        }, ArgumentType.Literal("apply"), targetArgument);
+                    if (entities.isEmpty()) {
+                        send(sender, "command.apply.no-players");
+                        return;
+                    }
 
-        setDefaultExecutor((sender, context) ->
-            sender.sendMessage("Unknown subcommand.")
+                    for (Entity entity : entities) {
+                        if (entity instanceof Player player) {
+                            // central.requestSender().send(player, request);
+                        }
+                    }
+                    send(sender, "command.feedback.apply");
+                },
+                ArgumentType.Literal("apply"),
+                targetArgument
         );
+
+        // "help", "?"
+        CommandCondition condition = (sender, commandString) -> {
+            if (sender.hasPermission(HELP_COMMAND_PERMISSION)) {
+                return true;
+            } else if (commandString != null) {
+                send(sender, "command.no-permission.help");
+            }
+            return false;
+        };
+        CommandExecutor helpExecutor = (sender, context) -> send(sender, "command.help");
+        addConditionalSyntax(condition, helpExecutor, ArgumentType.Literal("help"));
+        addConditionalSyntax(condition, helpExecutor, ArgumentType.Literal("?"));
+
+        // any others
+        setDefaultExecutor((sender, context) ->
+                send(sender, "command.usage.unknown"));
+    }
+
+    private void send(CommandSender player, String key) {
+
     }
 
 }