Attach channels on guild object.

src/database/guild.rs

@@ -1,4 +1,5 @@
 use super::get_collection;
+use super::channel::Channel;
 
 use lru::LruCache;
 use mongodb::bson::{doc, from_bson, Bson};
@@ -164,6 +165,31 @@ pub fn fetch_guilds(ids: &Vec<String>) -> Result<Vec<Guild>, String> {
     }
 }
 
+pub fn serialise_guilds_with_channels(ids: &Vec<String>) -> Result<Vec<JsonValue>, String> {
+    let guilds = fetch_guilds(&gids)?;
+    let cids: Vec<String> = guilds
+        .iter()
+        .flat_map(|x| x.channels.clone())
+        .collect();
+
+    let channels = database::channel::fetch_channels(&cids)?;
+    let data: Vec<rocket_contrib::json::JsonValue> = guilds
+        .into_iter()
+        .map(|x| {
+            let id = x.id.clone();
+            let mut obj = x.serialise();
+            obj.as_object_mut().unwrap().insert(
+                "channels".to_string(),
+                channels.iter()
+                    .filter(|x| x.guild.is_some() && x.guild.as_ref().unwrap() == &id)
+                    .map(|x| x.clone().serialise())
+                    .collect()
+            );
+            obj
+        })
+        .collect()
+}
+
 pub fn fetch_member(key: MemberKey) -> Result<Option<Member>, String> {
     {
         if let Ok(mut cache) = MEMBER_CACHE.lock() {

src/database/user.rs

@@ -1,6 +1,6 @@
 use super::get_collection;
-use super::guild::{Guild, fetch_guilds};
+use super::guild::{serialise_guilds_with_channels};
-use super::channel::{Channel, fetch_channels};
+use super::channel::{fetch_channels};
 
 use lru::LruCache;
 use mongodb::bson::{doc, from_bson, Bson, DateTime};
@@ -131,20 +131,7 @@ impl User {
             })
             .collect();
 
-        let guild_objects = fetch_guilds(&self.find_guilds()?)?;
+        let channels: Vec<JsonValue> = fetch_channels(&self.find_dms()?)?
-        let mut cids: Vec<String> = guild_objects
-            .iter()
-            .flat_map(|x| x.channels.clone())
-            .collect();
-
-        cids.append(&mut self.find_dms()?);
-
-        let channels: Vec<JsonValue> = fetch_channels(&cids)?
-            .into_iter()
-            .map(|x| x.serialise())
-            .collect();
-        
-        let guilds: Vec<JsonValue> = guild_objects
             .into_iter()
             .map(|x| x.serialise())
             .collect();
@@ -152,7 +139,7 @@ impl User {
         Ok(json!({
             "users": users,
             "channels": channels,
-            "guilds": guilds,
+            "guilds": serialise_guilds_with_channels(&self.find_guilds()?)?,
             "user": self.serialise(super::Relationship::SELF as i32)
         }))
     }

src/routes/guild.rs

@@ -2,7 +2,7 @@ use super::channel::ChannelType;
 use super::Response;
 use crate::database::guild::{fetch_member as get_member, get_invite, Guild, MemberKey};
 use crate::database::{
-    self, channel::fetch_channel, guild::fetch_guilds, channel::Channel, Permission, PermissionCalculator, user::User
+    self, channel::fetch_channel, guild::fetch_guilds, guild::serialise_guilds_with_channels, channel::Channel, Permission, PermissionCalculator, user::User
 };
 use crate::notifications::{
     self,
@@ -37,33 +37,8 @@ macro_rules! with_permissions {
 #[get("/@me")]
 pub fn my_guilds(user: User) -> Response {
     if let Ok(gids) = user.find_guilds() {
-        if let Ok(guilds) = fetch_guilds(&gids) {
+        if let Ok(data) = serialise_guilds_with_channels(&gids) {
-            let cids: Vec<String> = guilds
+            Response::Success(data)
-                .iter()
-                .flat_map(|x| x.channels.clone())
-                .collect();
-
-            if let Ok(channels) = database::channel::fetch_channels(&cids) {
-                let data: Vec<rocket_contrib::json::JsonValue> = guilds
-                    .into_iter()
-                    .map(|x| {
-                        let id = x.id.clone();
-                        let mut obj = x.serialise();
-                        obj.as_object_mut().unwrap().insert(
-                            "channels".to_string(),
-                            channels.iter()
-                                .filter(|x| x.guild.is_some() && x.guild.as_ref().unwrap() == &id)
-                                .map(|x| x.clone().serialise())
-                                .collect()
-                        );
-                        obj
-                    })
-                    .collect();
-                
-                Response::Success(json!(data))
-            } else {
-                Response::InternalServerError(json!({ "error": "Failed to fetch channels." }))
-            }
         } else {
             Response::InternalServerError(json!({ "error": "Failed to fetch guilds." }))
         }