kord-extensions/dev.kordex.core.commands.chat/ChatGroupCommand

ChatGroupCommand

open class ChatGroupCommand<T : Arguments>(extension: Extension, arguments: () -> T? = null, val parent: ChatGroupCommand<out Arguments>? = null) : ChatCommand<T>

Class representing a grouped command, which is essentially a command with its own subcommands.

You shouldn't need to use this class directly - instead, create an Extension and use the group function to register your command group, by overriding the Extension setup function.

Parameters

extension

The extension that registered this grouped command.

parent

The ChatGroupCommand this group exists under, if any.

Constructors

ChatGroupCommand

constructor(extension: Extension, arguments: () -> T? = null, parent: ChatGroupCommand<out Arguments>? = null)

Properties

aliasKey

open var aliasKey: Key?

Translation key referencing a comma-separated list of command aliases.

aliasTranslationCache

open val aliasTranslationCache: MutableMap<Locale, Set<String>>

Translation cache, so we don't have to look up translations every time.

allowKeywordArguments

open var allowKeywordArguments: Boolean

Whether to allow the parser to parse keyword arguments. Defaults to true.

arguments

open val arguments: () -> T?

description

open var description: Key

A description of what this function and how it's intended to be used.

enabled

open var enabled: Boolean

Whether this command is enabled and can be invoked.

extension

val extension: Extension

The extension object this command belongs to.

hidden

open var hidden: Boolean

Whether to hide this command from help command listings.

kord

val kord: Kord

Kord instance, backing the ExtensibleBot.

localeFallback

open var localeFallback: Boolean

When translated, whether this command supports locale fallback when a user is trying to resolve a command by name in a locale other than the bot's configured default locale.

locking

open override var locking: Boolean

Set this to true to lock command execution with a Mutex.

mutex

open override var mutex: Mutex?

Mutex object to use for locking.

name

open lateinit override var name: Key

The name of this command, for invocation and help commands.

nameTranslationCache

open val nameTranslationCache: MutableMap<Locale, String>

Translation cache, so we don't have to look up translations every time.

parent

open val parent: ChatGroupCommand<out Arguments>? = null

registry

val registry: ChatCommandRegistry

Chat command registry.

requiredPerms

open val requiredPerms: MutableSet<Permission>

Permissions required to be able to run this command.

sentry

val sentry: SentryAdapter

Sentry adapter, for easy access to Sentry functions.

settings

val settings: ExtensibleBotBuilder

Bot settings object.

signature

open var signature: Key?

Provide a translation key here to replace the auto-generated signature string.

signatureCache

open var signatureCache: MutableMap<Locale, String>

Locale-based cache of generated signature strings.

translationsProvider

val translationsProvider: TranslationsProvider

Translations provider, for retrieving translations.

Functions

action

open fun action(action: suspend ChatCommandContext<out T>.() -> Unit)

Define what will happen when your command is invoked.

call

open suspend override fun call(event: MessageCreateEvent, commandName: String, parser: StringParser, argString: String, skipChecks: Boolean, cache: MutableStringKeyedMap<Any>)

Execute this grouped command, given a MessageCreateEvent.

chatCommand

open suspend fun <R : Arguments> chatCommand(commandObj: ChatCommand<R>): ChatCommand<R>

Function for registering a custom command object.

open suspend fun chatCommand(body: suspend ChatCommand<Arguments>.() -> Unit): ChatCommand<Arguments>

DSL function for easily registering a command, without arguments.

open suspend fun <R : Arguments> chatCommand(arguments: () -> R?, body: suspend ChatCommand<R>.() -> Unit): ChatCommand<R>

DSL function for easily registering a command.

chatGroupCommand

open suspend fun chatGroupCommand(body: suspend ChatGroupCommand<Arguments>.() -> Unit): ChatGroupCommand<Arguments>

DSL function for easily registering a grouped command, without its own arguments.

open suspend fun <R : Arguments> chatGroupCommand(arguments: () -> R?, body: suspend ChatGroupCommand<R>.() -> Unit): ChatGroupCommand<R>

DSL function for easily registering a grouped command.

check

open fun check(vararg checks: ChatCommandCheck)

Define a check which must pass for the command to be executed.

open fun check(check: ChatCommandCheck)

Overloaded check function to allow for DSL syntax.

checkBotPerms

open suspend fun checkBotPerms(context: CommandContext)

Checks whether the bot has the specified required permissions, throwing if it doesn't.

emitEventAsync

open suspend fun emitEventAsync(event: CommandEvent<*, *>): Job

Quick shortcut for emitting a command event without blocking.

getFullTranslatedName

open suspend fun getFullTranslatedName(locale: Locale): String

Get the full command name, translated, with parent commands taken into account.

getKoin

open override fun getKoin(): Koin

Get the associated Koin instance.

getSignature

open suspend fun getSignature(locale: Locale): String

Retrieve the command signature for a locale, which specifies how the command's arguments should be structured.

getTranslatedAliases

open fun getTranslatedAliases(locale: Locale): Set<String>

Return this command's aliases translated for the given locale, cached as required.

getTranslatedName

open fun getTranslatedName(locale: Locale): String

Return this command's name translated for the given locale, cached as required.

lock

open suspend fun lock()

Lock the mutex, if locking is enabled - suspending until it's unlocked.

requireBotPermissions

fun requireBotPermissions(perms: Permissions)

fun requireBotPermissions(vararg perms: Permission)

If your bot requires permissions to be able to execute the command, add them using this function.

runChecks

open suspend override fun runChecks(event: MessageCreateEvent, sendMessage: Boolean, cache: MutableStringKeyedMap<Any>): Boolean

Run checks with the provided MessageCreateEvent. Return false if any failed, true otherwise.

unlock

open fun unlock()

Unlock the mutex, if it's locked.

validate

open override fun validate()

An internal function used to ensure that all of a command group's required arguments are present.

withLock

open suspend fun <T> withLock(body: suspend () -> T)

Lock the mutex (if locking is enabled), call the supplied callable, and unlock.