print available channels if unspecified

4 files changed, 109 insertions, 63 deletions

diff --git a/src/agenda.rs b/src/agenda.rs
index 39b07a7..1ca7bfb 100644
--- a/src/agenda.rs
+++ b/src/agenda.rs
@@ -6,8 +6,9 @@ use std::{
     fmt,
     fs,
 };
+use tokio::sync::mpsc;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct AgendaPoint {
     title: String,
     adder: String,
@@ -42,13 +43,19 @@ pub enum ParseError {
     NoSuchCommand,
 }
 
-pub fn parse_message(message: &str, sender: &str) -> Result<Option<String>, ParseError> {
+pub fn parse_message(
+    message: &str,
+    sender: &str,
+    point_sender: &mpsc::UnboundedSender<AgendaPoint>
+) -> Result<Option<String>, ParseError> {
     if message.starts_with("!add ") {
         let mut agenda = read_agenda();
-        agenda.points.push(AgendaPoint {
+        let agenda_point = AgendaPoint {
             title: message[5..].to_string(),
             adder: sender.to_string(),
-        });
+        };
+        point_sender.send(agenda_point.clone()).unwrap();
+        agenda.points.push(agenda_point);
         agenda.write();
         Ok(None)
     } else if message.starts_with("!agenda") {
diff --git a/src/discord.rs b/src/discord.rs
index ea7ad03..3933aba 100644
--- a/src/discord.rs
+++ b/src/discord.rs
@@ -7,6 +7,7 @@ use discord::{
     model::{
         ChannelId,
         Event,
+        PossibleServer,
     },
     Discord,
     Error,
@@ -34,49 +35,62 @@ 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 channel = match std::env::var("DISCORD_CHANNEL") {
+            Ok(channel) => Some(ChannelId(channel.parse::<u64>().unwrap())),
+            Err(_) => CHANNEL,
+        };
 
         let (_, _) = join!( //TODO?
-            spawn(receive_from_slack(receiver, Arc::clone(&client), channel_id)),
-            spawn_blocking(move || receive_events(our_id, connection, sender, client, channel_id)),
+            spawn(receive_from_slack(receiver, Arc::clone(&client), channel)),
+            spawn_blocking(move || receive_events(our_id, connection, sender, client, channel)),
         );
     }
 }
 
 fn receive_events(
-    our_id: discord::model::UserId,
+    _our_id: discord::model::UserId,
     mut connection: discord::Connection,
     sender: mpsc::UnboundedSender<AgendaPoint>,
     client: Arc<Mutex<discord::Discord>>,
-    channel_id: ChannelId,
+    channel: Option<ChannelId>,
 ) {
     loop {
         match connection.recv_event() {
+            Ok(Event::ServerCreate(server)) => {
+                if let PossibleServer::Online(server) = server {
+                    println!("Discord channels in {}: {:#?}",
+                             server.name,
+                             server
+                             .channels
+                             .iter()
+                             .map(|channel| format!("{}: {} ({:?})",
+                                                    channel.name,
+                                                    channel.id,
+                                                    channel.kind))
+                             .collect::<Vec<_>>());
+                }
+            }
+
             Ok(Event::MessageCreate(message)) => {
-                if let Ok(Some(s)) = parse_message(&message.content, &message.author.name) {
-                    client.lock().unwrap().send_message(channel_id,
-                                                        &s,
-                                                        "",
-                                                        false).unwrap();
+                if let Some(channel) = channel {
+                    if let Ok(Some(s)) = parse_message(
+                        &message.content,
+                        &message.author.name,
+                        &sender,
+                    ) {
+                        client.lock().unwrap().send_message(channel,
+                                                            &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)) => {
@@ -93,14 +107,16 @@ fn receive_events(
 async fn receive_from_slack(
     mut receiver: mpsc::UnboundedReceiver<AgendaPoint>,
     client: Arc<Mutex<discord::Discord>>,
-    channel_id: ChannelId
+    channel: Option<ChannelId>
 ) {
-    while let Some(point) = receiver.recv().await {
-        println!("Discord received '{}'", point);
-        client.lock().unwrap().send_message(channel_id,
-                                            &point.to_add_message(),
-                                            "",
-                                            false).unwrap();
+    if let Some(channel) = channel {
+        while let Some(point) = receiver.recv().await {
+            println!("Discord received '{}'", point);
+            client.lock().unwrap().send_message(channel,
+                                                &point.to_add_message(),
+                                                "",
+                                                false).unwrap();
+        }
     }
 
 }
diff --git a/src/main.rs b/src/main.rs
index b6edd38..0bcf53c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,10 +2,7 @@ mod agenda;
 mod discord;
 mod slack;
 
-use crate::agenda::{
-    Agenda,
-    AgendaPoint,
-};
+use crate::agenda::AgendaPoint;
 use futures::join;
 use tokio::sync::mpsc;
 
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<AgendaPoint>,
     slack_sender: slack::Sender,
-    slack_channel: String,
+    slack_channel: Option<String>,
+    print_channels: bool,
 }
 
 impl Handler {
     fn new(
         sender: mpsc::UnboundedSender<AgendaPoint>,
         slack_sender: slack::Sender,
-        slack_channel: String
+        slack_channel: Option<String>,
     ) -> Self {
         Self {
             sender,
             slack_sender,
-            slack_channel,
+            slack_channel: slack_channel.clone(),
+            print_channels: slack_channel.is_none()
         }
     }
-
-    fn sender(&self) -> &mpsc::UnboundedSender<AgendaPoint> {
-        &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::<Vec<_>>())
+                             }));
+                }
+            }
             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<AgendaPoint>,
     sender: slack::Sender,
+    channel: Option<String>,
 ) {
-    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");
+        }
     }
 }