Struct serenity::model::guild::Member

pub struct Member {
    pub deaf: bool,
    pub guild_id: GuildId,
    pub joined_at: Option<DateTime<FixedOffset>>,
    pub mute: bool,
    pub nick: Option<String>,
    pub roles: Vec<RoleId>,
    pub user: Arc<RwLock<User>>,
    // some fields omitted
}

Information about a member of a guild.

Fields

deaf: bool

Indicator of whether the member can hear in voice channels.

guild_id: GuildId

The unique Id of the guild that the member is a part of.

joined_at: Option<DateTime<FixedOffset>>

Timestamp representing the date when the member joined.

mute: bool

Indicator of whether the member can speak in voice channels.

nick: Option<String>

The member's nickname, if present.

Can't be longer than 32 characters.

roles: Vec<RoleId>

Vector of Ids of Roles given to the member.

user: Arc<RwLock<User>>

Attached User struct.

Implementations

impl Member

pub fn add_role<R: Into<RoleId>>(
    &mut self,
    http: impl AsRef<Http>,
    role_id: R
) -> Result<()>

Adds a Role to the member, editing its roles in-place if the request was successful.

Note: Requires the Manage Roles permission.

pub fn add_roles(
    &mut self,
    http: impl AsRef<Http>,
    role_ids: &[RoleId]
) -> Result<()>

Adds one or multiple Roles to the member, editing its roles in-place if the request was successful.

Note: Requires the Manage Roles permission.

pub fn ban<BO: BanOptions>(
    &self,
    http: impl AsRef<Http>,
    ban_options: &BO
) -> Result<()>

Ban the member from its guild, deleting the last X number of days' worth of messages.

Note: Requires the Ban Members permission.

Errors

Returns a ModelError::GuildNotFound if the guild could not be found.

pub fn colour(&self, cache: impl AsRef<CacheRwLock>) -> Option<Colour>

Determines the member's colour.

pub fn default_channel(
    &self,
    cache: impl AsRef<CacheRwLock>
) -> Option<Arc<RwLock<GuildChannel>>>

Returns the "default channel" of the guild for the member. (This returns the first channel that can be read by the member, if there isn't one returns None)

pub fn display_name(&self) -> Cow<'_, String>

Calculates the member's display name.

The nickname takes priority over the member's username if it exists.

pub fn distinct(&self) -> String

Returns the DiscordTag of a Member, taking possible nickname into account.

pub fn edit<F: FnOnce(&mut EditMember) -> &mut EditMember>(
    &self,
    http: impl AsRef<Http>,
    f: F
) -> Result<()>

Edits the member with the given data. See Guild::edit_member for more information.

See EditMember for the permission(s) required for separate builder methods, as well as usage of this.

pub fn highest_role_info(
    &self,
    cache: impl AsRef<CacheRwLock>
) -> Option<(RoleId, i64)>

Retrieves the ID and position of the member's highest role in the hierarchy, if they have one.

This may return None if:

• the user has roles, but they are not present in the cache for cache inconsistency reasons
• you already have a write lock to the member's guild

The "highest role in hierarchy" is defined as the role with the highest position. If two or more roles have the same highest position, then the role with the lowest ID is the highest.

pub fn kick(&self, cache_http: impl CacheHttp) -> Result<()>

Kick the member from the guild.

Note: Requires the Kick Members permission.

Examples

Kick a member from its guild:

// assuming a `member` has already been bound
match member.kick() {
    Ok(()) => println!("Successfully kicked member"),
    Err(Error::Model(ModelError::GuildNotFound)) => {
        println!("Couldn't determine guild of member");
    },
    Err(Error::Model(ModelError::InvalidPermissions(missing_perms))) => {
        println!("Didn't have permissions; missing: {:?}", missing_perms);
    },
    _ => {},
}

Errors

Returns a ModelError::GuildNotFound if the Id of the member's guild could not be determined.

If the cache is enabled, returns a ModelError::InvalidPermissions if the current user does not have permission to perform the kick.

pub fn kick_with_reason(
    &self,
    cache_http: impl CacheHttp,
    reason: &str
) -> Result<()>

Kicks the member from the guild, with a reason.

Note: Requires the [Kick Members] permission.

Examples

Kicks a member from it's guild, with an optional reason:

match member.kick(&ctx.http, "A Reason") {
    Ok(()) => println!("Successfully kicked member"),
    Err(Error::Model(ModelError::GuildNotFound)) => {
        println!("Couldn't determine guild of member");
    },
    Err(Error::Model(ModelError::InvalidPermissions(missing_perms))) => {
        println!("Didn't have permissions; missing: {:?}", missing_perms);
    },
    _ => {},
}

Errors

Same as kick

pub fn permissions(&self, cache: impl AsRef<CacheRwLock>) -> Result<Permissions>

Returns the guild-level permissions for the member.

Examples

// assuming there's a `member` variable gotten from anything.
println!("The permission bits for the member are: {}",
member.permissions().expect("permissions").bits);

Errors

Returns a ModelError::GuildNotFound if the guild the member's in could not be found in the cache.

And/or returns ModelError::ItemMissing if the "default channel" of the guild is not found.

pub fn remove_role<R: Into<RoleId>>(
    &mut self,
    http: impl AsRef<Http>,
    role_id: R
) -> Result<()>

Removes a Role from the member, editing its roles in-place if the request was successful.

Note: Requires the Manage Roles permission.

pub fn remove_roles(
    &mut self,
    http: impl AsRef<Http>,
    role_ids: &[RoleId]
) -> Result<()>

Removes one or multiple Roles from the member.

Note: Requires the Manage Roles permission.

pub fn roles(&self, cache: impl AsRef<CacheRwLock>) -> Option<Vec<Role>>

Retrieves the full role data for the user's roles.

This is shorthand for manually searching through the Cache.

If role data can not be found for the member, then None is returned.

pub fn unban(&self, http: impl AsRef<Http>) -> Result<()>

Unbans the User from the guild.

Note: Requires the Ban Members permission.

Errors

If the cache is enabled, returns a ModelError::InvalidPermissions if the current user does not have permission to perform bans.

pub fn user_id(&self) -> UserId

Retrieves the member's user ID.

This is a shortcut for accessing the user structfield, retrieving a reader guard, and then copying its ID.

Deadlocking

This function can deadlock while retrieving a read guard to the user object if your application infinitely holds a write lock elsewhere.

Trait Implementations

impl Clone for Member

pub fn clone(&self) -> Member

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Member

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Member

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

Deserialize this value from the given Serde deserializer.

impl Display for Member

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

Mentions the user so that they receive a notification.

Examples

// assumes a `member` has already been bound
println!("{} is a member!", member);

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

pub fn from(member: &Member) -> UserId

Gets the Id of a Member.

impl From<Member> for UserId

pub fn from(member: Member) -> UserId

Gets the Id of a Member.

impl Mentionable for Member

pub fn mention(&self) -> String

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

impl Serialize for Member

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

Serialize this value into the given Serde serializer.