added basic message sending

Author: roobscoob

Cargo.lock

@@ -4,5 +4,5 @@ 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) -> impl std::future::Future<Output = ()>;
 }

src/chat/src/channel.rs

@@ -4,6 +4,7 @@ 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 {

src/chat/src/message.rs

@@ -4,7 +4,7 @@ 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

@@ -8,15 +8,16 @@ use crate::{client::DiscordClient, message::DiscordMessage, snowflake::Snowflake
 pub struct DiscordChannel {
   channel_id: Snowflake,
   receiver: broadcast::Receiver<DiscordMessage>,
+  client: Arc<RwLock<DiscordClient>>
 }
 
 impl DiscordChannel {
-  pub async fn new(client: &mut Arc<RwLock<DiscordClient>>, channel_id: Snowflake) -> Self {
+  pub async fn new(client: Arc<RwLock<DiscordClient>>, channel_id: Snowflake) -> Self {
     let (sender, receiver) = broadcast::channel(10);
 
     client.write().await.add_channel_message_sender(channel_id, sender).await;
 
-    DiscordChannel { channel_id, receiver }
+    DiscordChannel { channel_id, receiver, client }
   }
 }
 
@@ -26,4 +27,20 @@ impl Channel for DiscordChannel {
   fn get_receiver(&self) -> broadcast::Receiver<Self::Message> {
     self.receiver.resubscribe()
   }
+
+  async fn send_message(&self, content: String, nonce: String) {
+    println!("Sending: {:?}", content);
+
+    self.client.write().await.send_message(self.channel_id, content, nonce).await;
+  }
+}
+
+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

@@ -19,19 +19,26 @@ use crate::{
 #[derive(Default)]
 pub struct DiscordClient {
   channel_message_event_handlers: HashMap<Snowflake, Vec<broadcast::Sender<DiscordMessage>>>,
+  client: Option<serenity::Client>
 }
 
 impl DiscordClient {
   pub fn new(token: String) -> Arc<RwLock<DiscordClient>> {
     let client = Arc::new(RwLock::new(DiscordClient::default()));
     let remote = RemoteDiscordClient(client.clone());
+    let async_client = client.clone();
 
-    tokio::spawn(async {
-      let mut client = serenity::Client::builder(token, GatewayIntents::all()).event_handler(remote).await.expect("Error creating client");
+    tokio::spawn(async move {
+      let mut client = serenity::Client::builder(token, GatewayIntents::all())
+        .event_handler(remote)
+        .await
+        .expect("Error creating client");
 
       if let Err(why) = client.start().await {
         panic!("Client error: {why:?}");
       }
+
+      async_client.write().await.client = Some(client);
     });
 
     client
@@ -40,6 +47,11 @@ impl DiscordClient {
   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);
   }
+
+  pub async fn send_message(&mut self, channel_id: Snowflake, content: String, nonce: String) {
+    println!("All the way to discord~! {:?} {:?}", channel_id, content);
+    ChannelId::new(channel_id.content).send_message(self.client.as_ref().unwrap().http.clone(), CreateMessage::new().content(content).enforce_nonce(true).nonce(serenity::all::Nonce::String(nonce))).await.unwrap();
+  }
 }
 
 struct RemoteDiscordClient(Arc<RwLock<DiscordClient>>);
@@ -68,8 +80,12 @@ impl EventHandler for RemoteDiscordClient {
             icon: msg.author.avatar_url().unwrap_or(msg.author.default_avatar_url()),
           },
           content: DiscordMessageContent {
-            content: msg.content.clone(),
+            content: msg.content.clone()
           },
+          nonce: msg.nonce.clone().map(|n| match n {
+            Nonce::Number(n) => n.to_string(),
+            Nonce::String(s) => s,
+          })
         });
       }
     }

src/discord/src/client.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.clone()
+  }
 }

src/discord/src/message/mod.rs

@@ -1,4 +1,4 @@
-#[derive(Clone, Hash, PartialEq, Eq, Copy)]
+#[derive(Clone, Hash, PartialEq, Eq, Copy, Debug)]
 pub struct Snowflake {
   pub content: u64,
 }

src/discord/src/snowflake.rs

@@ -24,6 +24,9 @@ scope-backend-discord = { version = "0.1.0", path = "../discord" }
 dotenv = "0.15.0"
 env_logger = "0.11.5"
 tokio = { version = "1.41.1", features = ["full"] }
+components = { package = "ui", git = "https://github.com/longbridgeapp/gpui-component", version = "0.1.0" }
+log = "0.4.22"
+random-string = "1.1.0"
 
 [features]
 default = ["gpui/x11"]