Struct serenity::builder::CreateEmbed

pub struct CreateEmbed(pub VecMap<&'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.

Methods

impl CreateEmbed

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

Set the author of the embed.

Refer to the documentation for CreateEmbedAuthor for more information.

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

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

This is an alias of colour.

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

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

pub fn description<D: Display>(self, description: D) -> Self

Set the description of the embed.

Note: This can't be longer than 2048 characters.

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

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>(self, fields: It) -> Self where     It: IntoIterator<Item = (T, U, bool)>,     T: Display,     U: Display,

Adds multiple fields at once.

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

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

Set the footer of the embed.

Refer to the documentation for CreateEmbedFooter for more information.

pub fn image<S: AsRef<str>>(self, url: S) -> Self

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

pub fn thumbnail<S: AsRef<str>>(self, url: S) -> Self

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

pub fn timestamp<T: Into<Timestamp>>(self, timestamp: T) -> 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 anything that implements chrono::TimeZone.

Examples

Passing a string timestamp:

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

struct Handler;

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

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

Creating a join-log:

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

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

struct Handler;

impl EventHandler for Handler {
    fn guild_member_addition(&self, _: Context, guild_id: GuildId, member: Member) {
        use serenity::CACHE;
        let cache = CACHE.read();

        if let Some(guild) = cache.guild(guild_id) {
            let guild = guild.read();

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

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

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

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

                        e
                    }));
            }
        }
    }
}

let mut client = Client::new("token", Handler).unwrap();

client.start().unwrap();

pub fn title<D: Display>(self, title: D) -> Self

Set the title of the embed.

pub fn url<S: AsRef<str>>(self, url: S) -> Self

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

pub fn attachment<S: AsRef<str>>(self, filename: S) -> Self

Same as calling 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 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) -> CreateEmbed

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

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

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.