basic commands and write agenda to file

1 files changed, 37 insertions, 21 deletions

diff --git a/src/discord.rs b/src/discord.rs
index fe64b24..ea7ad03 100644
--- a/src/discord.rs
+++ b/src/discord.rs
@@ -1,4 +1,7 @@
-use crate::agenda::AgendaPoint;
+use crate::agenda::{
+    parse_message,
+    AgendaPoint
+};
 
 use discord::{
     model::{
@@ -9,6 +12,10 @@ use discord::{
     Error,
 };
 use futures::join;
+use std::sync::{
+    Arc,
+    Mutex,
+};
 use tokio::{
     sync::mpsc,
     task::{
@@ -27,16 +34,23 @@ pub async fn handle(
     println!("Setting up Discord");
 
     let token = std::env::var("DISCORD_API_TOKEN").unwrap_or_else(|_| TOKEN.expect("Missing Discord token").to_string());
+    let channel_id = ChannelId(
+        match std::env::var("DISCORD_CHANNEL") {
+            Ok(var) => var.parse().unwrap(),
+            Err(_) => CHANNEL.expect("Missing Discord channel"),
+        });
+
     let client = Discord::from_bot_token(&token);
 
     if let Ok(client) = client {
         let (connection, _) = client.connect().expect("Discord connect failed"); //TODO
         let our_id = client.get_current_user().unwrap().id;
+        let client = Arc::new(Mutex::new(client));
         println!("Discord ready");
 
         let (_, _) = join!( //TODO?
-            spawn_blocking(move || receive_events(our_id, connection, sender)),
-            spawn(receive_from_slack(receiver, client))
+            spawn(receive_from_slack(receiver, Arc::clone(&client), channel_id)),
+            spawn_blocking(move || receive_events(our_id, connection, sender, client, channel_id)),
         );
     }
 }
@@ -44,17 +58,25 @@ pub async fn handle(
 fn receive_events(
     our_id: discord::model::UserId,
     mut connection: discord::Connection,
-    sender: mpsc::UnboundedSender<AgendaPoint>
+    sender: mpsc::UnboundedSender<AgendaPoint>,
+    client: Arc<Mutex<discord::Discord>>,
+    channel_id: ChannelId,
 ) {
     loop {
         match connection.recv_event() {
             Ok(Event::MessageCreate(message)) => {
-                if message.author.id != our_id {
-                    sender.send(AgendaPoint{
-                        title: message.content,
-                        adder: message.author.name,
-                    }).unwrap();
+                if let Ok(Some(s)) = parse_message(&message.content, &message.author.name) {
+                    client.lock().unwrap().send_message(channel_id,
+                                                        &s,
+                                                        "",
+                                                        false).unwrap();
                 }
+                //if message.author.id != our_id {
+                //    sender.send(AgendaPoint{
+                //        title: message.content,
+                //        adder: message.author.name,
+                //    }).unwrap();
+                //}
             }
             Ok(_) => {}
             Err(Error::Closed(code, body)) => {
@@ -70,21 +92,15 @@ fn receive_events(
 
 async fn receive_from_slack(
     mut receiver: mpsc::UnboundedReceiver<AgendaPoint>,
-    client: discord::Discord,
+    client: Arc<Mutex<discord::Discord>>,
+    channel_id: ChannelId
 ) {
     while let Some(point) = receiver.recv().await {
         println!("Discord received '{}'", point);
-        client.send_message(
-            ChannelId(
-                match std::env::var("DISCORD_CHANNEL") {
-                    Ok(var) => var.parse().unwrap(),
-                    Err(_) => CHANNEL.expect("Missing Discord channel"),
-                }
-            ),
-            &point.to_add_message(),
-            "",
-            false
-        ).unwrap();
+        client.lock().unwrap().send_message(channel_id,
+                                            &point.to_add_message(),
+                                            "",
+                                            false).unwrap();
     }
 
 }