Merge pull request #9 from roobscoob/message-sending

Message Sending

Author: alii

Cargo.lock

@@ -4,5 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-gpui = { git = "https://github.com/zed-industries/zed.git", version = "0.1.0" }
+gpui = { git = "https://github.com/huacnlee/zed.git", branch = "export-platform-window", default-features = false, features = [
+  "http_client",
+  "font-kit",
+] }
 tokio = "1.41.1"

src/chat/Cargo.toml

@@ -2,8 +2,10 @@ use tokio::sync::broadcast;
 
 use crate::message::Message;
 
-pub trait Channel {
+pub trait Channel: Clone {
   type Message: Message;
 
   fn get_receiver(&self) -> broadcast::Receiver<Self::Message>;
-}
+
+  fn send_message(&self, content: String, nonce: String) -> Self::Message;
+}

src/chat/src/channel.rs

@@ -1,2 +1,2 @@
-pub mod message;
 pub mod channel;
+pub mod message;

src/chat/src/lib.rs

@@ -1,12 +1,13 @@
-use gpui::{Element};
+use gpui::Element;
 
 pub trait Message: Clone {
   fn get_author(&self) -> &impl MessageAuthor;
   fn get_content(&self) -> impl Element;
   fn get_identifier(&self) -> String;
+  fn get_nonce(&self) -> Option<&String>;
 }
 
 pub trait MessageAuthor {
   fn get_display_name(&self) -> impl Element;
   fn get_icon(&self) -> String;
-}
+}

src/chat/src/message.rs

@@ -4,7 +4,10 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-gpui = { git = "https://github.com/zed-industries/zed.git", version = "0.1.0" }
+gpui = { git = "https://github.com/huacnlee/zed.git", branch = "export-platform-window", default-features = false, features = [
+  "http_client",
+  "font-kit",
+] }
 scope-chat = { version = "0.1.0", path = "../chat" }
 serenity = { git = "https://github.com/scopeclient/serenity", version = "0.13.0" }
 tokio = "1.41.1"

src/discord/Cargo.toml

@@ -3,20 +3,33 @@ use std::sync::Arc;
 use scope_chat::channel::Channel;
 use tokio::sync::{broadcast, RwLock};
 
