fix: cleanup merge (-shown reactions)

Author: Bloeckchengrafik

src/chat/src/channel.rs

@@ -1,16 +1,17 @@
 use std::{fmt::Debug, sync::Arc};
 
 use tokio::sync::broadcast;
-
+use tokio::sync::broadcast::Receiver;
 use crate::reaction::ReactionEvent;
 use crate::{async_list::AsyncList, message::Message};
 
+
 pub trait Channel: AsyncList<Content = Self::Message> + Send + Sync + Clone {
   type Message: Message<Identifier = Self::Identifier>;
   type Identifier: Sized + Copy + Clone + Debug + Eq + PartialEq;
 
   fn get_message_receiver(&self) -> broadcast::Receiver<Self::Message>;
-  fn get_reaction_receiver(&self) -> broadcast::Receiver<ReactionEvent>;
+  fn get_reaction_receiver(&self) -> broadcast::Receiver<ReactionEvent<Self::Identifier>>;
 
   fn send_message(&self, content: String, nonce: String) -> Self::Message;
 
@@ -25,8 +26,12 @@ impl<C: Channel> Channel for Arc<C> {
     (**self).get_identifier()
   }
 
-  fn get_receiver(&self) -> broadcast::Receiver<Self::Message> {
-    (**self).get_receiver()
+  fn get_message_receiver(&self) -> Receiver<Self::Message> {
+    (**self).get_message_receiver()
+  }
+
+  fn get_reaction_receiver(&self) -> Receiver<ReactionEvent<Self::Identifier>> {
+    (**self).get_reaction_receiver()
   }
 
   fn send_message(&self, content: String, nonce: String) -> Self::Message {

src/chat/src/reaction.rs

@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Formatter};
 use gpui::{IntoElement, Rgba};
 
-pub type ReactionEvent = (String, ReactionOperation);
+pub type ReactionEvent<T> = (T, ReactionOperation);
 
 #[derive(Copy, Clone, Debug)]
 pub enum MessageReactionType {

src/discord/src/channel/mod.rs

@@ -1,10 +1,5 @@
 use std::sync::{Arc, OnceLock};
 
-use crate::{
-  client::DiscordClient,
-  message::{content::DiscordMessageContent, DiscordMessage},
-  snowflake::Snowflake,
-};
 use chrono::Utc;
 use scope_backend_cache::async_list::{refcacheslice::Exists, AsyncListCache};
 use scope_chat::reaction::ReactionEvent;
@@ -24,7 +19,7 @@ use crate::{
 pub struct DiscordChannel {
   channel: Arc<serenity::model::channel::Channel>,
   message_receiver: broadcast::Receiver<DiscordMessage>,
-  reaction_receiver: broadcast::Receiver<ReactionEvent>,
+  reaction_receiver: broadcast::Receiver<ReactionEvent<Snowflake>>,
   client: Arc<DiscordClient>,
   cache: Arc<Mutex<AsyncListCache<DiscordMessage>>>,
   blocker: Semaphore,
@@ -58,7 +53,7 @@ impl Channel for DiscordChannel {
     self.message_receiver.resubscribe()
   }
 
-  fn get_reaction_receiver(&self) -> broadcast::Receiver<ReactionEvent> {
+  fn get_reaction_receiver(&self) -> broadcast::Receiver<ReactionEvent<Snowflake>> {
     self.reaction_receiver.resubscribe()
   }
 
@@ -82,7 +77,7 @@ impl Channel for DiscordChannel {
         list_item_id: Snowflake::random(),
       },
       content: OnceLock::new(),
-      reactions: Default::default()
+      reactions: Default::default(),
     }
   }
 

src/discord/src/client.rs

@@ -3,24 +3,11 @@ use std::{
   sync::{Arc, OnceLock, Weak},
 };
 
-use crate::{
-  channel::DiscordChannel,
-  message::{
-    author::{DiscordMessageAuthor, DisplayName},
-    DiscordMessage,
-  },
-  snowflake::Snowflake,
-};
-use scope_chat::reaction::{MessageReactionType, ReactionEvent, 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;
 use atomic_refcell::AtomicRefCell;
 use dashmap::DashMap;
+use scope_chat::reaction::{MessageReactionType, ReactionEvent, ReactionOperation};
+use serenity::all::Reaction;
 use serenity::{
   all::{
     Cache, CacheHttp, ChannelId, Context, CreateMessage, EventHandler, GatewayIntents, GetMessages, GuildId, Http, Member, Message, MessageId,
@@ -53,7 +40,7 @@ impl CacheHttp for SerenityClient {
 #[derive(Default)]
 pub struct DiscordClient {
   channel_message_event_handlers: RwLock<HashMap<ChannelId, Vec<broadcast::Sender<DiscordMessage>>>>,
-  channel_reaction_event_handlers: RwLock<HashMap<Snowflake, Vec<broadcast::Sender<ReactionEvent>>>>,
+  channel_reaction_event_handlers: RwLock<HashMap<ChannelId, Vec<broadcast::Sender<ReactionEvent<Snowflake>>>>>,
   client: OnceLock<SerenityClient>,
   user: OnceLock<Arc<User>>,
   channels: RwLock<HashMap<ChannelId, Arc<DiscordChannel>>>,
@@ -108,7 +95,7 @@ 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<ReactionEvent>) {
+  pub async fn add_channel_reaction_sender(&self, channel: ChannelId, sender: broadcast::Sender<ReactionEvent<Snowflake>>) {
     self.channel_reaction_event_handlers.write().await.entry(channel).or_default().push(sender);
   }
 
@@ -152,10 +139,10 @@ impl DiscordClient {
     Some(channel_id.message(self.discord().http.clone(), message_id).await.unwrap())
   }
 
-  async fn send_reaction_operation(&self, channel_id: Snowflake, message_id: MessageId, operation: ReactionOperation) {
+  async fn send_reaction_operation(&self, channel_id: ChannelId, 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()));
+        let _ = sender.send((message_id.into(), operation.clone()));
       }
     }
   }
@@ -194,47 +181,43 @@ 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 me_id = self.user.get().expect("User not ready").id;
 
-    let operation = if reaction.member.is_none_or(|member| member.user.id.get() == self.user().id.parse::<u64>().unwrap()) {
+    let operation = if reaction.member.is_none_or(|member| member.user.id == me_id) {
       ReactionOperation::AddSelf(emoji, ty)
     } else {
       ReactionOperation::Add(emoji, ty)
     };
 
-    self.send_reaction_operation(channel_snowflake, reaction.message_id, operation).await;
+    self.send_reaction_operation(reaction.channel_id, 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 me_id = self.user.get().expect("User not ready").id;
 
-    let operation = if reaction.member.is_none_or(|member| member.user.id.get() == self.user().id.parse::<u64>().unwrap()) {
+    let operation = if reaction.member.is_none_or(|member| member.user.id == me_id) {
       ReactionOperation::RemoveSelf(emoji)
     } else {
       ReactionOperation::Remove(emoji)
     };
 
-    self.send_reaction_operation(channel_snowflake, reaction.message_id, operation).await;
+    self.send_reaction_operation(reaction.channel_id, 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;
+    self.send_reaction_operation(channel_id, 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;
+    self.send_reaction_operation(removed_reactions.channel_id, removed_reactions.message_id, ReactionOperation::RemoveEmoji(emoji)).await;
   }
 }

src/discord/src/message/mod.rs

@@ -1,12 +1,10 @@
 use std::sync::{Arc, OnceLock};
 
 use crate::message::reaction_list::DiscordReactionList;
-use author::{DiscordMessageAuthor, DisplayName};
+use author::DiscordMessageAuthor;
 use chrono::{DateTime, Utc};
 use content::DiscordMessageContent;
 use gpui::{View, VisualContext, WindowContext};
-use gpui::{div, Element, IntoElement, ParentElement};
-use scope_chat::message::MessageAuthor;
 use scope_chat::reaction::ReactionList;
 use scope_chat::{async_list::AsyncListItem, message::Message};
 use serenity::all::{ModelError, Nonce};
@@ -35,7 +33,7 @@ pub struct DiscordMessage {
   pub channel: Arc<serenity::model::channel::Channel>,
   pub data: DiscordMessageData,
   pub content: OnceLock<View<DiscordMessageContent>>,
-  pub reactions: Option<DiscordReactionList>,
+  pub reactions: DiscordReactionList,
 }
 
 impl DiscordMessage {
@@ -48,16 +46,11 @@ impl DiscordMessage {
     }
     .unwrap();
 
-    let reactions = msg.reactions.iter().map(reaction::DiscordMessageReaction::from_message).collect::<Vec<_>>();
-    if !reactions.is_empty() {
-      println!("Reactions: {:?}", reactions);
-    }
-
     Self {
       client,
       channel,
+      reactions: (&msg.reactions).into(),
       data: DiscordMessageData::Received(msg, member),
-
       content: OnceLock::new(),
     }
   }
@@ -71,8 +64,8 @@ impl DiscordMessage {
     Self {
       client,
       channel,
+      reactions: (&msg.reactions).into(),
       data: DiscordMessageData::Received(msg, member),
-
       content: OnceLock::new(),
     }
   }

src/discord/src/message/reaction_list.rs

@@ -14,6 +14,14 @@ impl DiscordReactionList {
   }
 }
 
+impl From<&Vec<serenity::all::MessageReaction>> for DiscordReactionList {
+  fn from(reactions: &Vec<serenity::all::MessageReaction>) -> Self {
+    DiscordReactionList {
+      reactions: reactions.iter().map(DiscordMessageReaction::from_message).collect(),
+    }
+  }
+}
+
 impl ReactionList for DiscordReactionList {
   fn get_reactions(&self) -> &Vec<impl MessageReaction> {
     &self.reactions

src/discord/src/snowflake.rs

@@ -40,8 +40,3 @@ impl From<MessageId> for Snowflake {
   }
 }
 
-impl <T> From<T> for Snowflake where T: Into<u64> {
-  fn from(content: T) -> Self {
-    Snowflake { content: content.into() }
-  }
-}

src/ui/src/channel/message_list.rs

@@ -116,11 +116,11 @@ where
     });
   }
 
-  pub fn update_reaction(&mut self, cx: &mut ViewContext<Self>, reaction: ReactionEvent) {
+  pub fn update_reaction(&mut self, cx: &mut ViewContext<Self>, reaction: ReactionEvent<T::Identifier>) {
     self.cache.update(cx, |borrow: &mut Vec<Element<Option<T::Content>>>, cx| {
       for item in borrow.iter_mut() {
         if let Element::Resolved(Some(haystack)) = item {
-          if haystack.get_identifier() == reaction.0 {
+          if haystack.get_identifier() == Some(reaction.0) {
             let reactions = haystack.get_reactions();
             reactions.apply(reaction.1);
 

src/ui/src/channel/mod.rs

@@ -14,7 +14,7 @@ pub struct ChannelView<C: Channel + 'static> {
 }
 
 impl<C: Channel + 'static> ChannelView<C> {
-  pub fn create(ctx: &mut gpui::ViewContext<'_, ChannelView<C>>, channel: Arc<C>) -> Self {
+  pub fn create(ctx: &mut gpui::ViewContext<'_, ChannelView<C>>, channel: Arc<C>) -> Self where <C as Channel>::Identifier: Send  {
     let channel_message_listener = channel.get_message_receiver();
     let channel_reaction_listener = channel.get_reaction_receiver();