From c01c8716de4a91e4c60f61cf0bb6eaeca5cbf619 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 13:12:32 +0100 Subject: refactor to new files --- src/slack.rs | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 src/slack.rs (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs new file mode 100644 index 0000000..40e465c --- /dev/null +++ b/src/slack.rs @@ -0,0 +1,39 @@ +use slack_api as slack; +use tokio::sync::mpsc; + +pub async fn handle( + token: Option, + sender: mpsc::UnboundedSender, + _receiver: mpsc::UnboundedReceiver, +) { + println!("Setting up Slack"); + + let token = std::env::var("SLACK_API_TOKEN") + .unwrap_or(token.unwrap()); + let client = slack::default_client().unwrap(); + + let request = slack::rtm::StartRequest::default(); + let response = slack::rtm::start(&client, + &token, + &request).await; + + if let Ok(response) = response { + if let Some(channels) = response.channels { + let channel_names = channels + .iter() + .filter_map(|c| c.name.as_ref()) + .collect::>(); + sender.send(format!("Got channels {:?}", channel_names).to_string()).unwrap(); + } + + if let Some(users) = response.users { + let user_names = users + .iter() + .filter_map(|u| u.name.as_ref()) + .collect::>(); + sender.send(format!("Got users {:?}", user_names).to_string()).unwrap(); + } + } else { //TODO NotAuth etc + println!("{:?}", response) + } +} -- cgit v1.2.1 From 2a3eb31fe09152729f80f9329bedfec96c8ebff4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 13:17:41 +0100 Subject: send more strings between async --- src/slack.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index 40e465c..9a30b49 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -4,12 +4,11 @@ use tokio::sync::mpsc; pub async fn handle( token: Option, sender: mpsc::UnboundedSender, - _receiver: mpsc::UnboundedReceiver, + mut receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Slack"); - let token = std::env::var("SLACK_API_TOKEN") - .unwrap_or(token.unwrap()); + let token = std::env::var("SLACK_API_TOKEN").unwrap_or(token.unwrap()); let client = slack::default_client().unwrap(); let request = slack::rtm::StartRequest::default(); @@ -36,4 +35,8 @@ pub async fn handle( } else { //TODO NotAuth etc println!("{:?}", response) } + + while let Some(s) = receiver.recv().await { + println!("Slack received '{}' from discord", s); + } } -- cgit v1.2.1 From 07e3d4f5f772080028f86661ed7f6e95f63207b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 13:31:17 +0100 Subject: switch to actual slack rtm api --- src/slack.rs | 73 ++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 41 insertions(+), 32 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index 9a30b49..fb4eece 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -1,42 +1,51 @@ -use slack_api as slack; -use tokio::sync::mpsc; +use futures::join; +use tokio::{ + sync::mpsc, + task::{ + spawn, + spawn_blocking, + }, +}; + +struct Handler; + +impl slack::EventHandler for Handler { + fn on_event(&mut self, _cli: &slack::RtmClient, event: slack::Event) { + println!("on_event: {:#?}", event); + } + + fn on_close(&mut self, _cli: &slack::RtmClient) { + println!("on_close") + } + + fn on_connect(&mut self, _cli: &slack::RtmClient) { + println!("on_connect"); + } +} pub async fn handle( token: Option, - sender: mpsc::UnboundedSender, + _sender: mpsc::UnboundedSender, mut receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Slack"); let token = std::env::var("SLACK_API_TOKEN").unwrap_or(token.unwrap()); - let client = slack::default_client().unwrap(); - - let request = slack::rtm::StartRequest::default(); - let response = slack::rtm::start(&client, - &token, - &request).await; - - if let Ok(response) = response { - if let Some(channels) = response.channels { - let channel_names = channels - .iter() - .filter_map(|c| c.name.as_ref()) - .collect::>(); - sender.send(format!("Got channels {:?}", channel_names).to_string()).unwrap(); - } - if let Some(users) = response.users { - let user_names = users - .iter() - .filter_map(|u| u.name.as_ref()) - .collect::>(); - sender.send(format!("Got users {:?}", user_names).to_string()).unwrap(); - } - } else { //TODO NotAuth etc - println!("{:?}", response) - } - - while let Some(s) = receiver.recv().await { - println!("Slack received '{}' from discord", s); - } + join!( + spawn_blocking(move || { + let mut handler = Handler; + match slack::RtmClient::login_and_run(&token, &mut handler) { + Ok(_) => {} + Err(e) => { + println!("Error: {}", e) + } + } + }), + spawn(async move { + while let Some(s) = receiver.recv().await { + println!("Slack received '{}' from discord", s); + } + }) + ); } -- cgit v1.2.1 From f25e22abe842f51f2f29df1f885caa0939376ce8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 13:44:26 +0100 Subject: send messages from slack to discord handler --- src/slack.rs | 38 +++++++++++++++++++++++++++++++++++--- 1 file changed, 35 insertions(+), 3 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index fb4eece..564ca76 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -1,4 +1,8 @@ use futures::join; +use slack::{ + Event, + Message, +}; use tokio::{ sync::mpsc, task::{ @@ -7,11 +11,39 @@ use tokio::{ }, }; -struct Handler; +struct Handler { + sender: mpsc::UnboundedSender, +} + +impl Handler { + fn new(sender: mpsc::UnboundedSender) -> Self { + Self { + sender + } + } + + fn sender(&self) -> &mpsc::UnboundedSender { + &self.sender + } +} impl slack::EventHandler for Handler { fn on_event(&mut self, _cli: &slack::RtmClient, event: slack::Event) { println!("on_event: {:#?}", event); + match event { + Event::Message(msg) => { + match *msg { + Message::Standard(msg) => { + self.sender().send(format!("{} says: {}", + msg.user.unwrap_or("??".to_string()), + msg.text.unwrap_or("??".to_string())) + .to_string()).unwrap(); + } + _ => {} + } + } + _ => {} + } } fn on_close(&mut self, _cli: &slack::RtmClient) { @@ -25,7 +57,7 @@ impl slack::EventHandler for Handler { pub async fn handle( token: Option, - _sender: mpsc::UnboundedSender, + sender: mpsc::UnboundedSender, mut receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Slack"); @@ -34,7 +66,7 @@ pub async fn handle( join!( spawn_blocking(move || { - let mut handler = Handler; + let mut handler = Handler::new(sender); match slack::RtmClient::login_and_run(&token, &mut handler) { Ok(_) => {} Err(e) => { -- cgit v1.2.1 From 1fd5df9524f84511b8d22300e5b2aa1fb2063660 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 14:55:05 +0100 Subject: minor cleanup --- src/slack.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index 564ca76..887c1f9 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -76,7 +76,7 @@ pub async fn handle( }), spawn(async move { while let Some(s) = receiver.recv().await { - println!("Slack received '{}' from discord", s); + println!("Slack received '{}'", s); } }) ); -- cgit v1.2.1 From 222acec5e5153d169ae909a8c68b382f01becff2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 14:55:18 +0100 Subject: send messages to slack channel --- src/slack.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index 887c1f9..feff430 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -34,7 +34,8 @@ impl slack::EventHandler for Handler { Event::Message(msg) => { match *msg { Message::Standard(msg) => { - self.sender().send(format!("{} says: {}", + self.sender().send(format!("{}:{} says: {}", + msg.channel.unwrap_or("??".to_string()), msg.user.unwrap_or("??".to_string()), msg.text.unwrap_or("??".to_string())) .to_string()).unwrap(); @@ -63,11 +64,16 @@ pub async fn handle( println!("Setting up Slack"); let token = std::env::var("SLACK_API_TOKEN").unwrap_or(token.unwrap()); + let client = spawn_blocking(move || { + slack::RtmClient::login(&token).unwrap() + }).await.unwrap(); + + let slack_sender = client.sender().clone(); join!( spawn_blocking(move || { let mut handler = Handler::new(sender); - match slack::RtmClient::login_and_run(&token, &mut handler) { + match client.run(&mut handler) { Ok(_) => {} Err(e) => { println!("Error: {}", e) @@ -77,6 +83,12 @@ pub async fn handle( spawn(async move { while let Some(s) = receiver.recv().await { println!("Slack received '{}'", s); + //TODO Sending messages is very slow sometimes. Have seen delays + // from 5 up to 20(!) seconds. + slack_sender.send_typing("CPBAA5FA7").unwrap(); + println!("Typing"); + slack_sender.send_message("CPBAA5FA7", &s).unwrap(); + println!("Sent"); } }) ); -- cgit v1.2.1 From f0f616b94ec1778e7f7b84db0a368ea83438faaa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 16:07:14 +0100 Subject: refactor spawns to functions --- src/slack.rs | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index feff430..c13fc47 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -59,7 +59,7 @@ impl slack::EventHandler for Handler { pub async fn handle( token: Option, sender: mpsc::UnboundedSender, - mut receiver: mpsc::UnboundedReceiver, + receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Slack"); @@ -80,16 +80,21 @@ pub async fn handle( } } }), - spawn(async move { - while let Some(s) = receiver.recv().await { - println!("Slack received '{}'", s); - //TODO Sending messages is very slow sometimes. Have seen delays - // from 5 up to 20(!) seconds. - slack_sender.send_typing("CPBAA5FA7").unwrap(); - println!("Typing"); - slack_sender.send_message("CPBAA5FA7", &s).unwrap(); - println!("Sent"); - } - }) + spawn(receive_from_discord(receiver, slack_sender)) ); } + +async fn receive_from_discord( + mut receiver: mpsc::UnboundedReceiver, + sender: slack::Sender, +) { + while let Some(s) = receiver.recv().await { + println!("Slack received '{}'", s); + //TODO Sending messages is very slow sometimes. Have seen delays + // from 5 up to 20(!) seconds. + sender.send_typing("CPBAA5FA7").unwrap(); + println!("Typing"); + sender.send_message("CPBAA5FA7", &s).unwrap(); + println!("Sent"); + } +} -- cgit v1.2.1 From 6fbdede8516e6d35afbd032a2ca6fc6ef109b484 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 17:31:23 +0100 Subject: send AgendaPoint instead of String between services --- src/slack.rs | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index c13fc47..91705fa 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -1,3 +1,5 @@ +use crate::agenda::AgendaPoint; + use futures::join; use slack::{ Event, @@ -12,17 +14,17 @@ use tokio::{ }; struct Handler { - sender: mpsc::UnboundedSender, + sender: mpsc::UnboundedSender, } impl Handler { - fn new(sender: mpsc::UnboundedSender) -> Self { + fn new(sender: mpsc::UnboundedSender) -> Self { Self { sender } } - fn sender(&self) -> &mpsc::UnboundedSender { + fn sender(&self) -> &mpsc::UnboundedSender { &self.sender } } @@ -34,11 +36,10 @@ impl slack::EventHandler for Handler { Event::Message(msg) => { match *msg { Message::Standard(msg) => { - self.sender().send(format!("{}:{} says: {}", - msg.channel.unwrap_or("??".to_string()), - msg.user.unwrap_or("??".to_string()), - msg.text.unwrap_or("??".to_string())) - .to_string()).unwrap(); + self.sender().send(AgendaPoint{ + title: msg.text.unwrap_or("??".to_string()), + adder: msg.user.unwrap_or("??".to_string()), + }); } _ => {} } @@ -58,8 +59,8 @@ impl slack::EventHandler for Handler { pub async fn handle( token: Option, - sender: mpsc::UnboundedSender, - receiver: mpsc::UnboundedReceiver, + sender: mpsc::UnboundedSender, + receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Slack"); @@ -85,16 +86,16 @@ pub async fn handle( } async fn receive_from_discord( - mut receiver: mpsc::UnboundedReceiver, + mut receiver: mpsc::UnboundedReceiver, sender: slack::Sender, ) { - while let Some(s) = receiver.recv().await { - println!("Slack received '{}'", s); + while let Some(point) = receiver.recv().await { + println!("Slack received '{}'", point); //TODO Sending messages is very slow sometimes. Have seen delays // from 5 up to 20(!) seconds. sender.send_typing("CPBAA5FA7").unwrap(); println!("Typing"); - sender.send_message("CPBAA5FA7", &s).unwrap(); + sender.send_message("CPBAA5FA7", &point.to_add_message()).unwrap(); println!("Sent"); } } -- cgit v1.2.1 From 233b1b39a9ea5b622148c00558fa98082d1ae184 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 18:09:23 +0100 Subject: "fix" warnings --- src/slack.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index 91705fa..e13ac3d 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -39,7 +39,7 @@ impl slack::EventHandler for Handler { self.sender().send(AgendaPoint{ title: msg.text.unwrap_or("??".to_string()), adder: msg.user.unwrap_or("??".to_string()), - }); + }).unwrap(); } _ => {} } @@ -71,7 +71,7 @@ pub async fn handle( let slack_sender = client.sender().clone(); - join!( + let (_, _) = join!( spawn_blocking(move || { let mut handler = Handler::new(sender); match client.run(&mut handler) { -- cgit v1.2.1 From 8ff5e1295ce9e6c670dd097ab801e4ff35e94632 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 18:23:16 +0100 Subject: move service values to correct file and read more from env --- src/slack.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index e13ac3d..b460925 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -13,6 +13,9 @@ use tokio::{ }, }; +const TOKEN: Option<&str> = None; +const CHANNEL: Option<&str> = None; + struct Handler { sender: mpsc::UnboundedSender, } @@ -58,13 +61,12 @@ impl slack::EventHandler for Handler { } pub async fn handle( - token: Option, sender: mpsc::UnboundedSender, receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Slack"); - let token = std::env::var("SLACK_API_TOKEN").unwrap_or(token.unwrap()); + let token = std::env::var("SLACK_API_TOKEN").unwrap_or_else(|_| TOKEN.expect("Missing slack token").to_string()); let client = spawn_blocking(move || { slack::RtmClient::login(&token).unwrap() }).await.unwrap(); @@ -90,12 +92,11 @@ async fn receive_from_discord( sender: slack::Sender, ) { while let Some(point) = receiver.recv().await { - println!("Slack received '{}'", point); //TODO Sending messages is very slow sometimes. Have seen delays // from 5 up to 20(!) seconds. - sender.send_typing("CPBAA5FA7").unwrap(); - println!("Typing"); - sender.send_message("CPBAA5FA7", &point.to_add_message()).unwrap(); - println!("Sent"); + let channel = std::env::var("SLACK_CHANNEL").unwrap_or_else(|_| CHANNEL.expect("Missing slack channel").to_string()); + sender.send_typing(&channel).unwrap(); + sender.send_message(&channel, &point.to_add_message()).unwrap(); + println!("Slack message sent"); } } -- cgit v1.2.1 From 3b75792081e11cfeb334b45dfb41027532a8848e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Fri, 13 Nov 2020 00:59:32 +0100 Subject: basic commands and write agenda to file --- src/slack.rs | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index b460925..c0d9bb8 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -1,4 +1,7 @@ -use crate::agenda::AgendaPoint; +use crate::agenda::{ + parse_message, + AgendaPoint +}; use futures::join; use slack::{ @@ -18,12 +21,20 @@ const CHANNEL: Option<&str> = None; struct Handler { sender: mpsc::UnboundedSender, + slack_sender: slack::Sender, + slack_channel: String, } impl Handler { - fn new(sender: mpsc::UnboundedSender) -> Self { + fn new( + sender: mpsc::UnboundedSender, + slack_sender: slack::Sender, + slack_channel: String + ) -> Self { Self { - sender + sender, + slack_sender, + slack_channel, } } @@ -39,10 +50,12 @@ impl slack::EventHandler for Handler { Event::Message(msg) => { match *msg { Message::Standard(msg) => { - self.sender().send(AgendaPoint{ - title: msg.text.unwrap_or("??".to_string()), - adder: msg.user.unwrap_or("??".to_string()), - }).unwrap(); + if let Ok(Some(s)) = parse_message( + &msg.text.unwrap_or("".to_string()), + &msg.user.unwrap_or("??".to_string()), + ) { + self.slack_sender.send_message(self.slack_channel.as_str(), &s).unwrap(); + } } _ => {} } @@ -67,15 +80,16 @@ pub async fn handle( println!("Setting up Slack"); let token = std::env::var("SLACK_API_TOKEN").unwrap_or_else(|_| TOKEN.expect("Missing slack token").to_string()); + let token_clone = token.clone(); let client = spawn_blocking(move || { slack::RtmClient::login(&token).unwrap() }).await.unwrap(); + let mut handler = Handler::new(sender, client.sender().clone(), token_clone); let slack_sender = client.sender().clone(); let (_, _) = join!( spawn_blocking(move || { - let mut handler = Handler::new(sender); match client.run(&mut handler) { Ok(_) => {} Err(e) => { -- cgit v1.2.1 From 00491c8005fe75a8cdf9dc06288affd2ec50fb61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Fri, 13 Nov 2020 16:05:54 +0100 Subject: print available channels if unspecified --- src/slack.rs | 78 ++++++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 52 insertions(+), 26 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index c0d9bb8..6ed60c4 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -22,42 +22,60 @@ const CHANNEL: Option<&str> = None; struct Handler { sender: mpsc::UnboundedSender, slack_sender: slack::Sender, - slack_channel: String, + slack_channel: Option, + print_channels: bool, } impl Handler { fn new( sender: mpsc::UnboundedSender, slack_sender: slack::Sender, - slack_channel: String + slack_channel: Option, ) -> Self { Self { sender, slack_sender, - slack_channel, + slack_channel: slack_channel.clone(), + print_channels: slack_channel.is_none() } } - - fn sender(&self) -> &mpsc::UnboundedSender { - &self.sender - } } impl slack::EventHandler for Handler { - fn on_event(&mut self, _cli: &slack::RtmClient, event: slack::Event) { + fn on_event(&mut self, cli: &slack::RtmClient, event: slack::Event) { println!("on_event: {:#?}", event); match event { + Event::Hello => { + if self.print_channels { + println!("Slack channels found: {:#?}", + cli + .start_response() + .channels + .as_ref() + .and_then(|channels| { + Some(channels + .iter() + .map(|channel| format!("{}: {}", + channel.name.as_ref().unwrap_or(&"??".to_string()), //TODO &"".to_string() ? + channel.id.as_ref().unwrap_or(&"??".to_string()))) + .collect::>()) + })); + } + } Event::Message(msg) => { - match *msg { - Message::Standard(msg) => { - if let Ok(Some(s)) = parse_message( - &msg.text.unwrap_or("".to_string()), - &msg.user.unwrap_or("??".to_string()), - ) { - self.slack_sender.send_message(self.slack_channel.as_str(), &s).unwrap(); + if let Some(channel) = &self.slack_channel { + match *msg { + Message::Standard(msg) => { + if let Ok(Some(s)) = parse_message( + &msg.text.unwrap_or("".to_string()), + &msg.user.unwrap_or("??".to_string()), + &self.sender, + ) { + self.slack_sender.send_message(channel.as_str(), &s).unwrap(); + } } + _ => {} } - _ => {} } } _ => {} @@ -80,12 +98,18 @@ pub async fn handle( println!("Setting up Slack"); let token = std::env::var("SLACK_API_TOKEN").unwrap_or_else(|_| TOKEN.expect("Missing slack token").to_string()); - let token_clone = token.clone(); + let channel = match std::env::var("SLACK_CHANNEL") { + Ok(channel) => Some(channel), + Err(_) => match CHANNEL { + Some(channel) => Some(channel.to_string()), + None => None + } + }; let client = spawn_blocking(move || { slack::RtmClient::login(&token).unwrap() }).await.unwrap(); - let mut handler = Handler::new(sender, client.sender().clone(), token_clone); + let mut handler = Handler::new(sender, client.sender().clone(), channel.clone()); let slack_sender = client.sender().clone(); let (_, _) = join!( @@ -97,20 +121,22 @@ pub async fn handle( } } }), - spawn(receive_from_discord(receiver, slack_sender)) + spawn(receive_from_discord(receiver, slack_sender, channel)) ); } async fn receive_from_discord( mut receiver: mpsc::UnboundedReceiver, sender: slack::Sender, + channel: Option, ) { - while let Some(point) = receiver.recv().await { - //TODO Sending messages is very slow sometimes. Have seen delays - // from 5 up to 20(!) seconds. - let channel = std::env::var("SLACK_CHANNEL").unwrap_or_else(|_| CHANNEL.expect("Missing slack channel").to_string()); - sender.send_typing(&channel).unwrap(); - sender.send_message(&channel, &point.to_add_message()).unwrap(); - println!("Slack message sent"); + if let Some(channel) = channel { + while let Some(point) = receiver.recv().await { + //TODO Sending messages is very slow sometimes. Have seen delays + // from 5 up to 20(!) seconds. + sender.send_typing(&channel).unwrap(); + sender.send_message(&channel, &point.to_add_message()).unwrap(); + println!("Slack message sent"); + } } } -- cgit v1.2.1 From 1d4fcb47451a9154c215c4b3bba4e559d691f7fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Fri, 13 Nov 2020 16:33:23 +0100 Subject: only listen to channels we write to --- src/slack.rs | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) (limited to 'src/slack.rs') diff --git a/src/slack.rs b/src/slack.rs index 6ed60c4..1c272cf 100644 --- a/src/slack.rs +++ b/src/slack.rs @@ -43,7 +43,6 @@ impl Handler { impl slack::EventHandler for Handler { fn on_event(&mut self, cli: &slack::RtmClient, event: slack::Event) { - println!("on_event: {:#?}", event); match event { Event::Hello => { if self.print_channels { @@ -57,7 +56,7 @@ impl slack::EventHandler for Handler { .iter() .map(|channel| format!("{}: {}", channel.name.as_ref().unwrap_or(&"??".to_string()), //TODO &"".to_string() ? - channel.id.as_ref().unwrap_or(&"??".to_string()))) + channel.id.as_ref().unwrap_or(&"??".to_string()))) //TODO .collect::>()) })); } @@ -66,29 +65,27 @@ impl slack::EventHandler for Handler { if let Some(channel) = &self.slack_channel { match *msg { Message::Standard(msg) => { - if let Ok(Some(s)) = parse_message( - &msg.text.unwrap_or("".to_string()), - &msg.user.unwrap_or("??".to_string()), - &self.sender, - ) { - self.slack_sender.send_message(channel.as_str(), &s).unwrap(); + if msg.channel.is_some() && *channel == msg.channel.unwrap() { //TODO + if let Ok(Some(s)) = parse_message( + &msg.text.unwrap_or("".to_string()), + &msg.user.unwrap_or("??".to_string()), + &self.sender, + ) { + self.slack_sender.send_message(channel.as_str(), &s).unwrap(); + } } } - _ => {} + _ => {} // message type } } } - _ => {} + _ => {} // event type } } - fn on_close(&mut self, _cli: &slack::RtmClient) { - println!("on_close") - } + fn on_close(&mut self, _cli: &slack::RtmClient) {} - fn on_connect(&mut self, _cli: &slack::RtmClient) { - println!("on_connect"); - } + fn on_connect(&mut self, _cli: &slack::RtmClient) {} } pub async fn handle( -- cgit v1.2.1