Add caching for members, rewrite part of perms.

src/database/guild.rs

@@ -48,9 +48,14 @@ pub struct Guild {
     pub default_permissions: u32,
 }
 
+#[derive(Hash, Eq, PartialEq)]
+pub struct MemberKey(pub String, pub String);
+
 lazy_static! {
     static ref CACHE: Arc<Mutex<LruCache<String, Guild>>> =
         Arc::new(Mutex::new(LruCache::new(4_000_000)));
+    static ref MEMBER_CACHE: Arc<Mutex<LruCache<MemberKey, Member>>> =
+        Arc::new(Mutex::new(LruCache::new(4_000_000)));
 }
 
 pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
@@ -85,6 +90,44 @@ pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
     }
 }
 
+pub fn fetch_member(key: MemberKey) -> Result<Option<Member>, String> {
+    {
+        if let Ok(mut cache) = MEMBER_CACHE.lock() {
+            let existing = cache.get(&key);
+
+            if let Some(member) = existing {
+                return Ok(Some((*member).clone()));
+            }
+        } else {
+            return Err("Failed to lock cache.".to_string());
+        }
+    }
+
+    let col = get_collection("members");
+    if let Ok(result) = col.find_one(
+        doc! {
+            "_id.guild": &key.0,
+            "_id.user": &key.1,
+        },
+        None,
+    ) {
+        if let Some(doc) = result {
+            if let Ok(member) = from_bson(Bson::Document(doc)) as Result<Member, _> {
+                let mut cache = MEMBER_CACHE.lock().unwrap();
+                cache.put(key, member.clone());
+
+                Ok(Some(member))
+            } else {
+                Err("Failed to deserialize member!".to_string())
+            }
+        } else {
+            Ok(None)
+        }
+    } else {
+        Err("Failed to fetch member from database.".to_string())
+    }
+}
+
 impl<'r> FromParam<'r> for Guild {
     type Error = &'r RawStr;
 
@@ -101,24 +144,6 @@ impl<'r> FromParam<'r> for Guild {
     }
 }
 
-pub fn get_member(guild_id: &String, member: &String) -> Option<Member> {
-    if let Ok(result) = get_collection("members").find_one(
-        doc! {
-            "_id.guild": &guild_id,
-            "_id.user": &member,
-        },
-        None,
-    ) {
-        if let Some(doc) = result {
-            Some(from_bson(Bson::Document(doc)).expect("Failed to unwrap member."))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
 pub fn get_invite<U: Into<Option<String>>>(
     code: &String,
     user: U,
@@ -176,3 +201,60 @@ pub fn get_invite<U: Into<Option<String>>>(
         None
     }
 }
+
+use crate::notifications::events::Notification;
+
+pub fn process_event(event: &Notification) {
+    match event {
+        Notification::guild_channel_create(ev) => {} // ? for later use
+        Notification::guild_channel_create(ev) => {} // ? for later use
+        Notification::guild_delete(ev) => {}
+        Notification::guild_user_join(ev) => {}
+        Notification::guild_user_leave(ev) => {}
+        /*Notification::group_user_join(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            let entry = cache.pop(&ev.id);
+
+            if entry.is_some() {
+                let mut channel = entry.unwrap();
+                channel.recipients.as_mut().unwrap().push(ev.user.clone());
+                cache.put(ev.id.clone(), channel);
+            }
+        }
+        Notification::group_user_leave(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            let entry = cache.pop(&ev.id);
+
+            if entry.is_some() {
+                let mut channel = entry.unwrap();
+                let recipients = channel.recipients.as_mut().unwrap();
+                if let Some(pos) = recipients.iter().position(|x| *x == ev.user) {
+                    recipients.remove(pos);
+                }
+                cache.put(ev.id.clone(), channel);
+            }
+        }
+        Notification::guild_channel_create(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            cache.put(
+                ev.id.clone(),
+                Channel {
+                    id: ev.channel.clone(),
+                    channel_type: 2,
+                    active: None,
+                    last_message: None,
+                    recipients: None,
+                    owner: None,
+                    guild: Some(ev.id.clone()),
+                    name: Some(ev.name.clone()),
+                    description: Some(ev.description.clone())
+                }
+            );
+        }
+        Notification::guild_channel_delete(ev) => {
+            let mut cache = CACHE.lock().unwrap();
+            cache.pop(&ev.channel);
+        }*/
+        _ => {}
+    }
+}