[−][src]Struct serenity::model::id::ChannelId

pub struct ChannelId(pub u64);

An identifier for a Channel

Methods

`impl ChannelId`[src]

`pub fn broadcast_typing(self, http: impl AsRef<Http>) -> Result<()>`[src]

Broadcasts that the current user is typing to a channel for the next 5 seconds.

After 5 seconds, another request must be made to continue broadcasting that the current user is typing.

This should rarely be used for bots, and should likely only be used for signifying that a long-running command is still being executed.

Note: Requires the Send Messages permission.

Examples

use serenity::model::ChannelId;

let _successful = ChannelId(7).broadcast_typing();

`pub fn create_permission( self, http: impl AsRef<Http>, target: &PermissionOverwrite ) -> Result<()>`[src]

Creates a permission overwrite for either a single Member or Role within the channel.

Refer to the documentation for GuildChannel::create_permission for more information.

Requires the Manage Channels permission.

`pub fn create_reaction<M, R>( self, http: impl AsRef<Http>, message_id: M, reaction_type: R ) -> Result<()> where M: Into<MessageId>, R: Into<ReactionType>,` [src]

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 fn delete(self, http: impl AsRef<Http>) -> Result<Channel>`[src]

Deletes this channel, returning the channel on a successful deletion.

`pub fn delete_message<M: Into<MessageId>>( self, http: impl AsRef<Http>, message_id: M ) -> Result<()>`[src]

Deletes a Message given its Id.

Refer to Message::delete for more information.

Requires the Manage Messages permission, if the current user is not the author of the message.

`pub fn delete_messages<T: AsRef<MessageId>, It: IntoIterator<Item = T>>( self, http: impl AsRef<Http>, message_ids: It ) -> Result<()>`[src]

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

Refer to the documentation for Channel::delete_messages for more information.

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 fn delete_permission( self, http: impl AsRef<Http>, permission_type: PermissionOverwriteType ) -> Result<()>`[src]

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

Note: Requires the Manage Channel permission.

`pub fn delete_reaction<M, R>( self, http: impl AsRef<Http>, message_id: M, user_id: Option<UserId>, reaction_type: R ) -> Result<()> where M: Into<MessageId>, R: Into<ReactionType>,` [src]

Deletes the given Reaction from the channel.

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

`pub fn edit<F: FnOnce(&mut EditChannel) -> &mut EditChannel>( self, http: impl AsRef<Http>, f: F ) -> Result<GuildChannel>`[src]

Edits the settings of a Channel, optionally setting new values.

Refer to EditChannel's documentation for its methods.

Requires the Manage Channel permission.

Examples

Change a voice channel's name and bitrate:

// assuming a `channel_id` has been bound

channel_id.edit(&context, |c| c.name("test").bitrate(64000));

`pub fn edit_message<F, M>( self, http: impl AsRef<Http>, message_id: M, f: F ) -> Result<Message> where F: FnOnce(&mut EditMessage) -> &mut EditMessage, M: Into<MessageId>,` [src]

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 to_channel_cached( self, cache: impl AsRef<CacheRwLock> ) -> Option<Channel>`[src]

Attempts to find a Channel by its Id in the cache.

`pub fn to_channel(self, cache_http: impl CacheHttp) -> Result<Channel>`[src]

First attempts to find a Channel by its Id in the cache, upon failure requests it via the REST API.

Note: If the cache-feature is enabled permissions will be checked and upon owning the required permissions the HTTP-request will be issued.

`pub fn invites(self, http: impl AsRef<Http>) -> Result<Vec<RichInvite>>`[src]

Gets all of the channel's invites.

Requires the Manage Channels permission.

`pub fn message<M: Into<MessageId>>( self, http: impl AsRef<Http>, message_id: M ) -> Result<Message>`[src]

Gets a message from the channel.

Requires the Read Message History permission.

`pub fn messages<F>( self, http: impl AsRef<Http>, builder: F ) -> Result<Vec<Message>> where F: FnOnce(&mut GetMessages) -> &mut GetMessages,` [src]

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, cache: impl AsRef<CacheRwLock>) -> Option<String>`[src]

Returns the name of whatever channel this id holds.

`pub fn pin<M: Into<MessageId>>( self, http: impl AsRef<Http>, message_id: M ) -> Result<()>`[src]

Pins a Message to the channel.

`pub fn pins(self, http: impl AsRef<Http>) -> Result<Vec<Message>>`[src]

Gets the list of Messages which are pinned to the channel.

`pub fn reaction_users<M, R, U>( self, http: impl AsRef<Http>, message_id: M, reaction_type: R, limit: Option<u8>, after: U ) -> Result<Vec<User>> where M: Into<MessageId>, R: Into<ReactionType>, U: Into<Option<UserId>>,` [src]

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

Refer to Channel::reaction_users for more information.

Note: Requires the Read Message History permission.

`pub fn say( self, http: impl AsRef<Http>, content: impl Display ) -> Result<Message>`[src]

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 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>,` [src]

Sends a file along with optional message contents. The filename must be specified.

Message contents may be passed by using the CreateMessage::content method.

The Attach Files and Send Messages permissions are required.

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

Examples

Send files with the paths /path/to/file.jpg and /path/to/file2.jpg:

use serenity::model::id::ChannelId;

let channel_id = ChannelId(7);

let paths = vec!["/path/to/file.jpg", "path/to/file2.jpg"];

let _ = channel_id.send_files(&http, paths, |m| {
    m.content("a file")
});

Send files using File:

use serenity::model::id::ChannelId;
use std::fs::File;

let channel_id = ChannelId(7);

let f1 = File::open("my_file.jpg").unwrap();
let f2 = File::open("my_file2.jpg").unwrap();

let files = vec![(&f1, "my_file.jpg"), (&f2, "my_file2.jpg")];

let _ = channel_id.send_files(&http, files, |m| {
    m.content("a file")
});

Errors

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

Returns an HttpError::InvalidRequest(PayloadTooLarge) if the file is too large to send.

`pub 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>,` [src]

Sends a message to the channel.

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

Requires the Send Messages permission.

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

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.