Struct twilight_http::request::channel::webhook::execute_webhook::ExecuteWebhook

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

Execute a webhook, sending a message to its channel.

You can only specify one of content, embeds, or files.

Examples

use twilight_http::Client;
use twilight_model::id::WebhookId;

let client = Client::new("my token".to_owned());
let id = WebhookId::new(432).expect("non zero");

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

Implementations

impl<'a> ExecuteWebhook<'a>

pub fn allowed_mentions(self, allowed_mentions: AllowedMentions) -> Self

Specify the AllowedMentions for the webhook message.

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

The URL of the avatar of the webhook.

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

Add multiple Components to a message.

Calling this method multiple times will clear previous calls.

Errors

Returns an ExecuteWebhookErrorType::ComponentCount error type if too many components are provided.

Returns an ExecuteWebhookErrorType::ComponentInvalid error type if one of the provided components is invalid.

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

The content of the webhook’s message.

Up to 2000 UTF-16 codepoints, same as a message.

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

Set the list of embeds of the webhook’s message.

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

Attach multiple files to the webhook.

pub const 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 file. See Discord Docs/Create Message.

Examples

Without payload_json:

use twilight_embed_builder::EmbedBuilder;
use twilight_model::id::{MessageId, WebhookId};

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

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

With payload_json:

use twilight_model::id::{MessageId, WebhookId};

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

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

pub fn thread_id(self, thread_id: ChannelId) -> Self

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

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

Specify true if the message is TTS.

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

Specify the username of the webhook’s message.

pub 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.

pub fn exec(self) -> ResponseFuture<EmptyBody>

Execute the request, returning a future resolving to a Response.