Struct serenity::model::user::User

pub struct User {
    pub id: UserId,
    pub avatar: Option<String>,
    pub bot: bool,
    pub discriminator: u16,
    pub name: String,
    // some fields omitted
}

Information about a user.

Fields

id: UserId

The unique Id of the user. Can be used to calculate the account's creation date.

avatar: Option<String>

Optional avatar hash.

bot: bool

Indicator of whether the user is a bot.

discriminator: u16

The account's discriminator to differentiate the user from others with the same name. The name+discriminator pair is always unique.

name: String

The account's username. Changing username will trigger a discriminator change if the username+discriminator pair becomes non-unique.

Implementations

impl User

pub fn avatar_url(&self) -> Option<String>

Returns the formatted URL of the user's icon, if one exists.

This will produce a WEBP image URL, or GIF if the user has a GIF avatar.

pub async fn create_dm_channel<'_>(
    &'_ self,
    cache_http: impl CacheHttp
) -> Result<PrivateChannel>

Creates a direct message channel between the current user and the user. This can also retrieve the channel if one already exists.

pub fn created_at(&self) -> DateTime<Utc>

Retrieves the time that this user was created at.

pub fn default_avatar_url(&self) -> String

Returns the formatted URL to the user's default avatar URL.

This will produce a PNG URL.

pub async fn direct_message<F, '_>(
    &'_ self,
    cache_http: impl CacheHttp,
    f: F
) -> Result<Message> where
    F: FnOnce(&'b mut CreateMessage<'a>) -> &'b mut CreateMessage<'a>, 

Sends a message to a user through a direct message channel. This is a channel that can only be accessed by you and the recipient.

Examples

When a user sends a message with a content of "~help", DM the author a help message, and then react with '👌' to verify message sending:

use serenity::model::Permissions;

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "~help" {
            let url = match ctx.cache.current_user().await.invite_url(&ctx, Permissions::empty()).await {
                Ok(v) => v,
                Err(why) => {
                    println!("Error creating invite url: {:?}", why);

                    return;
                },
            };

            let help = format!(
                "Helpful info here. Invite me with this link: <{}>",
                url,
            );

            let dm = msg.author.direct_message(&ctx, |m| {
                m.content(&help)
            })
            .await;

            match dm {
                Ok(_) => {
                    let _ = msg.react(&ctx, '👌').await;
                },
                Err(why) => {
                    println!("Err sending help: {:?}", why);

                    let _ = msg.reply(&ctx, "There was an error DMing you help.").await;
                },
            };
        }
    }
}

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

Examples

Returns a ModelError::MessagingBot if the user being direct messaged is a bot user.

pub async fn dm<F, '_>(
    &'_ self,
    cache_http: impl CacheHttp,
    f: F
) -> Result<Message> where
    F: FnOnce(&'b mut CreateMessage<'a>) -> &'b mut CreateMessage<'a>, 

This is an alias of direct_message.

Examples

Sending a message:

// assuming you are in a context

let _ = message.author.dm("Hello!");

Examples

Returns a ModelError::MessagingBot if the user being direct messaged is a bot user.

pub fn face(&self) -> String

Retrieves the URL to the user's avatar, falling back to the default avatar if needed.

This will call avatar_url first, and if that returns None, it then falls back to default_avatar_url.

pub async fn has_role<'_>(
    &'_ self,
    cache_http: impl CacheHttp,
    guild: impl Into<GuildContainer>,
    role: impl Into<RoleId>
) -> Result<bool>

Check if a user has a Role. This will retrieve the Guild from the Cache if it is available, and then check if that guild has the given Role.

Three forms of data may be passed in to the guild parameter: either a PartialGuild, a GuildId, or a u64.

Examples

Check if a guild has a Role by Id:

// Assumes a 'guild_id' and `role_id` have already been bound
let _ = message.author.has_role(guild_id, role_id);

pub async fn refresh<'_>(&'_ mut self, cache_http: impl CacheHttp) -> Result<()>

Refreshes the information about the user.

Replaces the instance with the data retrieved over the REST API.

pub fn static_avatar_url(&self) -> Option<String>

Returns a static formatted URL of the user's icon, if one exists.

This will always produce a WEBP image URL.

pub fn tag(&self) -> String

Returns the "tag" for the user.

The "tag" is defined as "username#discriminator", such as "zeyla#5479".

Examples

Make a command to tell the user what their tag is:

use serenity::utils::MessageBuilder;
use serenity::utils::ContentModifier::Bold;

struct Handler;

#[serenity::async_trait]
impl EventHandler for Handler {
    async fn message(&self, context: Context, msg: Message) {
        if msg.content == "!mytag" {
            let content = MessageBuilder::new()
                .push("Your tag is ")
                .push(Bold + msg.author.tag())
                .build();

            let _ = msg.channel_id.say(&context.http, &content).await;
        }
    }
}
let mut client =Client::builder("token").event_handler(Handler).await?;

client.start().await?;

pub async fn nick_in<'_>(
    &'_ self,
    cache_http: impl CacheHttp,
    guild_id: impl Into<GuildId>
) -> Option<String>

Returns the user's nickname in the given guild_id.

If none is used, it returns None.

pub fn await_reply<'a>(
    &self,
    shard_messenger: &'a impl AsRef<ShardMessenger>
) -> CollectReply<'a>

Returns a future that will await one message by this user.

pub fn await_replies<'a>(
    &self,
    shard_messenger: &'a impl AsRef<ShardMessenger>
) -> MessageCollectorBuilder<'a>

Returns a stream builder which can be awaited to obtain a stream of messages sent by this user.

pub fn await_reaction<'a>(
    &self,
    shard_messenger: &'a impl AsRef<ShardMessenger>
) -> CollectReaction<'a>

Await a single reaction by this user.

pub fn await_reactions<'a>(
    &self,
    shard_messenger: &'a impl AsRef<ShardMessenger>
) -> ReactionCollectorBuilder<'a>

Returns a stream builder which can be awaited to obtain a stream of reactions sent by this user.

Trait Implementations

impl Clone for User

fn clone(&self) -> User

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for User

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

Formats the value using the given formatter.

impl Default for User

fn default() -> Self

Initializes a User with default values. Setting the following:

• id to UserId(210)
• avatar to Some("abc")
• bot to true.
• discriminator to 1432.
• name to "test".

impl<'de> Deserialize<'de> for User

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

Deserialize this value from the given Serde deserializer.

impl Display for User

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

Formats a string which will mention the user.

impl Eq for User

impl<'a> From<&'a CurrentUser> for User

fn from(user: &'a CurrentUser) -> Self

Performs the conversion.

impl<'a> From<&'a User> for UserId

fn from(user: &User) -> UserId

Gets the Id of a User.

impl From<CurrentUser> for User

fn from(user: CurrentUser) -> Self

Performs the conversion.

impl From<User> for UserId

fn from(user: User) -> UserId

Gets the Id of a User.

impl Hash for User

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Mentionable for User

fn mention(&self) -> String

Creates a mentionable string, that will be able to notify and/or create a link to the item.

impl PartialEq<User> for User

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for User

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

Serialize this value into the given Serde serializer.