Struct twilight_http::request::application::UpdateFollowupMessage

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

Update a followup message.

A followup message must always have at least one embed or some amount of content. If you wish to delete a followup message refer to DeleteFollowupMessage.

Examples

Update a followup message by setting the content to test <@3> - attempting to mention user ID 3 - and specifying that only that the user may not be mentioned.

use std::env;
use twilight_http::Client;
use twilight_model::{
    channel::message::AllowedMentions,
    id::{MessageId, ApplicationId}
};

let client = Client::new(env::var("DISCORD_TOKEN")?);
client.set_application_id(ApplicationId(1));

client.update_followup_message("token here", MessageId(2))?
    // By creating a default set of allowed mentions, no entity can be
    // mentioned.
    .allowed_mentions(AllowedMentions::default())
    .content(Some("test <@3>".to_owned()))?
    .await?;

Implementations

impl<'a> UpdateFollowupMessage<'a>

pub const EMBED_COUNT_LIMIT: usize

Maximum number of embeds that a followup message may have.

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

Set the allowed mentions in the message.

pub fn attachment(self, attachment: Attachment) -> Self

Specify an attachment already present in the target message to keep.

If called, all unspecified attachments will be removed from the message. If not called, all attachments will be kept.

pub fn attachments(
    self,
    attachments: impl IntoIterator<Item = Attachment>
) -> Self

Specify multiple attachments already present in the target message to keep.

If called, all unspecified attachments will be removed from the message. If not called, all attachments will be kept.

pub fn content(
    self,
    content: Option<String>
) -> Result<Self, UpdateFollowupMessageError>

Set the content of the message.

Pass None if you want to remove the message content.

Note that if there is are no embeds then you will not be able to remove the content of the message.

The maximum length is 2000 UTF-16 characters.

Errors

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

pub fn embeds(
    self,
    embeds: Option<Vec<Embed>>
) -> Result<Self, UpdateFollowupMessageError>

Set the list of embeds of the followup message.

Pass None to remove all of the embeds.

The maximum number of allowed embeds is defined by EMBED_COUNT_LIMIT.

The total character length of each embed must not exceed 6000 characters. Additionally, the internal fields also have character limits. Refer to the discord docs for more information.

Examples

Create an embed and update the message with the new embed. The content of the original message is unaffected and only the embed(s) are modified.

use std::env;
use twilight_http::Client;
use twilight_embed_builder::EmbedBuilder;
use twilight_model::id::{ApplicationId, MessageId};

let client = Client::new(env::var("DISCORD_TOKEN")?);
client.set_application_id(ApplicationId(1));

let embed = EmbedBuilder::new()
    .description("Powerful, flexible, and scalable ecosystem of Rust libraries for the Discord API.")
    .title("Twilight")
    .url("https://twilight.rs")
    .build()?;

client.update_followup_message("token", MessageId(2))?
    .embeds(Some(vec![embed]))?
    .await?;

Errors

Returns an UpdateFollowupMessageErrorType::EmbedTooLarge error type if one of the embeds are too large.

Returns an UpdateFollowupMessageErrorType::TooManyEmbeds error type if more than 10 embeds are provided.

pub fn file(self, name: impl Into<String>, file: impl Into<Vec<u8>>) -> Self

Attach a file to the followup message.

This method is repeatable.

pub fn files<N: Into<String>, F: Into<Vec<u8>>>(
    self,
    attachments: impl IntoIterator<Item = (N, F)>
) -> Self

Attach multiple files to the followup message.

pub fn payload_json(self, payload_json: impl Into<Vec<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 and CreateFollowupMessage::payload_json.

Trait Implementations

impl Future for UpdateFollowupMessage<'_>

type Output = Result<(), Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.