refactor: reactions use the serenity object as a store now

Author: Bloeckchengrafik

src/chat/src/reaction.rs

@@ -13,7 +13,7 @@ pub enum ReactionEmoji {
 }
 
 pub trait MessageReaction {
-  fn get_count(&self, kind: Option<MessageReactionType>) -> u32;
+  fn get_count(&self, kind: Option<MessageReactionType>) -> u64;
   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::{async_list::AsyncListItem, message::Message};
-use serenity::all::Nonce;
 use scope_chat::message::MessageAuthor;
 use scope_chat::reaction::MessageReaction;
-use crate::snowflake::Snowflake;
+use scope_chat::{async_list::AsyncListItem, message::Message};
+use serenity::all::Nonce;
 
 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)).filter_map(Result::ok).collect::<Vec<_>>();
+    let reactions = &msg.reactions.iter().map(|r| reaction::DiscordMessageReaction::from_serenity(r)).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,16 +4,38 @@ use scope_chat::reaction::{MessageReaction, ReactionEmoji, MessageReactionType};
 
 #[derive(Clone, Debug)]
 pub struct DiscordMessageReaction {
-    pub count: u32,
-    pub count_burst: u32,
-    pub self_reaction: Option<MessageReactionType>,
-    pub emoji: ReactionEmoji,
-    pub burst_colors: Vec<Rgba>,
+    pub data: serenity::all::MessageReaction,
 }
 
 impl DiscordMessageReaction {
-    pub fn from_serenity(reaction: &serenity::all::MessageReaction) -> Result<Self, String> {
-        let emoji = match &reaction.reaction_type {
+    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 {
             ReactionType::Custom { animated, id, name } => {
                 ReactionEmoji::Custom {
                     url: format!("https://cdn.discordapp.com/emojis/{}.png", id),
@@ -25,57 +47,20 @@ impl DiscordMessageReaction {
                 ReactionEmoji::Simple(character.clone())
             }
             ty => {
-                return Err(format!("Unsupported reaction type: {:?}", ty));
+                eprintln!("Unsupported reaction type: {:?}", ty);
+                ReactionEmoji::Simple("❓".to_string())
             }
-        };
+        }
+    }
 
-        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| {
+    fn get_burst_colors(&self) -> Vec<Rgba> {
+        self.data.burst_colours.iter().map(|color| {
             Rgba {
                 r: color.r() as f32,
                 g: color.g() as f32,
                 b: color.b() as f32,
                 a: 1f32,
             }
-        }).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()
+        }).collect()
     }
 }