Struct serenity::model::channel::Attachment

#[non_exhaustive]
pub struct Attachment {
    pub id: AttachmentId,
    pub filename: String,
    pub height: Option<u64>,
    pub proxy_url: String,
    pub size: u64,
    pub url: String,
    pub width: Option<u64>,
    pub content_type: Option<String>,
    pub ephemeral: bool,
}

A file uploaded with a message. Not to be confused with Embeds.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: AttachmentId

The unique ID given to this attachment.

filename: String

The filename of the file that was uploaded. This is equivalent to what the uploader had their file named.

height: Option<u64>

If the attachment is an image, then the height of the image is provided.

proxy_url: String

The proxy URL.

size: u64

The size of the file in bytes.

url: String

The URL of the uploaded attachment.

width: Option<u64>

If the attachment is an image, then the width of the image is provided.

content_type: Option<String>

The attachment’s media type.

ephemeral: bool

Whether this attachment is ephemeral.

Ephemeral attachments will automatically be removed after a set period of time.

Ephemeral attachments on messages are guaranteed to be available as long as the message itself exists.

Implementations

impl Attachment

pub fn dimensions(&self) -> Option<(u64, u64)>

If this attachment is an image, then a tuple of the width and height in pixels is returned.

pub async fn download(&self) -> Result<Vec<u8>>

Downloads the attachment, returning back a vector of bytes.

Examples

Download all of the attachments associated with a Message:

use std::io::Write;
use std::path::Path;

use serenity::model::prelude::*;
use serenity::prelude::*;
use tokio::fs::File;
use tokio::io::AsyncWriteExt;

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, context: Context, mut message: Message) {
        for attachment in message.attachments {
            let content = match attachment.download().await {
                Ok(content) => content,
                Err(why) => {
                    println!("Error downloading attachment: {:?}", why);
                    let _ =
                        message.channel_id.say(&context, "Error downloading attachment").await;

                    return;
                },
            };

            let mut file = match File::create(&attachment.filename).await {
                Ok(file) => file,
                Err(why) => {
                    println!("Error creating file: {:?}", why);
                    let _ = message.channel_id.say(&context, "Error creating file").await;

                    return;
                },
            };

            if let Err(why) = file.write_all(&content).await {
                println!("Error writing to file: {:?}", why);

                return;
            }

            let _ = message
                .channel_id
                .say(&context, &format!("Saved {:?}", attachment.filename))
                .await;
        }
    }

    async fn ready(&self, _: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
    }
}
let token = std::env::var("DISCORD_TOKEN")?;
let mut client = Client::builder(&token).event_handler(Handler).await?;

client.start().await?;

Errors

Returns an Error::Io when there is a problem reading the contents of the HTTP response.

Returns an Error::Http when there is a problem retrieving the attachment.

Trait Implementations

impl Clone for Attachment

fn clone(&self) -> Attachment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Attachment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Attachment

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Attachment

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.