Struct serenity::builder::CreateEmbed

pub struct CreateEmbed(pub HashMap<&'static str, Value>);

A builder to create a fake Embed object, for use with the ChannelId::send_message and ExecuteWebhook::embeds methods.

Examples

Refer to the documentation for ChannelId::send_message for a very in-depth example on how to use this.

Tuple Fields

0: HashMap<&'static str, Value>

Implementations

impl CreateEmbed

pub fn author<F>(&mut self, f: F) -> &mut Self where
    F: FnOnce(&mut CreateEmbedAuthor) -> &mut CreateEmbedAuthor, 

Build the author of the embed.

Refer to the documentation for CreateEmbedAuthor for more information.

pub fn set_author(&mut self, author: CreateEmbedAuthor) -> &mut Self

Set the author of the embed.

pub fn color<C: Into<Colour>>(&mut self, colour: C) -> &mut Self

Set the colour of the left-hand side of the embed.

This is an alias of Self::colour.

pub fn colour<C: Into<Colour>>(&mut self, colour: C) -> &mut Self

Set the colour of the left-hand side of the embed.

pub fn description<D: ToString>(&mut self, description: D) -> &mut Self

Set the description of the embed.

Note: This can’t be longer than 4096 characters.

pub fn field<T, U>(&mut self, name: T, value: U, inline: bool) -> &mut Self where
    T: ToString,
    U: ToString, 

Set a field. Note that this will not overwrite other fields, and will add to them.

Note: Maximum amount of characters you can put is 256 in a field name and 1024 in a field value.

pub fn fields<T, U, It>(&mut self, fields: It) -> &mut Self where
    It: IntoIterator<Item = (T, U, bool)>,
    T: ToString,
    U: ToString, 

Adds multiple fields at once.

This is sugar to reduce the need of calling Self::field manually multiple times.

pub fn footer<F>(&mut self, f: F) -> &mut Self where
    F: FnOnce(&mut CreateEmbedFooter) -> &mut CreateEmbedFooter, 

Build the footer of the embed.

Refer to the documentation for CreateEmbedFooter for more information.

pub fn set_footer(
    &mut self,
    create_embed_footer: CreateEmbedFooter
) -> &mut Self

Set the footer of the embed.

pub fn image<S: ToString>(&mut self, url: S) -> &mut Self

Set the image associated with the embed. This only supports HTTP(S).

pub fn thumbnail<S: ToString>(&mut self, url: S) -> &mut Self

Set the thumbnail of the embed. This only supports HTTP(S).

pub fn timestamp<T: Into<Timestamp>>(&mut self, timestamp: T) -> &mut Self

Set the timestamp.

You may pass a direct string:

• 2017-01-03T23:00:00
• 2004-06-08T16:04:23
• 2004-06-08T16:04:23

This timestamp must be in ISO-8601 format. It must also be in UTC format.

You can also pass an instance of chrono::DateTime<Utc>, which will construct the timestamp string out of it.

Examples

Passing a string timestamp:

use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, context: Context, mut msg: Message) {
        if msg.content == "~embed" {
            let _ = msg
                .channel_id
                .send_message(&context.http, |m| {
                    m.embed(|e| e.title("hello").timestamp("2004-06-08T16:04:23"));

                    m
                })
                .await;
        }
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

Creating a join-log:

Note: this example isn’t efficient and is for demonstrative purposes.

use serenity::model::guild::Member;
use serenity::model::id::GuildId;
use serenity::prelude::*;

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn guild_member_addition(&self, context: Context, guild_id: GuildId, member: Member) {
        if let Ok(guild) = guild_id.to_partial_guild(&context).await {
            let channels = guild.channels(&context).await.unwrap();

            let channel_search = channels.values().find(|c| c.name == "join-log");

            if let Some(channel) = channel_search {
                let user = &member.user;

                let _ = channel
                    .send_message(&context, |m| {
                        m.embed(|e| {
                            e.author(|a| a.icon_url(&user.face()).name(&user.name));
                            e.title("Member Join");

                            if let Some(ref joined_at) = member.joined_at {
                                e.timestamp(joined_at);
                            }

                            e
                        })
                    })
                    .await;
            }
        }
    }
}

let mut client = Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub fn title<D: ToString>(&mut self, title: D) -> &mut Self

Set the title of the embed.

pub fn url<S: ToString>(&mut self, url: S) -> &mut Self

Set the URL to direct to when clicking on the title.

pub fn attachment<S: ToString>(&mut self, filename: S) -> &mut Self

Same as calling Self::image with “attachment://filename.(jpg, png)”.

Note however, you have to be sure you set an attachment (with ChannelId::send_files) with the provided filename. Or else this won’t work.

Trait Implementations

impl Clone for CreateEmbed

fn clone(&self) -> CreateEmbed

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CreateEmbed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CreateEmbed

fn default() -> CreateEmbed

Creates a builder with default values, setting the type to rich.

impl From<Embed> for CreateEmbed

fn from(embed: Embed) -> Self

Converts the fields of an embed into the values for a new embed builder.

Some values - such as Proxy URLs - are not preserved.