feat(model): add guild_scheduled_events to guild struct (#2371)

Supersedes #2235 Closes #1961 and #2320 --------- Co-authored-by: Tim Vilgot Mikael Fredenberg <[email protected]>
twilight-rs · Sep 9, 2024 · 956ad94 · 956ad94
1 parent f58b540
commit 956ad94
Show file tree

Hide file tree

Showing 12 changed files with 416 additions and 46 deletions.
diff --git a/examples/cache-optimization/models/guild_scheduled_events.rs b/examples/cache-optimization/models/guild_scheduled_events.rs
@@ -0,0 +1,51 @@
+use twilight_cache_inmemory::traits::CacheableGuildScheduledEvent;
+use twilight_model::{
+    guild::scheduled_event::GuildScheduledEvent,
+    id::{
+        marker::{GuildMarker, ScheduledEventMarker},
+        Id,
+    },
+};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct MinimalGuildScheduledEvent {
+    guild_id: Id<GuildMarker>,
+    id: Id<ScheduledEventMarker>,
+    user_count: Option<u64>,
+}
+
+impl From<GuildScheduledEvent> for MinimalGuildScheduledEvent {
+    fn from(event: GuildScheduledEvent) -> Self {
+        Self {
+            guild_id: event.guild_id,
+            id: event.id,
+            user_count: event.user_count,
+        }
+    }
+}
+
+impl PartialEq<GuildScheduledEvent> for MinimalGuildScheduledEvent {
+    fn eq(&self, other: &GuildScheduledEvent) -> bool {
+        self.id == other.id
+    }
+}
+
+impl CacheableGuildScheduledEvent for MinimalGuildScheduledEvent {
+    fn add_user(
+        &mut self,
+        _guild_id: Id<GuildMarker>,
+        _event_id: Id<ScheduledEventMarker>,
+        _user_id: Id<twilight_model::id::marker::UserMarker>,
+    ) {
+        self.user_count = self.user_count.map(|c| c.saturating_add(1));
+    }
+
+    fn remove_user(
+        &mut self,
+        _guild_id: Id<GuildMarker>,
+        _event_id: Id<ScheduledEventMarker>,
+        _user_id: Id<twilight_model::id::marker::UserMarker>,
+    ) {
+        self.user_count = self.user_count.map(|c| c.saturating_sub(1));
+    }
+}
diff --git a/examples/cache-optimization/models/mod.rs b/examples/cache-optimization/models/mod.rs
@@ -8,6 +8,7 @@ pub mod current_user;
 pub mod emoji;
 pub mod guild;
 pub mod guild_integration;
+pub mod guild_scheduled_events;
 pub mod member;
 pub mod message;
 pub mod presence;
@@ -26,6 +27,7 @@ impl CacheableModels for CustomCacheModels {
     type Emoji = emoji::MinimalCachedEmoji;
     type Guild = guild::MinimalCachedGuild;
     type GuildIntegration = guild_integration::MinimalCachedGuildIntegration;
+    type GuildScheduledEvent = guild_scheduled_events::MinimalGuildScheduledEvent;
     type Member = member::MinimalCachedMember;
     type Message = message::MinimalCachedMessage;
     type Presence = presence::MinimalCachedPresence;

diff --git a/twilight-cache-inmemory/src/config.rs b/twilight-cache-inmemory/src/config.rs
@@ -37,6 +37,8 @@ bitflags! {
         const INTEGRATION = 1 << 12;
         /// Information relating to guild stickers.
         const STICKER = 1 << 13;
+        /// Information relating to guild scheduled events.
+        const GUILD_SCHEDULED_EVENT = 1 << 14;
     }
 }
 

diff --git a/twilight-cache-inmemory/src/event/guild.rs b/twilight-cache-inmemory/src/event/guild.rs
@@ -51,7 +51,7 @@ impl<CacheModels: CacheableModels> InMemoryCache<CacheModels> {
         }
 
         if self.wants(ResourceType::STICKER) {
-            self.guild_stage_instances.insert(guild.id, HashSet::new());
+            self.guild_stickers.insert(guild.id, HashSet::new());
             self.cache_stickers(guild.id, mem::take(&mut guild.stickers));
         }
 
@@ -65,6 +65,14 @@ impl<CacheModels: CacheableModels> InMemoryCache<CacheModels> {
             self.cache_stage_instances(guild.id, mem::take(&mut guild.stage_instances));
         }
 
+        if self.wants(ResourceType::GUILD_SCHEDULED_EVENT) {
+            self.guild_scheduled_events.insert(guild.id, HashSet::new());
+            self.cache_guild_scheduled_events(
+                guild.id,
+                mem::take(&mut guild.guild_scheduled_events),
+            );
+        }
+
         if self.wants(ResourceType::GUILD) {
             let guild = CacheModels::Guild::from(guild);
             self.unavailable_guilds.remove(&guild.id());
@@ -295,6 +303,7 @@ mod tests {
             emojis: Vec::new(),
             explicit_content_filter: ExplicitContentFilter::AllMembers,
             features: vec![],
+            guild_scheduled_events: Vec::new(),
             icon: None,
             id: Id::new(123),
             joined_at: Some(Timestamp::from_secs(1_632_072_645).expect("non zero")),

diff --git a/twilight-cache-inmemory/src/event/guild_scheduled_events.rs b/twilight-cache-inmemory/src/event/guild_scheduled_events.rs
@@ -0,0 +1,160 @@
+use twilight_model::{
+    gateway::payload::incoming::{
+        GuildScheduledEventCreate, GuildScheduledEventDelete, GuildScheduledEventUpdate,
+        GuildScheduledEventUserAdd, GuildScheduledEventUserRemove,
+    },
+    guild::scheduled_event::GuildScheduledEvent,
+    id::{marker::GuildMarker, Id},
+};
+
+use crate::{
+    traits::CacheableGuildScheduledEvent, CacheableModels, InMemoryCache, ResourceType, UpdateCache,
+};
+
+impl<CacheModels: CacheableModels> InMemoryCache<CacheModels> {
+    pub(crate) fn cache_guild_scheduled_events(
+        &self,
+        guild_id: Id<GuildMarker>,
+        guild_scheduled_events: impl IntoIterator<Item = GuildScheduledEvent>,
+    ) {
+        for event in guild_scheduled_events {
+            self.cache_guild_scheduled_event(guild_id, event);
+        }
+    }
+
+    fn cache_guild_scheduled_event(
+        &self,
+        guild_id: Id<GuildMarker>,
+        guild_scheduled_event: GuildScheduledEvent,
+    ) {
+        self.guild_scheduled_events
+            .entry(guild_id)
+            .or_default()
+            .insert(guild_scheduled_event.id);
+
+        crate::upsert_guild_item(
+            &self.scheduled_events,
+            guild_id,
+            guild_scheduled_event.id,
+            CacheModels::GuildScheduledEvent::from(guild_scheduled_event),
+        );
+    }
+}
+
+impl<CacheModels: CacheableModels> UpdateCache<CacheModels> for GuildScheduledEventCreate {
+    fn update(&self, cache: &InMemoryCache<CacheModels>) {
+        if !cache.wants(ResourceType::GUILD_SCHEDULED_EVENT) {
+            return;
+        }
+
+        cache.cache_guild_scheduled_event(self.guild_id, self.0.clone());
+    }
+}
+
+impl<CacheModels: CacheableModels> UpdateCache<CacheModels> for GuildScheduledEventDelete {
+    fn update(&self, cache: &InMemoryCache<CacheModels>) {
+        if !cache.wants(ResourceType::GUILD_SCHEDULED_EVENT) {
+            return;
+        }
+
+        if cache.scheduled_events.remove(&self.id).is_some() {
+            if let Some(mut events) = cache.guild_scheduled_events.get_mut(&self.guild_id) {
+                events.remove(&self.id);
+            }
+        }
+    }
+}
+
+impl<CacheModels: CacheableModels> UpdateCache<CacheModels> for GuildScheduledEventUpdate {
+    fn update(&self, cache: &InMemoryCache<CacheModels>) {
+        if !cache.wants(ResourceType::GUILD_SCHEDULED_EVENT) {
+            return;
+        }
+
+        cache.cache_guild_scheduled_event(self.guild_id, self.0.clone());
+    }
+}
+
+impl<CacheModels: CacheableModels> UpdateCache<CacheModels> for GuildScheduledEventUserAdd {
+    fn update(&self, cache: &InMemoryCache<CacheModels>) {
+        cache
+            .scheduled_events
+            .entry(self.guild_scheduled_event_id)
+            .and_modify(|event| {
+                event
+                    .value
+                    .add_user(self.guild_id, self.guild_scheduled_event_id, self.user_id);
+            });
+    }
+}
+
+impl<CacheModels: CacheableModels> UpdateCache<CacheModels> for GuildScheduledEventUserRemove {
+    fn update(&self, cache: &InMemoryCache<CacheModels>) {
+        cache
+            .scheduled_events
+            .entry(self.guild_scheduled_event_id)
+            .and_modify(|event| {
+                event
+                    .value
+                    .remove_user(self.guild_id, self.guild_scheduled_event_id, self.user_id);
+            });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{test, DefaultInMemoryCache};
+    use twilight_model::{
+        gateway::payload::incoming::{
+            GuildScheduledEventCreate, GuildScheduledEventUserAdd, GuildScheduledEventUserRemove,
+        },
+        id::Id,
+    };
+
+    #[test]
+    fn guild_event_on_event() {
+        let cache = DefaultInMemoryCache::new();
+
+        let id = Id::new(1);
+        let guild_id = Id::new(2);
+        let user_id = Id::new(3);
+
+        cache.update(&GuildScheduledEventCreate(test::guild_scheduled_event(
+            id,
+            guild_id,
+            Some(41),
+        )));
+
+        assert_eq!(
+            1,
+            cache.guild_scheduled_events.get(&guild_id).unwrap().len()
+        );
+        assert_eq!(1, cache.scheduled_events.len());
+        assert_eq!(
+            41,
+            cache.scheduled_events.get(&id).unwrap().user_count.unwrap()
+        );
+
+        cache.update(&GuildScheduledEventUserAdd {
+            guild_id,
+            guild_scheduled_event_id: id,
+            user_id,
+        });
+
+        assert_eq!(
+            42,
+            cache.scheduled_events.get(&id).unwrap().user_count.unwrap()
+        );
+
+        cache.update(&GuildScheduledEventUserRemove {
+            guild_id,
+            guild_scheduled_event_id: id,
+            user_id,
+        });
+
+        assert_eq!(
+            41,
+            cache.scheduled_events.get(&id).unwrap().user_count.unwrap()
+        );
+    }
+}
diff --git a/twilight-cache-inmemory/src/event/mod.rs b/twilight-cache-inmemory/src/event/mod.rs
@@ -1,6 +1,7 @@
 pub mod channel;
 pub mod emoji;
 pub mod guild;
+pub mod guild_scheduled_events;
 pub mod integration;
 pub mod interaction;
 pub mod member;