Slash commands

src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt

@@ -3,14 +3,23 @@ package at.hannibal2.skyhanni.discord
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.logAction
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.command.BaseCommand
 import at.hannibal2.skyhanni.discord.command.HelpCommand
-import at.hannibal2.skyhanni.discord.command.PullRequestCommand
+import at.hannibal2.skyhanni.discord.command.BaseCommand
+import at.hannibal2.skyhanni.discord.command.MessageEvent
+import at.hannibal2.skyhanni.discord.command.SlashCommandEvent
 import at.hannibal2.skyhanni.discord.command.ServerCommands
+import at.hannibal2.skyhanni.discord.command.PullRequestCommand.isPullRequest
+import at.hannibal2.skyhanni.discord.command.ServerCommands.isKnownServerUrl
 import at.hannibal2.skyhanni.discord.command.TagCommands
+import at.hannibal2.skyhanni.discord.command.TagCommands.handleTag
 import at.hannibal2.skyhanni.discord.command.TagUndo
+import net.dv8tion.jda.api.entities.Guild
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData
 import org.reflections.Reflections
 import java.lang.reflect.Modifier
 
@@ -23,70 +32,160 @@ object CommandListener {
 
     fun init() {
         loadCommands()
+
+        BOT.jda.awaitReady()
+
+        BOT.jda.getGuildById(BOT.config.allowedServerId)?.let { createCommands(it) }
     }
 
     fun onMessage(bot: DiscordBot, event: MessageReceivedEvent) {
         event.onMessage(bot)
     }
 
+    fun onInteraction(bot: DiscordBot, event: SlashCommandInteractionEvent) {
+        event.onInteraction(bot)
+    }
+
+    fun onAutocomplete(event: CommandAutoCompleteInteractionEvent) {
+        event.onCompletion()
+    }
+
     private fun MessageReceivedEvent.onMessage(bot: DiscordBot) {
-        val message = message.contentRaw.trim()
-        if (!isFromGuild) {
-            logAction("private dm: '$message'")
-            return
-        }
-        if (guild.id != bot.config.allowedServerId) return
+        with(MessageEvent(this)) {
+            val message = message.contentRaw.trim()
+            if (!isFromGuild) {
+                logAction("private dm: '$message'")
+                return
+            }
+            if (guild.id != bot.config.allowedServerId) return
 
-        if (this.author.isBot) {
-            if (this.author.id == BOT_ID) {
-                BotMessageHandler.handle(this)
+            if (author.isBot) {
+                if (author.id == BOT_ID) {
+                    BotMessageHandler.handle(event)
+                }
+                return
             }
-            return
-        }
 
-        if (TagUndo.getAllNames().none { "!$it" == message }) {
-            TagCommands.lastMessages.remove(this.author.id)
-        }
+            if (TagUndo.getAllNames().none { "!$it" == message }) {
+                TagCommands.lastMessages.remove(author.id)
+            }
 
-        if (ServerCommands.isKnownServerUrl(this, message)) return
-        if (PullRequestCommand.isPullRequest(this, message)) return
+            if (isKnownServerUrl(message) || isPullRequest(message) || !isCommand(message)) return
 
-        if (!isCommand(message)) return
+            val split = message.substring(1).split(" ")
+            val literal = split.first().lowercase()
+            val args = split.drop(1)
 
-        val split = message.substring(1).split(" ")
-        val literal = split.first().lowercase()
-        val args = split.drop(1)
+            val command = getCommand(literal) ?: run {
+                handleTag()
+                return
+            }
 
-        val command = getCommand(literal) ?: run {
-            TagCommands.handleTag(this)
-            return
-        }
+            if (!command.userCommand) {
+                if (!hasAdminPermissions()) {
+                    reply("No permissions $PLEADING_FACE")
+                    return
+                }
 
-        if (!command.userCommand) {
-            if (!hasAdminPermissions()) {
-                reply("No permissions $PLEADING_FACE")
-                return
+                if (!inBotCommandChannel()) {
+                    reply("Wrong channel $PLEADING_FACE")
+                    return
+                }
             }
 
-            if (!inBotCommandChannel()) {
-                reply("Wrong channel $PLEADING_FACE")
+            // allows to use `!<command> -help` instead of `!help -<command>`
+            if (args.size == 1 && args.first() == "-help") {
+                with(HelpCommand) {
+                    sendUsageReply(literal)
+                }
                 return
             }
+            // allows to use `!<command> -help` instead of `!help -<command>`
+            if (args.size == 1) {
+                if (args.first() == "-help") {
+                    with(HelpCommand) {
+                        sendUsageReply(literal)
+                    }
+                    return
+                }
+            }
+            try {
+                with(command) {
+                    execute(args)
+                }
+            } catch (e: Exception) {
+                reply("Error: ${e.message}")
+            }
         }
+    }
+
+    private fun SlashCommandInteractionEvent.onInteraction(bot: DiscordBot) {
+        with(SlashCommandEvent(this)) {
+            if (guild?.id != bot.config.allowedServerId || user.isBot) return
 
-        // allows to use `!<command> -help` instaed of `!help -<command>`
-        if (args.size == 1 && args.first() == "-help") {
-            with(HelpCommand) {
-                sendUsageReply(literal)
+            val command = getCommand(fullCommandName) ?: return
+
+            if (!command.userCommand) {
+                if (!hasAdminPermissions()) {
+                    reply("No permissions $PLEADING_FACE")
+                    return
+                }
+
+                if (!inBotCommandChannel()) {
+                    reply("Wrong channel $PLEADING_FACE")
+                    return
+                }
+            }
+
+            try {
+                with(command) {
+                    execute(listOf())
+                }
+            } catch (e: Exception) {
+                reply("Error: ${e.message}")
             }
-            return
         }
-        try {
-            with(command) {
-                execute(args)
+    }
+
+    private fun CommandAutoCompleteInteractionEvent.onCompletion() {
+        when (fullCommandName) {
+            "help" -> {
+                if (focusedOption.name != "command") return
+
+                replyChoiceStrings(
+                    commands.filter { it.name.startsWith(focusedOption.value) }
+                        .map { it.name }
+                        .take(25)
+                ).queue()
+            }
+
+            "server" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    ServerCommands.servers.filter { it.name.startsWith(focusedOption.value, true) }
+                        .map { it.name }
+                        .take(25)
+                ).queue()
+            }
+
+            "tagedit" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    Database.listKeywords().filter { it.startsWith(focusedOption.value, true) }
+                        .take(25)
+                ).queue()
+            }
+
+            "tagdelete" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    Database.listKeywords().filter { it.startsWith(focusedOption.value, true) }
+                        .take(25)
+                ).queue()
             }
-        } catch (e: Exception) {
-            reply("Error: ${e.message}")
         }
     }
 
@@ -121,6 +220,38 @@ object CommandListener {
         this.commands = commands
         this.commandsMap = commandsMap
     }
+
+    private fun createCommands(guild: Guild) {
+        guild.retrieveCommands().queue {
+            val commandData = commands.map { value -> convertToData(value) }
+            println(getCommand("server"))
+
+            println(commandsMap)
+            println(commandData)
+
+            guild.updateCommands().addCommands(commandData).queue()
+        }
+    }
+
+    private fun convertToData(old: BaseCommand): SlashCommandData {
+        return Commands.slash(old.name, old.description).apply {
+            old.options.forEach { option ->
+                addOption(
+                    option.type,
+                    option.name.replace(" ", "_"),
+                    option.description,
+                    option.required,
+                    option.autoComplete
+                )
+            }
+        }
+    }
 }
 
-data class Option(val name: String, val description: String, val required: Boolean = true)
+data class Option(
+    val name: String,
+    val description: String,
+    val required: Boolean = true,
+    val type: OptionType = OptionType.STRING,
+    val autoComplete: Boolean = false
+)

src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt

@@ -3,7 +3,10 @@ package at.hannibal2.skyhanni.discord
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.JDABuilder
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.events.session.ReadyEvent
 import net.dv8tion.jda.api.hooks.ListenerAdapter
 import net.dv8tion.jda.api.requests.GatewayIntent
 import org.slf4j.Logger
@@ -68,12 +71,24 @@ private fun startBot(): DiscordBot {
     }.build()
 
     val bot = DiscordBot(jda, config)
-    jda.awaitReady()
     val messageListener = object : ListenerAdapter() {
         override fun onMessageReceived(event: MessageReceivedEvent) {
             CommandListener.onMessage(bot, event)
         }
     }
+    val slashCommandListener = object : ListenerAdapter() {
+        override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
+            CommandListener.onInteraction(bot, event)
+        }
+
+        override fun onCommandAutoCompleteInteraction(event: CommandAutoCompleteInteractionEvent) {
+            CommandListener.onAutocomplete(event)
+        }
+    }
+    jda.addEventListener(slashCommandListener)
     jda.addEventListener(messageListener)
+
+    jda.awaitReady()
+
     return bot
 }

