explicitly cache member list

youmubot-prelude/src/member_cache.rs

@@ -5,19 +5,15 @@ use serenity::model::{
     id::{GuildId, UserId},
 };
 use serenity::{http::CacheHttp, prelude::*};
-use std::collections::HashMap as Map;
 use std::sync::Arc;
 
-use crate::OkPrint;
-
 const VALID_CACHE_SECONDS: i64 = 15 * 60; // 15 minutes
 
 /// MemberCache resolves `does User belong to Guild` requests, and store them in a cache.
 #[derive(Debug, Default)]
 pub struct MemberCache {
     per_user: DashMap<(UserId, GuildId), Expiring<Option<Member>>>,
-    per_guild: DashMap<GuildId, Expiring<Map<UserId, Member>>>,
-    guild_counts: DashMap<GuildId, Option<u64>>,
+    per_guild: DashMap<GuildId, Expiring<Arc<[Member]>>>,
 }
 
 #[derive(Debug)]
@@ -50,62 +46,6 @@ impl MemberCache {
         cache_http: impl CacheHttp,
         user_id: UserId,
         guild_id: GuildId,
-    ) -> Option<Member> {
-        let members_count = match self.guild_counts.get(&guild_id) {
-            Some(v) => v.clone(),
-            None => {
-                let res = guild_id
-                    .to_partial_guild_with_counts(cache_http.http())
-                    .await
-                    .ok()
-                    .and_then(|v| v.approximate_member_count);
-                self.guild_counts.insert(guild_id, res);
-                res
-            }
-        };
-        match members_count {
-            Some(g) if g <= 1000 => self.query_per_guild(cache_http, user_id, guild_id).await,
-            _ => self.query_per_user(cache_http, user_id, guild_id).await,
-        }
-    }
-
-    async fn query_per_guild(
-        &self,
-        cache_http: impl CacheHttp,
-        user_id: UserId,
-        guild_id: GuildId,
-    ) -> Option<Member> {
-        let now = Utc::now();
-        // Check cache
-        if let Some(r) = self.per_guild.get(&guild_id) {
-            if r.timeout > now {
-                return r.get(&user_id).cloned();
-            }
-        }
-        // query
-        let members = guild_id
-            .members(cache_http.http(), None, None)
-            .await
-            .pls_ok()?
-            .into_iter()
-            .map(|m| (m.user.id, m))
-            .collect::<Map<_, _>>();
-        let result = members.get(&user_id).cloned();
-        self.per_guild.insert(
-            guild_id,
-            Expiring::new(
-                members,
-                now + chrono::Duration::seconds(VALID_CACHE_SECONDS),
-            ),
-        );
-        result
-    }
-
-    async fn query_per_user(
-        &self,
-        cache_http: impl CacheHttp,
-        user_id: UserId,
-        guild_id: GuildId,
     ) -> Option<Member> {
         let now = Utc::now();
         // Check cache
@@ -125,4 +65,31 @@ impl MemberCache {
         );
         t
     }
+
+    pub async fn query_members(
+        &self,
+        cache_http: impl CacheHttp,
+        guild_id: GuildId,
+    ) -> crate::Result<Arc<[Member]>> {
+        let now = Utc::now();
+        // Check cache
+        if let Some(r) = self.per_guild.get(&guild_id) {
+            if r.timeout > now {
+                return Ok(r.value.clone());
+            }
+        }
+        // query
+        let members: Arc<[Member]> = guild_id
+            .members(cache_http.http(), None, None)
+            .await?
+            .into();
+        self.per_guild.insert(
+            guild_id,
+            Expiring::new(
+                members.clone(),
+                now + chrono::Duration::seconds(VALID_CACHE_SECONDS),
+            ),
+        );
+        Ok(members)
+    }
 }