Struct serenity::model::channel::Attachment

pub struct Attachment {
    pub id: String,
    pub filename: String,
    pub height: Option<u64>,
    pub proxy_url: String,
    pub size: u64,
    pub url: String,
    pub width: Option<u64>,
}

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

Fields

id: String

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.

Methods

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 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 serenity::model::prelude::*;
use serenity::prelude::*;
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::Path;

struct Handler;

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

                    return;
                },
            };

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

                    return;
                },
            };

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

                return;
            }

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

    fn ready(&self, _: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
    }
}
let token = env::var("DISCORD_TOKEN").expect("token in environment");
let mut client = Client::new(&token, Handler).unwrap();

client.start().unwrap();

Errors

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

Returns an Error::Hyper 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 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.

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.