Struct serenity::model::channel::PrivateChannel

pub struct PrivateChannel {
    pub id: ChannelId,
    pub last_message_id: Option<MessageId>,
    pub last_pin_timestamp: Option<DateTime<Utc>>,
    pub kind: ChannelType,
    pub recipient: User,
    // some fields omitted
}

A Direct Message text channel with another user.

Fields

id: ChannelId

The unique Id of the private channel.

Can be used to calculate the first message's creation date.

last_message_id: Option<MessageId>

The Id of the last message sent.

last_pin_timestamp: Option<DateTime<Utc>>

Timestamp of the last time a Message was pinned.

kind: ChannelType

Indicator of the type of channel this is.

This should always be ChannelType::Private.

recipient: User

The recipient to the private channel.

Implementations

impl PrivateChannel

pub async fn broadcast_typing<'_>(
    &'_ self,
    http: impl AsRef<Http>
) -> Result<()>

Broadcasts that the current user is typing to the recipient.

pub async fn create_reaction<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>,
    reaction_type: impl Into<ReactionType>
) -> Result<()>

React to a Message with a custom Emoji or unicode character.

Message::react may be a more suited method of reacting in most cases.

Requires the Add Reactions permission, if the current user is the first user to perform a react with a certain emoji.

pub async fn delete<'_>(&'_ self, http: impl AsRef<Http>) -> Result<Channel>

Deletes the channel. This does not delete the contents of the channel, and is equivalent to closing a private channel on the client, which can be re-opened.

pub async fn delete_messages<T: AsRef<MessageId>, It: IntoIterator<Item = T>, '_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_ids: It
) -> Result<()> where
    T: AsRef<MessageId>,
    It: IntoIterator<Item = T>, 

Deletes all messages by Ids from the given vector in the channel.

The minimum amount of messages is 2 and the maximum amount is 100.

Requires the Manage Messages permission.

Note: Messages that are older than 2 weeks can't be deleted using this method.

Errors

Returns ModelError::BulkDeleteAmount if an attempt was made to delete either 0 or more than 100 messages.

pub async fn delete_permission<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    permission_type: PermissionOverwriteType
) -> Result<()>

Deletes all permission overrides in the channel from a member or role.

Note: Requires the Manage Channel permission.

pub async fn delete_reaction<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>,
    user_id: Option<UserId>,
    reaction_type: impl Into<ReactionType>
) -> Result<()>

Deletes the given Reaction from the channel.

Note: Requires the Manage Messages permission, if the current user did not perform the reaction.

pub async fn edit_message<F, '_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>,
    f: F
) -> Result<Message> where
    F: FnOnce(&mut EditMessage) -> &mut EditMessage, 

Edits a Message in the channel given its Id.

Message editing preserves all unchanged message data.

Refer to the documentation for EditMessage for more information regarding message restrictions and requirements.

Note: Requires that the current user be the author of the message.

Errors

Returns a ModelError::MessageTooLong if the content of the message is over the the limit, containing the number of unicode code points over the limit.

pub fn is_nsfw(&self) -> bool

Determines if the channel is NSFW.

Note: This method is for consistency. This will always return false, due to DMs not being considered NSFW.

pub async fn message<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>
) -> Result<Message>

Gets a message from the channel.

Requires the Read Message History permission.

pub async fn messages<F, '_>(
    &'_ self,
    http: impl AsRef<Http>,
    builder: F
) -> Result<Vec<Message>> where
    F: FnOnce(&mut GetMessages) -> &mut GetMessages, 

Gets messages from the channel.

Refer to GetMessages for more information on how to use builder.

Requires the Read Message History permission.

pub fn name(&self) -> String

Returns "DM with $username#discriminator".

pub async fn reaction_users<M, R, U, '_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>,
    reaction_type: impl Into<ReactionType>,
    limit: Option<u8>,
    after: impl Into<Option<UserId>>
) -> Result<Vec<User>>

Gets the list of Users who have reacted to a Message with a certain Emoji.

The default limit is 50 - specify otherwise to receive a different maximum number of users. The maximum that may be retrieve at a time is 100, if a greater number is provided then it is automatically reduced.

The optional after attribute is to retrieve the users after a certain user. This is useful for pagination.

Note: Requires the Read Message History permission.

pub async fn pin<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>
) -> Result<()>

Pins a Message to the channel.

pub async fn pins<'_>(&'_ self, http: impl AsRef<Http>) -> Result<Vec<Message>>

Retrieves the list of messages that have been pinned in the private channel.

pub async fn say<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    content: impl Display
) -> Result<Message>

Sends a message with just the given message content in the channel.

Errors

Returns a ModelError::MessageTooLong if the content of the message is over the above limit, containing the number of unicode code points over the limit.

pub async fn send_files<'a, F, T, It, '_>(
    &'_ self,
    http: impl AsRef<Http>,
    files: It,
    f: F
) -> Result<Message> where
    F: FnOnce(&'b mut CreateMessage<'a>) -> &'b mut CreateMessage<'a>,
    T: Into<AttachmentType<'a>>,
    It: IntoIterator<Item = T>, 

Sends (a) file(s) along with optional message contents.

Refer to ChannelId::send_files for examples and more information.

The Attach Files and Send Messages permissions are required.

Note: Message contents must be under 2000 unicode code points.

Errors

If the content of the message is over the above limit, then a ModelError::MessageTooLong will be returned, containing the number of unicode code points over the limit.

pub async fn send_message<'a, F, '_>(
    &'_ self,
    http: impl AsRef<Http>,
    f: F
) -> Result<Message> where
    F: FnOnce(&'b mut CreateMessage<'a>) -> &'b mut CreateMessage<'a>, 

Sends a message to the channel with the given content.

Refer to the documentation for CreateMessage for more information regarding message restrictions and requirements.

Errors

Returns a ModelError::MessageTooLong if the content of the message is over the above limit, containing the number of unicode code points over the limit.

pub fn start_typing(self, http: &Arc<Http>) -> Result<Typing>

Starts typing in the channel for an indefinite period of time.

Returns Typing that is used to trigger the typing. Typing::stop must be called on the returned struct to stop typing. Note that on some clients, typing may persist for a few seconds after stop is called. Typing is also stopped when the struct is dropped.

If a message is sent while typing is triggered, the user will stop typing for a brief period of time and then resume again until either stop is called or the struct is dropped.

This should rarely be used for bots, although it is a good indicator that a long-running command is still being processed.

Examples

// Initiate typing (assuming http is `Arc<Http>` and `channel` is bound)
let typing = channel.start_typing(&http)?;

// Run some long-running process
long_process();

// Stop typing
typing.stop();

pub async fn unpin<'_>(
    &'_ self,
    http: impl AsRef<Http>,
    message_id: impl Into<MessageId>
) -> Result<()>

Unpins a Message in the channel given by its Id.

Requires the Manage Messages permission.

Trait Implementations

impl Clone for PrivateChannel

fn clone(&self) -> PrivateChannel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateChannel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PrivateChannel

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

Deserialize this value from the given Serde deserializer.

impl Display for PrivateChannel

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

Formats the private channel, displaying the recipient's username.

impl<'a> From<&'a PrivateChannel> for ChannelId

fn from(private_channel: &PrivateChannel) -> ChannelId

Gets the Id of a private channel.

impl From<PrivateChannel> for ChannelId

fn from(private_channel: PrivateChannel) -> ChannelId

Gets the Id of a private channel.

impl Mentionable for PrivateChannel

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 PrivateChannel

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

Serialize this value into the given Serde serializer.