feat: use both serenity and local state, load live reactions

Author: Bloeckchengrafik

Diff for: Cargo.lock

@@ -1,11 +1,13 @@
 use tokio::sync::broadcast;
 
 use crate::{async_list::AsyncList, message::Message};
+use crate::reaction::ReactionOperation;
 
 pub trait Channel: AsyncList<Content = Self::Message> + Send + Sync + Clone {
   type Message: Message;
 
-  fn get_receiver(&self) -> broadcast::Receiver<Self::Message>;
+  fn get_message_receiver(&self) -> broadcast::Receiver<Self::Message>;
+  fn get_reaction_receiver(&self) -> broadcast::Receiver<(String, ReactionOperation)>;
 
   fn send_message(&self, content: String, nonce: String) -> Self::Message;
 }

Diff for: src/chat/src/channel.rs

@@ -2,7 +2,7 @@ use chrono::{DateTime, Utc};
 use gpui::Element;
 
 use crate::async_list::AsyncListItem;
-use crate::reaction::MessageReaction;
+use crate::reaction::ReactionList;
 
 pub trait Message: Clone + AsyncListItem + Send {
   fn get_author(&self) -> &impl MessageAuthor;
@@ -11,7 +11,7 @@ pub trait Message: Clone + AsyncListItem + Send {
   fn get_nonce(&self) -> Option<&String>;
   fn should_group(&self, previous: &Self) -> bool;
   fn get_timestamp(&self) -> Option<DateTime<Utc>>;
-  fn get_reactions(&self) -> Vec<impl MessageReaction>;
+  fn get_reactions(&mut self) -> &mut impl ReactionList;
 }
 
 pub trait MessageAuthor: PartialEq + Eq {

Diff for: src/chat/src/message.rs

@@ -1,3 +1,4 @@
+use std::fmt::Debug;
 use gpui::Rgba;
 
 #[derive(Copy, Clone, Debug)]
@@ -6,15 +7,33 @@ pub enum MessageReactionType {
   Burst,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ReactionEmoji {
   Simple(String),
   Custom { url: String, animated: bool, name: Option<String> },
 }
 
-pub trait MessageReaction {
+pub trait MessageReaction: Debug {
   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>;
+  fn increment(&mut self, kind: MessageReactionType, user_is_self: bool, by: isize);
+}
+
+#[derive(Clone, Debug)]
+pub enum ReactionOperation {
+  Add(ReactionEmoji, MessageReactionType),
+  AddSelf(ReactionEmoji, MessageReactionType),
+  Remove(ReactionEmoji),
+  RemoveSelf(ReactionEmoji),
+  RemoveAll,
+  RemoveEmoji(ReactionEmoji),
+}
+
+pub trait ReactionList {
+  fn get_reactions(&self) -> &Vec<impl MessageReaction>;
+  fn get_reaction(&self, emoji: &ReactionEmoji) -> Option<&impl MessageReaction>;
+  fn increment(&mut self, emoji: &ReactionEmoji, kind: MessageReactionType, user_is_self: bool, by: isize);
+  fn apply(&mut self, operation: ReactionOperation);
 }

Diff for: src/chat/src/reaction.rs

@@ -10,3 +10,4 @@ serenity = { git = "https://github.com/scopeclient/serenity", version = "0.12" }
 tokio = "1.41.1"
 chrono.workspace = true
 scope-backend-cache = { version = "0.1.0", path = "../cache" }
+log = "0.4.22"

Diff for: src/discord/Cargo.toml

@@ -1,36 +1,40 @@
 use std::sync::Arc;
 
+use crate::{
+  client::DiscordClient,
+  message::{content::DiscordMessageContent, DiscordMessage},
+  snowflake::Snowflake,
+};
 use scope_backend_cache::async_list::{refcacheslice::Exists, AsyncListCache};
+use scope_chat::reaction::ReactionOperation;
 use scope_chat::{
   async_list::{AsyncList, AsyncListIndex, AsyncListItem, AsyncListResult},
   channel::Channel,
 };
 use serenity::all::{GetMessages, MessageId, Timestamp};
 use tokio::sync::{broadcast, Mutex, Semaphore};
 
-use crate::{
-  client::DiscordClient,
-  message::{content::DiscordMessageContent, DiscordMessage},
-  snowflake::Snowflake,
-};
-
 pub struct DiscordChannel {
   channel_id: Snowflake,
-  receiver: broadcast::Receiver<DiscordMessage>,
+  message_receiver: broadcast::Receiver<DiscordMessage>,
+  reaction_receiver: broadcast::Receiver<(String, ReactionOperation)>,
   client: Arc<DiscordClient>,
   cache: Arc<Mutex<AsyncListCache<DiscordMessage>>>,
   blocker: Semaphore,
 }
 
 impl DiscordChannel {
   pub async fn new(client: Arc<DiscordClient>, channel_id: Snowflake) -> Self {
-    let (sender, receiver) = broadcast::channel(10);
+    let (message_sender, message_receiver) = broadcast::channel(10);
+    client.add_channel_message_sender(channel_id, message_sender).await;
 
-    client.add_channel_message_sender(channel_id, sender).await;
+    let (reaction_sender, reaction_receiver) = broadcast::channel(10);
+    client.add_channel_reaction_sender(channel_id, reaction_sender).await;
 
     DiscordChannel {
       channel_id,
-      receiver,
+      message_receiver,
+      reaction_receiver,
       client,
       cache: Arc::new(Mutex::new(AsyncListCache::new())),
       blocker: Semaphore::new(1),
@@ -41,8 +45,12 @@ impl DiscordChannel {
 impl Channel for DiscordChannel {
   type Message = DiscordMessage;
 
-  fn get_receiver(&self) -> broadcast::Receiver<Self::Message> {
-    self.receiver.resubscribe()
+  fn get_message_receiver(&self) -> broadcast::Receiver<Self::Message> {
+    self.message_receiver.resubscribe()
+  }
+
+  fn get_reaction_receiver(&self) -> broadcast::Receiver<(String, ReactionOperation)> {
+    self.reaction_receiver.resubscribe()
   }
 
   fn send_message(&self, content: String, nonce: String) -> DiscordMessage {
@@ -61,7 +69,7 @@ impl Channel for DiscordChannel {
       id: Snowflake { content: 0 },
       nonce: Some(nonce),
       creation_time: Timestamp::now(),
-      reactions: vec![],
+      reactions: Default::default(),
     }
   }
 }
@@ -233,7 +241,8 @@ impl Clone for DiscordChannel {
   fn clone(&self) -> Self {
     Self {
       channel_id: self.channel_id,
-      receiver: self.receiver.resubscribe(),
+      message_receiver: self.message_receiver.resubscribe(),
+      reaction_receiver: self.reaction_receiver.resubscribe(),
       client: self.client.clone(),
       cache: self.cache.clone(),
       blocker: Semaphore::new(1),

Diff for: src/discord/src/channel/mod.rs

@@ -3,12 +3,6 @@ use std::{
   sync::{Arc, OnceLock},
 };
 
-use serenity::{
-  all::{Cache, ChannelId, Context, CreateMessage, EventHandler, GatewayIntents, GetMessages, Http, Message, MessageId, Ready},
-  async_trait,
-};
-use tokio::sync::{broadcast, RwLock};
-
 use crate::{
   channel::DiscordChannel,
   message::{
@@ -17,6 +11,14 @@ use crate::{
   },
   snowflake::Snowflake,
 };
+use scope_chat::reaction::{MessageReactionType, ReactionOperation};
+use serenity::all::Reaction;
+use serenity::{
+  all::{Cache, ChannelId, Context, CreateMessage, EventHandler, GatewayIntents, GetMessages, Http, Message, MessageId, Ready},
+  async_trait,
+};
+use tokio::sync::{broadcast, RwLock};
+use crate::message::reaction::discord_reaction_to_emoji;
 
 #[allow(dead_code)]
 struct SerenityClient {
@@ -29,6 +31,7 @@ struct SerenityClient {
 #[derive(Default)]
 pub struct DiscordClient {
   channel_message_event_handlers: RwLock<HashMap<Snowflake, Vec<broadcast::Sender<DiscordMessage>>>>,
+  channel_reaction_event_handlers: RwLock<HashMap<Snowflake, Vec<broadcast::Sender<(String, ReactionOperation)>>>>,
   client: OnceLock<SerenityClient>,
   user: OnceLock<DiscordMessageAuthor>,
   channels: RwLock<HashMap<Snowflake, Arc<DiscordChannel>>>,
@@ -38,10 +41,7 @@ impl DiscordClient {
   pub async fn new(token: String) -> Arc<DiscordClient> {
     let client = Arc::new(DiscordClient::default());
 
-    let mut discord = serenity::Client::builder(token, GatewayIntents::all())
-      .event_handler_arc(client.clone())
-      .await
-      .expect("Error creating client");
+    let mut discord = serenity::Client::builder(token, GatewayIntents::all()).event_handler_arc(client.clone()).await.expect("Error creating client");
 
     let _ = client.client.set(SerenityClient {
       // voice_manager: discord.voice_manager.clone(),
@@ -70,6 +70,10 @@ impl DiscordClient {
     self.channel_message_event_handlers.write().await.entry(channel).or_default().push(sender);
   }
 
+  pub async fn add_channel_reaction_sender(&self, channel: Snowflake, sender: broadcast::Sender<(String, ReactionOperation)>) {
+    self.channel_reaction_event_handlers.write().await.entry(channel).or_default().push(sender);
+  }
+
   pub async fn channel(self: Arc<Self>, channel_id: Snowflake) -> Arc<DiscordChannel> {
     let self_clone = self.clone();
     let mut channels = self_clone.channels.write().await;
@@ -107,8 +111,15 @@ impl DiscordClient {
     // FIXME: proper error handling
     Some(ChannelId::new(channel_id.content).message(self.discord().http.clone(), MessageId::new(message_id.content)).await.unwrap())
   }
-}
 
+  async fn send_reaction_operation(&self, channel_id: Snowflake, message_id: MessageId, operation: ReactionOperation) {
+    if let Some(vec) = self.channel_reaction_event_handlers.read().await.get(&channel_id) {
+      for sender in vec {
+        let _ = sender.send((message_id.to_string(), operation.clone()));
+      }
+    }
+  }
+}
 
 #[async_trait]
 impl EventHandler for DiscordClient {
@@ -130,4 +141,49 @@ impl EventHandler for DiscordClient {
       }
     }
   }
+
+  async fn reaction_add(&self, _: Context, reaction: Reaction) {
+    let channel_snowflake = reaction.channel_id.into();
+
+    let ty = if reaction.burst {
+      MessageReactionType::Burst
+    } else {
+      MessageReactionType::Normal
+    };
+
+    let emoji = discord_reaction_to_emoji(&reaction.emoji);
+
+    let operation = if reaction.member.is_none_or(|member| member.user.id.get() == self.user().id.parse::<u64>().unwrap()) {
+      ReactionOperation::AddSelf(emoji, ty)
+    } else {
+      ReactionOperation::Add(emoji, ty)
+    };
+
+    self.send_reaction_operation(channel_snowflake, reaction.message_id, operation).await;
+  }
+
+  async fn reaction_remove(&self, _: Context, reaction: Reaction) {
+    let channel_snowflake = reaction.channel_id.into();
+
+    let emoji = discord_reaction_to_emoji(&reaction.emoji);
+
+    let operation = if reaction.member.is_none_or(|member| member.user.id.get() == self.user().id.parse::<u64>().unwrap()) {
+      ReactionOperation::RemoveSelf(emoji)
+    } else {
+      ReactionOperation::Remove(emoji)
+    };
+
+    self.send_reaction_operation(channel_snowflake, reaction.message_id, operation).await;
+  }
+
+  async fn reaction_remove_all(&self, _: Context, channel_id: ChannelId, removed_from_message_id: MessageId) {
+    let channel_snowflake = channel_id.into();
+    self.send_reaction_operation(channel_snowflake, removed_from_message_id, ReactionOperation::RemoveAll).await;
+  }
+
+  async fn reaction_remove_emoji(&self, _: Context, removed_reactions: Reaction) {
+    let channel_snowflake = removed_reactions.channel_id.into();
+    let emoji = discord_reaction_to_emoji(&removed_reactions.emoji);
+    self.send_reaction_operation(channel_snowflake, removed_reactions.message_id, ReactionOperation::RemoveEmoji(emoji)).await;
+  }
 }

Diff for: src/discord/src/client.rs

@@ -1,16 +1,17 @@
+use crate::message::reaction::DiscordReactionList;
 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::reaction::ReactionList;
 use scope_chat::{async_list::AsyncListItem, message::Message};
 use serenity::all::Nonce;
 
 pub mod author;
 pub mod content;
-mod reaction;
+pub mod reaction;
 
 #[derive(Clone, Debug)]
 pub struct DiscordMessage {
@@ -19,12 +20,12 @@ pub struct DiscordMessage {
   pub id: Snowflake,
   pub nonce: Option<String>,
   pub creation_time: serenity::model::Timestamp,
-  pub reactions: Vec<reaction::DiscordMessageReaction>,
+  pub reactions: DiscordReactionList,
 }
 
 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_message(r)).collect::<Vec<_>>();
     if !reactions.is_empty() {
       println!("Reactions: {:?}", reactions);
     }
@@ -44,7 +45,7 @@ impl DiscordMessage {
         Nonce::String(s) => s,
       }),
       creation_time: msg.timestamp,
-      reactions: reactions.clone(),
+      reactions: DiscordReactionList::new(reactions),
     }
   }
 }
@@ -78,8 +79,8 @@ impl Message for DiscordMessage {
     DateTime::from_timestamp_millis(ts)
   }
 
-  fn get_reactions(&self) -> Vec<impl MessageReaction> {
-    self.reactions.clone()
+  fn get_reactions(&mut self) -> &mut impl ReactionList {
+    &mut self.reactions
   }
 }