src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt

@@ -1,5 +1,6 @@
 package at.hannibal2.skyhanni.discord
 
+import at.hannibal2.skyhanni.discord.command.CommandEvent
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.Message
 import net.dv8tion.jda.api.entities.MessageEmbed
@@ -8,7 +9,6 @@ import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel
 import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import net.dv8tion.jda.api.utils.FileUpload
-import org.slf4j.LoggerFactory
 import java.awt.Color
 import java.io.File
 import java.util.zip.ZipFile
@@ -20,28 +20,6 @@ object Utils {
 
     private inline val logger get() = BOT.logger
 
-    fun MessageReceivedEvent.reply(text: String) {
-        message.messageReply(text)
-    }
-
-    fun MessageReceivedEvent.userError(text: String) {
-        message.messageReply("❌ $text")
-    }
-
-    fun MessageReceivedEvent.sendError(text: String) {
-        message.messageReply("❌ An error occurred: $text")
-        logAction("Error: $text")
-    }
-
-    fun MessageReceivedEvent.reply(embed: MessageEmbed) {
-        message.messageReply(embed)
-    }
-
-    fun MessageReceivedEvent.replyWithConsumer(text: String, consumer: (MessageReceivedEvent) -> Unit) {
-        BotMessageHandler.log(text, consumer)
-        reply(text)
-    }
-
     fun Message.messageDelete() {
         delete().queue()
     }
@@ -82,31 +60,29 @@ object Utils {
         BOT.jda.getTextChannelById(BOT.config.botCommandChannelId)?.messageSend(text, instantly)
     }
 
-    fun MessageReceivedEvent.logAction(action: String, raw: Boolean = false) {
+    fun CommandEvent.logAction(action: String, raw: Boolean = false) {
         if (raw) {
             logger.info(action)
             return
         }
+
         val name = author.name
         val id = author.id
+        val nickString = member?.nickname?.takeIf { it != "null" }?.let { " (`$it`)" } ?: ""
+        val isFromGuild = isFromGuild
+        val channelSuffix = if (isFromGuild) " in channel '${channel.name}'" else ""
 
-        val nick = member?.nickname?.takeIf { it != "null" }
-        val nickString = nick?.let { " (`$nick`)" } ?: ""
-
-        val channelSuffix = if (isFromGuild) {
-            val channelName = channel.name
-            " in channel '$channelName'"
-        } else ""
         logger.info("$id/$name$nickString $action$channelSuffix")
     }
 
-    fun MessageReceivedEvent.hasAdminPermissions(): Boolean {
+    fun CommandEvent.hasAdminPermissions(): Boolean {
         val member = member ?: return false
+
         val allowedRoleIds = BOT.config.editPermissionRoleIds.values
         return !member.roles.none { it.id in allowedRoleIds }
     }
 
-    fun MessageReceivedEvent.inBotCommandChannel() = channel.id == BOT.config.botCommandChannelId
+    fun CommandEvent.inBotCommandChannel(): Boolean = channel.id == BOT.config.botCommandChannelId
 
     fun runDelayed(duration: Duration, consumer: () -> Unit) {
         Thread {