Add GuildId param to ChannelId::to_channel (#2895)

Author: GnomedDev

examples/e04_message_builder/src/main.rs

@@ -12,7 +12,7 @@ struct Handler;
 impl EventHandler for Handler {
     async fn message(&self, context: Context, msg: Message) {
         if msg.content == "!ping" {
-            let channel = match msg.channel_id.to_channel(&context).await {
+            let channel = match msg.channel(&context).await {
                 Ok(channel) => channel,
                 Err(why) => {
                     println!("Error getting channel: {why:?}");

examples/testing/src/main.rs

@@ -161,8 +161,8 @@ async fn message(ctx: &Context, msg: Message) -> Result<(), serenity::Error> {
             )
             .await?;
     } else if msg.content == "assigntags" {
-        let forum_id = channel_id.to_channel(ctx).await?.guild().unwrap().parent_id.unwrap();
-        let forum = forum_id.to_channel(ctx).await?.guild().unwrap();
+        let forum_id = msg.guild_channel(&ctx).await?.parent_id.unwrap();
+        let forum = forum_id.to_guild_channel(&ctx, msg.guild_id).await?;
         channel_id
             .edit_thread(
                 &ctx.http,
@@ -195,15 +195,18 @@ async fn message(ctx: &Context, msg: Message) -> Result<(), serenity::Error> {
 
         msg.author.dm(&ctx.http, builder).await?;
     } else if let Some(channel) = msg.content.strip_prefix("movetorootandback") {
-        let mut channel =
-            channel.trim().parse::<ChannelId>().unwrap().to_channel(ctx).await?.guild().unwrap();
+        let mut channel = {
+            let channel_id = channel.trim().parse::<ChannelId>().unwrap();
+            channel_id.to_guild_channel(&ctx, msg.guild_id).await.unwrap()
+        };
+
         let parent_id = channel.parent_id.unwrap();
         channel.edit(&ctx.http, EditChannel::new().category(None)).await?;
         channel.edit(&ctx.http, EditChannel::new().category(Some(parent_id))).await?;
     } else if msg.content == "channelperms" {
         let guild = guild_id.to_guild_cached(&ctx.cache).unwrap().clone();
         let perms = guild.user_permissions_in(
-            &channel_id.to_channel(ctx).await?.guild().unwrap(),
+            guild.channels.get(&channel_id).unwrap(),
             &*guild.member(&ctx.http, msg.author.id).await?,
         );
         channel_id.say(&ctx.http, format!("{:?}", perms)).await?;

src/model/channel/channel_id.rs

@@ -360,23 +360,30 @@ impl ChannelId {
         http.follow_news_channel(self, &map).await
     }
 
-    /// First attempts to retrieve the channel from the `temp_cache` if enabled, otherwise performs
-    /// a HTTP request.
-    ///
-    /// It is recommended to first check if the channel is accessible via `Cache::guild` and
-    /// `Guild::members`, although this requires a `GuildId`.
+    /// Attempts to retrieve the channel from the guild cache, otherwise from HTTP/temp cache.
     ///
     /// # Errors
     ///
     /// Returns [`Error::Http`] if the channel retrieval request failed.
-    pub async fn to_channel(self, cache_http: impl CacheHttp) -> Result<Channel> {
-        #[cfg(feature = "temp_cache")]
-        {
-            if let Some(cache) = cache_http.cache() {
-                if let Some(channel) = cache.temp_channels.get(&self) {
-                    return Ok(Channel::Guild(GuildChannel::clone(&*channel)));
+    pub async fn to_channel(
+        self,
+        cache_http: impl CacheHttp,
+        guild_id: Option<GuildId>,
+    ) -> Result<Channel> {
+        #[cfg(feature = "cache")]
+        if let Some(cache) = cache_http.cache() {
+            if let Some(guild_id) = guild_id {
+                if let Some(guild) = cache.guild(guild_id) {
+                    if let Some(channel) = guild.channels.get(&self) {
+                        return Ok(Channel::Guild(channel.clone()));
+                    }
                 }
             }
+
+            #[cfg(feature = "temp_cache")]
+            if let Some(channel) = cache.temp_channels.get(&self) {
+                return Ok(Channel::Guild(GuildChannel::clone(&*channel)));
+            }
         }
 
         let channel = cache_http.http().get_channel(self).await?;
@@ -396,6 +403,29 @@ impl ChannelId {
         Ok(channel)
     }
 
+    /// Fetches a channel from the cache, falling back to HTTP/temp cache.
+    ///
+    /// It is highly recommended to pass the `guild_id` parameter as otherwise this may perform many
+    /// HTTP requests.
+    ///
+    /// # Errors
+    ///
+    /// Errors if the HTTP fallback fails, or if the channel does not come from the guild passed.
+    pub async fn to_guild_channel(
+        self,
+        cache_http: impl CacheHttp,
+        guild_id: Option<GuildId>,
+    ) -> Result<GuildChannel> {
+        let channel = self.to_channel(cache_http, guild_id).await?;
+        let guild_channel = channel.guild().ok_or(ModelError::InvalidChannelType)?;
+
+        if guild_id.is_some_and(|id| guild_channel.guild_id != id) {
+            return Err(Error::Model(ModelError::ChannelNotFound));
+        }
+
+        Ok(guild_channel)
+    }
+
     /// Gets all of the channel's invites.
     ///
     /// Requires the [Manage Channels] permission.

src/model/channel/message.rs

@@ -182,16 +182,23 @@ impl Message {
     }
 
     /// 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.
+    /// HTTP.
     ///
     /// # Errors
     ///
     /// Can return an error if the HTTP request fails.
     pub async fn channel(&self, cache_http: impl CacheHttp) -> Result<Channel> {
-        self.channel_id.to_channel(cache_http).await
+        self.channel_id.to_channel(cache_http, self.guild_id).await
+    }
+
+    /// First attempts to find the [`GuildChannel`] by it's Id in the cache, upon failure requests
+    /// it via HTTP.
+    ///
+    /// # Errors
+    ///
+    /// Can return an error if the HTTP request fails, or this is executed in a DM channel.
+    pub async fn guild_channel(&self, cache_http: impl CacheHttp) -> Result<GuildChannel> {
+        self.channel_id.to_guild_channel(cache_http, self.guild_id).await
     }
 
     /// Deletes the message.
@@ -654,9 +661,10 @@ impl Message {
             }
         }
 
-        let channel = self.channel_id.to_channel(&cache_http).await.ok()?.guild()?;
+        let http = cache_http.http();
+        let channel = http.get_channel(self.channel_id).await.ok()?.guild()?;
         if channel.thread_metadata.is_some() {
-            let thread_parent = channel.parent_id?.to_channel(cache_http).await.ok()?.guild()?;
+            let thread_parent = http.get_channel(channel.parent_id?).await.ok()?.guild()?;
             thread_parent.parent_id
         } else {
             channel.parent_id

src/model/channel/reaction.rs

@@ -104,7 +104,7 @@ impl Reaction {
     ///
     /// [Read Message History]: Permissions::READ_MESSAGE_HISTORY
     pub async fn channel(&self, cache_http: impl CacheHttp) -> Result<Channel> {
-        self.channel_id.to_channel(cache_http).await
+        self.channel_id.to_channel(cache_http, self.guild_id).await
     }
 
     /// Deletes the reaction, but only if the current user is the user who made the reaction or has

src/model/webhook.rs

@@ -165,23 +165,6 @@ pub struct WebhookChannel {
     pub name: FixedString<u16>,
 }
 
-#[cfg(feature = "model")]
-impl WebhookChannel {
-    /// First attempts to retrieve the channel from the `temp_cache` if enabled, otherwise performs
-    /// a HTTP request.
-    ///
-    /// It is recommended to first check if the channel is accessible via `Cache::guild` and
-    /// `Guild::members`, although this requires a `GuildId`.
-    ///
-    /// # Errors
-    ///
-    /// Returns [`Error::Http`] if the channel retrieval request failed.
-    pub async fn to_channel(self, cache_http: impl CacheHttp) -> Result<GuildChannel> {
-        let channel = self.id.to_channel(cache_http).await?;
-        channel.guild().ok_or(Error::Model(ModelError::InvalidChannelType))
-    }
-}
-
 #[cfg(feature = "model")]
 impl Webhook {
     /// Retrieves a webhook given its Id.

src/utils/argument_convert/channel.rs

@@ -46,7 +46,7 @@ async fn lookup_channel_global(
     s: &str,
 ) -> Result<Channel, ChannelParseError> {
     if let Some(channel_id) = s.parse().ok().or_else(|| crate::utils::parse_channel_mention(s)) {
-        return channel_id.to_channel(&ctx).await.map_err(ChannelParseError::Http);
+        return channel_id.to_channel(ctx, guild_id).await.map_err(ChannelParseError::Http);
     }
 
     let guild_id = guild_id.ok_or(ChannelParseError::NotFoundOrMalformed)?;