Add the ability to use slash commands

src/main/kotlin/de/bigboot/ggtools/fang/Command.kt

@@ -1,5 +1,13 @@
 package de.bigboot.ggtools.fang
 
+import de.bigboot.ggtools.fang.service.AutostartService
+import discord4j.discordjson.json.ApplicationCommandOptionData;
+import discord4j.discordjson.json.ApplicationCommandRequest;
+import discord4j.discordjson.json.ImmutableApplicationCommandOptionData;
+import discord4j.core.GatewayDiscordClient
+import discord4j.core.`object`.command.ApplicationCommandOption;
+import discord4j.core.spec.*
+import org.koin.core.component.inject
 import org.koin.core.component.KoinComponent
 
 data class Argument(
@@ -17,20 +25,38 @@ abstract class CommandGroupSpec(val name: String, val description: String) : Koi
     abstract val build: CommandGroupBuilder.() -> Unit
 }
 
-sealed class Command(val name: String, val description: String) {
+sealed class Command(val name: String, val description: String, var slashCommand: ImmutableApplicationCommandOptionData.Builder) {
     var parent: Command? = null
         internal set
 
     class Invokable(
         name: String,
         description: String,
         val args: Array<Argument>,
-        val handler: suspend CommandContext.() -> Unit
+        val handler: suspend CommandContext.() -> MessageCreateSpec.Builder.() -> Unit
     ) :
-        Command(name, description)
+        Command(name, description, run {
+            var command = ApplicationCommandOptionData.builder()
+                                           .name(name)
+                                           .description(description)
+                                           .type(ApplicationCommandOption.Type.SUB_COMMAND.getValue());
+            args.forEach {
+                command = command.addOption(ApplicationCommandOptionData.builder()
+                                                .name(it.name)
+                                                .description(it.description)
+                                                .required(!it.optional)
+                                                .type(ApplicationCommandOption.Type.STRING.getValue())
+                                                .build());
+            }
+            command
+        })
+
 
     class Group(name: String, description: String, override val commands: Map<String, Command>) :
-        Command(name, description), Commands {
+        Command(name, description, ApplicationCommandOptionData.builder()
+                                       .name(name)
+                                       .description(description)
+                                       .type(ApplicationCommandOption.Type.SUB_COMMAND_GROUP.getValue())), Commands {
 
         operator fun plus(other: Command): Group {
             return Group(
@@ -62,14 +88,14 @@ sealed class Command(val name: String, val description: String) {
 }
 
 class CommandBuilder(private val name: String, private val description: String) {
-    private var handler: suspend CommandContext.() -> Unit = {}
+    private var handler: suspend CommandContext.() -> MessageCreateSpec.Builder.() -> Unit = {{}}
     private var args = ArrayList<Argument>()
 
     fun arg(name: String, description: String = "", optional: Boolean = false, verify: ((String) -> Boolean)? = null) {
         this.args.add(Argument(name, description, optional, verify))
     }
 
-    fun onCall(handler: suspend CommandContext.() -> Unit) {
+    fun onCall(handler: suspend CommandContext.() -> MessageCreateSpec.Builder.() -> Unit) {
         this.handler = handler
     }
 
@@ -88,13 +114,25 @@ class CommandBuilder(private val name: String, private val description: String)
                 }
                 .toTypedArray()
         )
+
+    fun args(): Array<Argument> =
+        this@CommandBuilder.args
+            .sortedBy {
+                if (it.optional) {
+                    1
+                } else {
+                    0
+                }
+            }
+            .toTypedArray()
 }
 
-class CommandGroupBuilder(private val name: String, private val description: String) {
+class CommandGroupBuilder(private val name: String, private val description: String) : AutostartService, KoinComponent {
+    private val client by inject<GatewayDiscordClient>()
     private val commands = HashMap<String, Command>()
 
     fun command(name: String, description: String = "", builder: CommandBuilder.() -> Unit = {}) {
-        commands[name] = CommandBuilder(name, description).apply(builder).build()
+        commands[name] = CommandBuilder(name, description).apply(builder).build();
     }
 
     fun group(spec: CommandGroupSpec) {
@@ -108,5 +146,21 @@ class CommandGroupBuilder(private val name: String, private val description: Str
         name = name,
         description = description,
         commands = commands
-    ).apply { commands.values.forEach { it.parent = this } }
+    ).apply {
+        commands.values.forEach { it.parent = this };
+
+        var command = ApplicationCommandRequest.builder()
+            .name(name)
+            .description(description)
+            .type(ApplicationCommandOption.Type.SUB_COMMAND.getValue());
+        commands.values.forEach {
+            command = command.addOption(it.slashCommand.build());
+        }
+
+        val applicationId = client.getRestClient().getApplicationId().block();
+
+        client.getRestClient().getApplicationService()
+            .createGlobalApplicationCommand(applicationId, command.build())
+            .subscribe();
+    }
 }

src/main/kotlin/de/bigboot/ggtools/fang/CommandContext.kt

@@ -2,20 +2,24 @@ package de.bigboot.ggtools.fang
 
 import discord4j.core.`object`.entity.Guild
 import discord4j.core.`object`.entity.Message
+import discord4j.core.`object`.entity.User
 import discord4j.core.`object`.entity.channel.MessageChannel
 import kotlinx.coroutines.reactive.awaitSingle
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 
 data class CommandContext(
     val args: Arguments,
-    val message: Message
+    val channel: MessageChannel,
+    val guild: Guild,
+    var author: User
 ) : KoinComponent {
     private val _commands: Commands by inject()
     val commands = _commands.commands
 
-    suspend fun channel(): MessageChannel = message.channel.awaitSingle()
-    suspend fun guild(): Guild = message.guild.awaitSingle()
+    suspend fun channel(): MessageChannel = channel
+    suspend fun guild(): Guild = guild
+    suspend fun author(): User = author
 
     class Arguments(private val arguments: Map<String, String>) {
         operator fun get(key: String) = arguments.getValue(key)

src/main/kotlin/de/bigboot/ggtools/fang/commands/Root.kt

@@ -5,9 +5,7 @@ import de.bigboot.ggtools.fang.CommandGroupSpec
 import de.bigboot.ggtools.fang.commands.admin.Admin
 import de.bigboot.ggtools.fang.commands.queue.Queue
 import de.bigboot.ggtools.fang.commands.server.Server
-import de.bigboot.ggtools.fang.utils.createEmbedCompat
-import de.bigboot.ggtools.fang.utils.formatCommandHelp
-import de.bigboot.ggtools.fang.utils.formatCommandTree
+import de.bigboot.ggtools.fang.utils.*
 import kotlinx.coroutines.reactive.awaitFirst
 
 class Root : CommandGroupSpec("", "") {
@@ -18,28 +16,32 @@ class Root : CommandGroupSpec("", "") {
 
         command("help", "show this help") {
             onCall {
-                channel().createEmbedCompat {
-                    title("Help")
-                    addField(
-                        "commands",
-                        commands.values.joinToString("\n\n") {
-                            "${formatCommandHelp(
-                                it.name,
-                                it
-                            )}\n${it.description}"
-                        },
-                        false
-                    )
-                }.awaitFirst()
+                {
+                    addEmbedCompat {
+                        title("Help")
+                        addField(
+                            "commands",
+                            commands.values.joinToString("\n\n") {
+                                "${formatCommandHelp(
+                                       it.name,
+                                       it
+                                   )}\n${it.description}"
+                            },
+                            false
+                        )
+                    }
+                }
             }
         }
 
         command("commands", "Show all available commands") {
             onCall {
-                channel().createEmbedCompat {
-                    title("Commands")
-                    description("```\n${formatCommandTree(commands.values)}\n```")
-                }.awaitFirst()
+                {
+                    addEmbedCompat {
+                        title("Commands")
+                        description("```\n${formatCommandTree(commands.values)}\n```")
+                    }
+                }
             }
         }
     }

src/main/kotlin/de/bigboot/ggtools/fang/commands/admin/Server.kt

@@ -3,9 +3,7 @@ package de.bigboot.ggtools.fang.commands.admin
 import de.bigboot.ggtools.fang.CommandGroupBuilder
 import de.bigboot.ggtools.fang.CommandGroupSpec
 import de.bigboot.ggtools.fang.service.ServerService
-import de.bigboot.ggtools.fang.utils.addEmbedCompat
-import de.bigboot.ggtools.fang.utils.createEmbedCompat
-import de.bigboot.ggtools.fang.utils.editCompat
+import de.bigboot.ggtools.fang.utils.*
 import kotlinx.coroutines.reactive.awaitSingle
 import org.koin.core.component.inject
 
@@ -23,23 +21,19 @@ class Server : CommandGroupSpec("server", "Commands for managing servers") {
                 val url = args["url"]
                 val apiKey = args["api_key"]
 
-                val msg = channel().createEmbedCompat {
-                    description("Adding $name to the list of servers")
-                }.awaitSingle()
-
                 if (serverService.checkServer(name, url, apiKey)) {
                     serverService.addServer(name, url, apiKey)
-                    msg.editCompat {
+                    return@onCall {
                         addEmbedCompat {
                             description("Adding $name to the list of servers -> Success")
                         }
-                    }.awaitSingle()
+                    }
                 } else {
-                    msg.editCompat {
+                    return@onCall {
                         addEmbedCompat {
                             description("Adding $name to the list of servers -> Failed")
                         }
-                    }.awaitSingle()
+                    }
                 }
             }
         }
@@ -52,13 +46,13 @@ class Server : CommandGroupSpec("server", "Commands for managing servers") {
 
                 if (serverService.getClient(name) != null) {
                     serverService.removeServer(name)
-                    channel().createEmbedCompat {
+                    return@onCall {addEmbedCompat{
                         description("$name removed from the list of servers.")
-                    }.awaitSingle()
+                    }}
                 } else {
-                    channel().createEmbedCompat {
+                    return@onCall {addEmbedCompat {
                         description("$name not the list of servers.")
-                    }.awaitSingle()
+                    }}
                 }
             }
         }

src/main/kotlin/de/bigboot/ggtools/fang/commands/admin/group/Group.kt

@@ -3,7 +3,7 @@ package de.bigboot.ggtools.fang.commands.admin.group
 import de.bigboot.ggtools.fang.CommandGroupBuilder
 import de.bigboot.ggtools.fang.Config
 import de.bigboot.ggtools.fang.service.PermissionService
-import de.bigboot.ggtools.fang.utils.createEmbedCompat
+import de.bigboot.ggtools.fang.utils.*
 import kotlinx.coroutines.reactive.awaitSingle
 import org.koin.core.component.inject
 
@@ -16,11 +16,11 @@ class Group : de.bigboot.ggtools.fang.CommandGroupSpec("group", "Commands for ma
 
         command("list", "List all groups") {
             onCall {
-                channel().createEmbedCompat {
+                {addEmbedCompat{
                     title("Groups")
                     description(permissionService.getGroups()
                         .joinToString("\n"))
-                }.awaitSingle()
+                 }}
             }
         }
 
@@ -29,12 +29,12 @@ class Group : de.bigboot.ggtools.fang.CommandGroupSpec("group", "Commands for ma
 
             onCall {
                 val group = args["group"]
-                channel().createEmbedCompat {
+                {addEmbedCompat{
                     title("Permissions for group $group")
                     description(
                         permissionService.getPermissions(group)
                             ?.joinToString("\n") ?: "Group not found")
-                }.awaitSingle()
+                 }}
             }
         }
 
@@ -44,12 +44,12 @@ class Group : de.bigboot.ggtools.fang.CommandGroupSpec("group", "Commands for ma
             onCall {
                 val group = args["group"]
 
-                channel().createEmbedCompat {
+                {addEmbedCompat{
                     description(when {
                         permissionService.addGroup(group) -> "The group $group has been created"
                         else -> "The group $group already exists"
                     })
-                }.awaitSingle()
+                 }}
             }
         }
 
@@ -60,19 +60,17 @@ class Group : de.bigboot.ggtools.fang.CommandGroupSpec("group", "Commands for ma
                 val group = args["group"]
 
                 if (group == Config.permissions.default_group_name || group == Config.permissions.admin_group_name) {
-                    channel().createEmbedCompat {
+                    return@onCall {addEmbedCompat{
                         description("The default and admin groups cannot be deleted")
-                    }.awaitSingle()
-
-                    return@onCall
+                    }}
                 }
 
-                channel().createEmbedCompat {
+                {addEmbedCompat{
                     description(when {
                         permissionService.removeGroup(group) -> "The group $group has been deleted"
                         else -> "The group $group was not found"
                     })
-                }.awaitSingle()
+                 }}
             }
         }
     }