kord-extensions/dev.kordex.core.components.menus.user/PublicUserSelectMenu

PublicUserSelectMenu

open class PublicUserSelectMenu<M : ModalForm>(timeoutTask: Task?, val modal: () -> M? = null) : PublicSelectMenu<PublicUserSelectMenuContext<M>, M> , UserSelectMenu

Class representing a public-only user select (dropdown) menu.

Constructors

PublicUserSelectMenu

constructor(timeoutTask: Task?, modal: () -> M? = null)

Properties

lateinit var body: suspend PublicUserSelectMenuContext<M>.(modal: M?) -> Unit

Component body, to be called when the component is interacted with.

val bot: ExtensibleBot

Bot object.

open override var defaultUsers: MutableList<Snowflake>

Default users to preselect.

open var deferredAck: Boolean

Whether to use a deferred ack, which will prevent Discord's "Thinking..." message.

open var disabled: Boolean?

Whether this select menu is disabled.

open var id: String

Component's ID, a UUID by default.

initialResponseBuilder

open var initialResponseBuilder: InitialEphemeralSelectMenuResponseBuilder

The initial response builder, omit to ack instead.

val kord: Kord

Kord instance, backing the ExtensibleBot.

open override var locking: Boolean

Set this to true to lock execution with a Mutex.

var maximumChoices: Int?

The maximum number of choices that the user can make. Set to null for no maximum.

var minimumChoices: Int

The minimum number of choices that the user must make.

open override val modal: () -> M? = null

open override var mutex: Mutex?

Mutex object to use for locking.

var placeholder: Key?

Placeholder text to show before the user has selected any options.

val registry: ApplicationCommandRegistry

Quick access to the command registry.

open val requiredPerms: MutableSet<Permission>

Bot permissions required to be able to run execute this component's action.

val sentry: SentryAdapter

Sentry adapter, for easy access to Sentry functions.

val settings: ExtensibleBotBuilder

Bot settings object.

open val timeoutTask: Task?

open override val unitWidth: Int

Component width, how many "slots" in one row it needs to be added to the row.

Functions

fun action(action: suspend PublicUserSelectMenuContext<M>.(modal: M?) -> Unit)

Call this to supply a component body, to be called when the component is interacted with.

open override fun apply(builder: ActionRowBuilder)

Called to apply the given component to a Kord ActionRowBuilder.

applyUserSelectMenu

open fun applyUserSelectMenu(selectMenu: SelectMenu<*, *>, builder: ActionRowBuilder)

Apply the user select menu to an action row builder.

open suspend override fun call(event: SelectMenuInteractionCreateEvent)

Override this to implement your component's calling logic. Check subtypes for examples!

open fun check(vararg checks: CheckWithCache<SelectMenuInteractionCreateEvent>)

Define a check which must pass for the component's body to be executed.

open fun check(check: CheckWithCache<SelectMenuInteractionCreateEvent>)

Overloaded check function to allow for DSL syntax.

open suspend fun checkBotPerms(context: PublicUserSelectMenuContext<M>)

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

open override fun createContext(event: SelectMenuInteractionCreateEvent, interactionResponse: PublicMessageInteractionResponseBehavior, cache: MutableStringKeyedMap<Any>): PublicUserSelectMenuContext<M>

Function to create the context for the select menu.

open fun defaultUser(vararg users: Snowflake)

open fun defaultUser(vararg users: UserBehavior)

open fun defaultUser(users: Collection<Snowflake>)

Add default pre-selected users to the selector.

open fun disable()

Mark this select menu as disabled.

open fun enable()

Mark this select menu as enabled.

firstSentryBreadcrumb

open suspend fun firstSentryBreadcrumb(context: PublicUserSelectMenuContext<M>, component: SelectMenu<*, *>)

If enabled, adds the initial Sentry breadcrumb to the given context.

open override fun getKoin(): Koin

Get the associated Koin instance.

open suspend fun handleError(context: PublicUserSelectMenuContext<M>, t: Throwable, button: SelectMenu<*, *>)

A general way to handle errors thrown during the course of a select menu action's execution.

initialResponse

fun initialResponse(body: InitialEphemeralSelectMenuResponseBuilder)

Call this to open with a response, omit it to ack instead.

open suspend fun lock()

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

requireBotPermissions

fun requireBotPermissions(vararg perms: Permission)

If your bot requires permissions to be able to execute this component's body, add them using this function.

open suspend override fun respondText(context: PublicUserSelectMenuContext<M>, message: Key, failureType: FailureReason<*>)

Override this to implement a way to respond to the user, regardless of whatever happens.

open suspend fun runChecks(event: SelectMenuInteractionCreateEvent, cache: MutableStringKeyedMap<Any>): Boolean

Override this in order to implement any subclass-specific checks.

runStandardChecks

open suspend fun runStandardChecks(event: SelectMenuInteractionCreateEvent, cache: MutableStringKeyedMap<Any>): Boolean

Runs standard checks that can be handled in a generic way, without worrying about subclass-specific checks.

open fun unlock()

Unlock the mutex, if it's locked.

open override fun validate()

Validation function, called to ensure the component is valid, throws exceptions if not.

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

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