Struct ExecuteWebhook

pub struct ExecuteWebhook<'a> { /* private fields */ }

Execute a webhook, sending a message to its channel.

The message must include at least one of attachments, components, content, or embeds.

Examples

use twilight_http::Client;
use twilight_model::id::Id;

let client = Client::new("my token".to_owned());
let id = Id::new(432);

client
    .execute_webhook(id, "webhook token")
    .content("Pinkie...")
    .await?;

Implementations

impl<'a> ExecuteWebhook<'a>

pub fn allowed_mentions( self, allowed_mentions: Option<&'a AllowedMentions>, ) -> Self

Specify the AllowedMentions for the message.

Unless otherwise called, the request will use the client’s default allowed mentions. Set to None to ignore this default.

pub fn attachments(self, attachments: &'a [Attachment]) -> Self

Attach multiple files to the message.

Calling this method will clear any previous calls.

Errors

Returns an error of type AttachmentDescriptionTooLarge if the attachments’s description is too large.

Returns an error of type AttachmentFilename if any filename is invalid.

pub fn avatar_url(self, avatar_url: &'a str) -> Self

The URL of the avatar of the webhook.

pub fn components(self, components: &'a [Component]) -> Self

Set the message’s list of Components.

Calling this method will clear previous calls.

Requires a webhook owned by the application.

Errors

Refer to the errors section of twilight_validate::component::component for a list of errors that may be returned as a result of validating each provided component.

pub fn content(self, content: &'a str) -> Self

Set the message’s content.

The maximum length is 2000 UTF-16 characters.

Errors

Returns an error of type ContentInvalid if the content length is too long.

pub fn embeds(self, embeds: &'a [Embed]) -> Self

Set the message’s list of embeds.

Calling this method will clear previous calls.

The amount of embeds must not exceed EMBED_COUNT_LIMIT. The total character length of each embed must not exceed EMBED_TOTAL_LENGTH characters. Additionally, the internal fields also have character limits. Refer to Discord Docs/Embed Limits for more information.

Errors

Returns an error of type TooManyEmbeds if there are too many embeds.

Otherwise, refer to the errors section of twilight_validate::embed::embed for a list of errors that may occur.

pub fn flags(self, flags: MessageFlags) -> Self

Set the message’s flags.

The only supported flag is SUPPRESS_EMBEDS.

pub fn payload_json(self, payload_json: &'a [u8]) -> Self

JSON encoded body of any additional request fields.

If this method is called, all other fields are ignored, except for attachments. See Discord Docs/Uploading Files.

Without payload_json:

use twilight_http::Client;
use twilight_model::id::Id;
use twilight_util::builder::embed::EmbedBuilder;

let client = Client::new("token".to_owned());

let message = client
    .execute_webhook(Id::new(1), "token here")
    .content("some content")
    .embeds(&[EmbedBuilder::new().title("title").validate()?.build()])
    .wait()
    .await?
    .model()
    .await?;

assert_eq!(message.content, "some content");

With payload_json:

use twilight_http::Client;
use twilight_model::id::Id;
use twilight_util::builder::embed::EmbedBuilder;

let client = Client::new("token".to_owned());

let message = client
    .execute_webhook(Id::new(1), "token here")
    .content("some content")
    .payload_json(br#"{ "content": "other content", "embeds": [ { "title": "title" } ] }"#)
    .wait()
    .await?
    .model()
    .await?;

assert_eq!(message.content, "other content");

pub fn thread_id(self, thread_id: Id<ChannelMarker>) -> Self

Execute in a thread belonging to the channel instead of the channel itself.

pub fn thread_name(self, thread_name: &'a str) -> Self

Set the name of the created thread when used in a forum channel.

pub fn tts(self, tts: bool) -> Self

Specify true if the message is TTS.

pub fn username(self, username: &'a str) -> Self

Specify the username of the webhook’s message.

Errors

Returns an error of type WebhookUsername if the webhook’s name is invalid.

pub const fn wait(self) -> ExecuteWebhookAndWait<'a>

Wait for the message to send before sending a response. See Discord Docs/Execute Webhook.

Using this will result in receiving the created message.

Trait Implementations

impl IntoFuture for ExecuteWebhook<'_>

type Output = Result<Response<EmptyBody>, Error>

The output that the future will produce on completion.

type IntoFuture = ResponseFuture<EmptyBody>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl TryIntoRequest for ExecuteWebhook<'_>

fn try_into_request(self) -> Result<Request, Error>

Try to convert a request builder into a raw Request.