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::channel::{Channel, fetch_channels};
+use super::guild::{serialise_guilds_with_channels};
+use super::channel::{fetch_channels};
 
 use lru::LruCache;
 use mongodb::bson::{doc, from_bson, Bson, DateTime};
@@ -130,29 +130,16 @@ impl User {
                 )
             })
             .collect();
-        
-        let guild_objects = fetch_guilds(&self.find_guilds()?)?;
-        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)?
+        let channels: Vec<JsonValue> = fetch_channels(&self.find_dms()?)?
             .into_iter()
             .map(|x| x.serialise())
             .collect();
         
-        let guilds: Vec<JsonValue> = guild_objects
-            .into_iter()
-            .map(|x| x.serialise())
-            .collect();
-
         Ok(json!({
             "users": users,
             "channels": channels,
-            "guilds": guilds,
+            "guilds": serialise_guilds_with_channels(&self.find_guilds()?)?,
             "user": self.serialise(super::Relationship::SELF as i32)
         }))
     }