Revert "refactor: reactions use the serenity object as a store now"

This reverts commit 002e44c.

Author: Bloeckchengrafik

src/chat/src/reaction.rs

@@ -13,7 +13,7 @@ pub enum ReactionEmoji {
 }
 
 pub trait MessageReaction {
-  fn get_count(&self, kind: Option<MessageReactionType>) -> u64;
+  fn get_count(&self, kind: Option<MessageReactionType>) -> u32;
   fn get_self_reaction(&self) -> Option<MessageReactionType>;
   fn get_emoji(&self) -> ReactionEmoji;
   fn get_burst_colors(&self) -> Vec<Rgba>;

src/discord/src/message/mod.rs

@@ -1,12 +1,12 @@
-use crate::snowflake::Snowflake;
 use author::{DiscordMessageAuthor, DisplayName};
 use chrono::{DateTime, Utc};
 use content::DiscordMessageContent;
 use gpui::{Element, IntoElement};
-use scope_chat::message::MessageAuthor;
-use scope_chat::reaction::MessageReaction;
 use scope_chat::{async_list::AsyncListItem, message::Message};
 use serenity::all::Nonce;
+use scope_chat::message::MessageAuthor;
+use scope_chat::reaction::MessageReaction;
+use crate::snowflake::Snowflake;
 
 pub mod author;
 pub mod content;
@@ -24,9 +24,9 @@ pub struct DiscordMessage {
 
 impl DiscordMessage {
   pub fn from_serenity(msg: &serenity::all::Message) -> Self {
-    let reactions = &msg.reactions.iter().map(|r| reaction::DiscordMessageReaction::from_serenity(r)).collect::<Vec<_>>();
+    let reactions = &msg.reactions.iter().map(|r| reaction::DiscordMessageReaction::from_serenity(r)).filter_map(Result::ok).collect::<Vec<_>>();
     if !reactions.is_empty() {
-      println!("Reactions: {:?}", reactions);
+        println!("Reactions: {:?}", reactions);
     }
     DiscordMessage {
       id: Snowflake { content: msg.id.get() },

src/discord/src/message/reaction.rs

@@ -4,38 +4,16 @@ use scope_chat::reaction::{MessageReaction, ReactionEmoji, MessageReactionType};
 
 #[derive(Clone, Debug)]
 pub struct DiscordMessageReaction {
-    pub data: serenity::all::MessageReaction,
+    pub count: u32,
+    pub count_burst: u32,
+    pub self_reaction: Option<MessageReactionType>,
+    pub emoji: ReactionEmoji,
+    pub burst_colors: Vec<Rgba>,
 }
 
 impl DiscordMessageReaction {
-    pub fn from_serenity(reaction: &serenity::all::MessageReaction) -> Self {
-        DiscordMessageReaction {
-            data: reaction.clone(),
-        }
-    }
-}
-
-impl MessageReaction for DiscordMessageReaction {
-    fn get_count(&self, kind: Option<MessageReactionType>) -> u64 {
-        match kind {
-            Some(MessageReactionType::Burst) => self.data.count_details.burst,
-            Some(MessageReactionType::Normal) => self.data.count_details.normal,
-            None => self.data.count,
-        }
-    }
-
-    fn get_self_reaction(&self) -> Option<MessageReactionType> {
-        if self.data.me {
-            Some(MessageReactionType::Normal)
-        } else if self.data.me_burst {
-            Some(MessageReactionType::Burst)
-        } else {
-            None
-        }
-    }
-
-    fn get_emoji(&self) -> ReactionEmoji {
-        match &self.data.reaction_type {
+    pub fn from_serenity(reaction: &serenity::all::MessageReaction) -> Result<Self, String> {
+        let emoji = match &reaction.reaction_type {
             ReactionType::Custom { animated, id, name } => {
                 ReactionEmoji::Custom {
                     url: format!("https://cdn.discordapp.com/emojis/{}.png", id),
@@ -47,20 +25,57 @@ impl MessageReaction for DiscordMessageReaction {
                 ReactionEmoji::Simple(character.clone())
             }
             ty => {
-                eprintln!("Unsupported reaction type: {:?}", ty);
-                ReactionEmoji::Simple("❓".to_string())
+                return Err(format!("Unsupported reaction type: {:?}", ty));
             }
-        }
-    }
+        };
 
-    fn get_burst_colors(&self) -> Vec<Rgba> {
-        self.data.burst_colours.iter().map(|color| {
+        let count = reaction.count_details.normal as u32;
+        let count_burst = reaction.count_details.burst as u32;
+        let burst_colors = reaction.burst_colours.iter().map(|color| {
             Rgba {
                 r: color.r() as f32,
                 g: color.g() as f32,
                 b: color.b() as f32,
                 a: 1f32,
             }
-        }).collect()
+        }).collect();
+
+        let self_reaction = if reaction.me {
+            Some(MessageReactionType::Normal)
+        } else if reaction.me_burst {
+            Some(MessageReactionType::Burst)
+        } else {
+            None
+        };
+
+        Ok(DiscordMessageReaction {
+            count,
+            count_burst,
+            self_reaction,
+            emoji,
+            burst_colors,
+        })
+    }
+}
+
+impl MessageReaction for DiscordMessageReaction {
+    fn get_count(&self, kind: Option<MessageReactionType>) -> u32 {
+        match kind {
+            Some(MessageReactionType::Burst) => self.count_burst,
+            Some(MessageReactionType::Normal) => self.count,
+            None => self.count + self.count_burst,
+        }
+    }
+
+    fn get_self_reaction(&self) -> Option<MessageReactionType> {
+        self.self_reaction
+    }
+
+    fn get_emoji(&self) -> ReactionEmoji {
+        self.emoji.clone()
+    }
+
+    fn get_burst_colors(&self) -> Vec<Rgba> {
+        self.burst_colors.clone()
     }
 }