-use crate::{client::DiscordClient, message::DiscordMessage, snowflake::Snowflake};
+use crate::{
+  client::DiscordClient,
+  message::{
+    author::{DiscordMessageAuthor, DisplayName},
+    content::DiscordMessageContent,
+    DiscordMessage,
+  },
+  snowflake::Snowflake,
+};
 
 pub struct DiscordChannel {
   channel_id: Snowflake,
   receiver: broadcast::Receiver<DiscordMessage>,
+  client: Arc<DiscordClient>,
 }
 
 impl DiscordChannel {
-  pub async fn new(client: &mut Arc<RwLock<DiscordClient>>, channel_id: Snowflake) -> Self {
+  pub async fn new(client: Arc<DiscordClient>, channel_id: Snowflake) -> Self {
     let (sender, receiver) = broadcast::channel(10);
 
-    client.write().await.add_channel_message_sender(channel_id, sender).await;
+    client.add_channel_message_sender(channel_id, sender).await;
 
-    DiscordChannel { channel_id, receiver }
+    DiscordChannel {
+      channel_id,
+      receiver,
+      client,
+    }
   }
 }
 
@@ -26,4 +39,32 @@ impl Channel for DiscordChannel {
   fn get_receiver(&self) -> broadcast::Receiver<Self::Message> {
     self.receiver.resubscribe()
   }
+
+  fn send_message(&self, content: String, nonce: String) -> DiscordMessage {
+    let client = self.client.clone();
+    let channel_id = self.channel_id;
+    let sent_content = content.clone();
+    let sent_nonce = nonce.clone();
+
+    tokio::spawn(async move {
+      client.send_message(channel_id, sent_content, sent_nonce).await;
+    });
+
+    DiscordMessage {
+      content: DiscordMessageContent { content, is_pending: true },
+      author: self.client.user().clone(),
+      id: Snowflake { content: 0 },
+      nonce: Some(nonce),
+    }
+  }
+}
+
+impl Clone for DiscordChannel {
+  fn clone(&self) -> Self {
+    Self {
+      channel_id: self.channel_id.clone(),
+      receiver: self.receiver.resubscribe(),
+      client: self.client.clone(),
+    }
+  }
 }

src/discord/src/channel/mod.rs

@@ -1,10 +1,16 @@
-use std::{collections::HashMap, rc::Rc, sync::Arc};
+use std::{
+  collections::HashMap,
+  fs::File,
+  rc::Rc,
+  sync::{Arc, OnceLock},
+};
 
 use serenity::{
-  all::{Context, EventHandler, GatewayIntents, Message},
+  all::{ChannelId, Context, CreateMessage, Event, EventHandler, GatewayIntents, Message, Nonce, RawEventHandler},
   async_trait,
   futures::SinkExt,
 };
+use std::io::Write;
 use tokio::sync::{broadcast, Mutex, RwLock};
 
 use crate::{
@@ -18,49 +24,84 @@ use crate::{
 
 #[derive(Default)]
 pub struct DiscordClient {
-  channel_message_event_handlers: HashMap<Snowflake, Vec<broadcast::Sender<DiscordMessage>>>,
+  channel_message_event_handlers: RwLock<HashMap<Snowflake, Vec<broadcast::Sender<DiscordMessage>>>>,
+  client: OnceLock<serenity::Client>,
+  user: OnceLock<DiscordMessageAuthor>,
 }
 
 impl DiscordClient {
-  pub fn new(token: String) -> Arc<RwLock<DiscordClient>> {
-    let client = Arc::new(RwLock::new(DiscordClient::default()));
-    let remote = RemoteDiscordClient(client.clone());
+  pub async fn new(token: String) -> Arc<DiscordClient> {
+    let client = Arc::new(DiscordClient::default());
 
-    tokio::spawn(async {
-      let mut client = serenity::Client::builder(token, GatewayIntents::all()).event_handler(remote).await.expect("Error creating client");
+    let mut discord = serenity::Client::builder(token, GatewayIntents::all())
+      .event_handler_arc(client.clone())
+      .raw_event_handler(RawClient(client.clone()))
+      .await
+      .expect("Error creating client");
 
-      if let Err(why) = client.start().await {
-        panic!("Client error: {why:?}");
-      }
-    });
+    if let Err(why) = discord.start().await {
+      panic!("Client error: {why:?}");
+    }
+
+    let _ = client.client.set(discord);
 
     client
   }
 
-  pub async fn add_channel_message_sender(&mut self, channel: Snowflake, sender: broadcast::Sender<DiscordMessage>) {
-    self.channel_message_event_handlers.entry(channel).or_default().push(sender);
+  fn discord(&self) -> &serenity::Client {
+    self.client.get().unwrap()
+  }
+
+  pub fn user(&self) -> &DiscordMessageAuthor {
+    self.user.get().unwrap()
+  }
+
+  pub async fn add_channel_message_sender(&self, channel: Snowflake, sender: broadcast::Sender<DiscordMessage>) {
+    self.channel_message_event_handlers.write().await.entry(channel).or_default().push(sender);
+  }
+
+  pub async fn send_message(&self, channel_id: Snowflake, content: String, nonce: String) {
+    ChannelId::new(channel_id.content)
+      .send_message(
+        self.discord().http.clone(),
+        CreateMessage::new().content(content).enforce_nonce(true).nonce(serenity::all::Nonce::String(nonce)),
+      )
+      .await
+      .unwrap();
   }
 }
 
-struct RemoteDiscordClient(Arc<RwLock<DiscordClient>>);
+struct RawClient(Arc<DiscordClient>);
 
 #[async_trait]
-impl EventHandler for RemoteDiscordClient {
-  async fn ready(&self, ctx: Context, data_about_bot: serenity::model::prelude::Ready) {
-    println!("Ready! {:?}", data_about_bot);
+impl RawEventHandler for RawClient {
+  async fn raw_event(&self, ctx: Context, ev: serenity::model::prelude::Event) {
+    if let Event::Unknown(unk) = ev {
+      if unk.kind == "READY" {
+        let user = unk.value.as_object().unwrap().get("user").unwrap().as_object().unwrap();
+
+        self.0.user.get_or_init(|| DiscordMessageAuthor {
+          display_name: DisplayName(user.get("username").unwrap().as_str().unwrap().to_owned()),
+          icon: format!(
+            "https://cdn.discordapp.com/avatars/{}/{}",
+            user.get("id").unwrap().as_str().unwrap(),
+            user.get("avatar").unwrap().as_str().unwrap()
+          ),
+        });
+      }
+    }
   }
+}
 
+#[async_trait]
+impl EventHandler for DiscordClient {
   async fn message(&self, _: Context, msg: Message) {
-    println!("Got message: {:?} {:?}", msg.channel_id, msg.content);
-
     let snowflake = Snowflake {
       content: msg.channel_id.get(),
     };
 
-    if let Some(vec) = self.0.read().await.channel_message_event_handlers.get(&snowflake) {
+    if let Some(vec) = self.channel_message_event_handlers.read().await.get(&snowflake) {
       for sender in vec {
-        println!("Sending to sender!");
-
         let _ = sender.send(DiscordMessage {
           id: snowflake,
           author: DiscordMessageAuthor {
@@ -69,7 +110,12 @@ impl EventHandler for RemoteDiscordClient {
           },
           content: DiscordMessageContent {
             content: msg.content.clone(),
+            is_pending: false,
           },
+          nonce: msg.nonce.clone().map(|n| match n {
+            Nonce::Number(n) => n.to_string(),
+            Nonce::String(s) => s,
+          }),
         });
       }
     }

src/discord/src/client.rs

@@ -1,12 +1,13 @@
-use gpui::{IntoElement, Render, RenderOnce, WindowContext};
+use gpui::{div, IntoElement, ParentElement, Render, RenderOnce, Styled, WindowContext};
 
 #[derive(Clone, IntoElement)]
 pub struct DiscordMessageContent {
   pub content: String,
+  pub is_pending: bool,
 }
 
 impl RenderOnce for DiscordMessageContent {
   fn render(self, _: &mut WindowContext) -> impl IntoElement {
-    self.content.clone()
+    div().opacity(if self.is_pending { 0.25 } else { 1.0 }).child(self.content.clone())
   }
 }

src/discord/src/message/content.rs

@@ -13,6 +13,7 @@ pub struct DiscordMessage {
   pub content: DiscordMessageContent,
   pub author: DiscordMessageAuthor,
   pub id: Snowflake,
+  pub nonce: Option<String>,
 }
 
 impl Message for DiscordMessage {
@@ -27,4 +28,8 @@ impl Message for DiscordMessage {
   fn get_identifier(&self) -> String {
     self.id.to_string()
   }
+
+  fn get_nonce(&self) -> Option<&String> {
+    self.nonce.as_ref()
+  }
 }