From 5788bc84c13ed56324bdc6dc7c61bb0ca12a9256 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= <gustav@sornas.net>
Date: Sun, 22 Nov 2020 23:01:28 +0100
Subject: print agenda when reminders are requested

---
 src/agenda.rs  |  2 +-
 src/discord.rs | 32 ++++++++++++++++++++++++++++++--
 src/main.rs    | 12 +++++++-----
 src/slack.rs   | 33 ++++++++++++++++++++++++++++-----
 4 files changed, 66 insertions(+), 13 deletions(-)

diff --git a/src/agenda.rs b/src/agenda.rs
index a132bbb..8ed1840 100644
--- a/src/agenda.rs
+++ b/src/agenda.rs
@@ -91,7 +91,7 @@ where
     }
 }
 
-fn read_agenda() -> Agenda {
+pub fn read_agenda() -> Agenda {
     serde_json::from_str::<Agenda>(
         &fs::read_to_string("agenda.json").expect("Can't read agenda.json"),
     )
diff --git a/src/discord.rs b/src/discord.rs
index fb121fb..438f0ed 100644
--- a/src/discord.rs
+++ b/src/discord.rs
@@ -1,4 +1,5 @@
 use crate::agenda::{self, parse_message, AgendaPoint, Emoji};
+use crate::reminder::ReminderType;
 
 use discord::{
     model::{ChannelId, Event, PossibleServer, ReactionEmoji, UserId},
@@ -10,7 +11,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 use tokio::{
-    sync::mpsc,
+    sync::{mpsc, watch},
     task::{spawn, spawn_blocking},
 };
 
@@ -29,6 +30,7 @@ struct Handler {
 pub async fn handle(
     sender: mpsc::UnboundedSender<AgendaPoint>,
     receiver: mpsc::UnboundedReceiver<AgendaPoint>,
+    reminder: watch::Receiver<ReminderType>,
 ) {
     println!("Setting up Discord");
 
@@ -45,8 +47,9 @@ pub async fn handle(
             .map(|id| Some(ChannelId(id.parse::<u64>().unwrap())))
             .unwrap_or(CHANNEL);
 
-        let (_, _) = join!(
+        let (_, _, _) = join!(
             spawn(receive_from_slack(receiver, Arc::clone(&client), channel)),
+            spawn(handle_reminders(reminder, Arc::clone(&client), channel)),
             spawn_blocking(move || receive_events(&mut Handler {
                 _our_id,
                 connection,
@@ -159,3 +162,28 @@ async fn receive_from_slack(
         }
     }
 }
+
+async fn handle_reminders(
+    mut reminder: watch::Receiver<ReminderType>,
+    client: Arc<Mutex<discord::Discord>>,
+    channel: Option<ChannelId>,
+) {
+    if let Some(channel) = channel {
+        while let Some(reminder) = reminder.recv().await {
+            match reminder {
+                ReminderType::OneHour => {
+                    client
+                        .lock()
+                        .unwrap()
+                        .send_message(channel,
+                                      &format!("Meeting in one hour!\n{}",
+                                              agenda::read_agenda().to_string()),
+                                      "",
+                                      false)
+                        .unwrap();
+                },
+                ReminderType::Void => {}
+            }
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 6bd2de5..8980b31 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,18 +4,20 @@ mod reminder;
 mod slack;
 
 use crate::agenda::AgendaPoint;
+use crate::reminder::ReminderType;
 use futures::join;
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc, watch};
 
 #[tokio::main]
 async fn main() {
-    println!("Hello, world!");
-
     let (from_discord, to_slack) = mpsc::unbounded_channel::<AgendaPoint>();
     let (from_slack, to_discord) = mpsc::unbounded_channel::<AgendaPoint>();
 
+    let (reminder_sender, reminder_receiver) = watch::channel(ReminderType::Void);
+
     join!(
-        discord::handle(from_discord, to_discord),
-        slack::handle(from_slack, to_slack),
+        reminder::handle(reminder_sender),
+        discord::handle(from_discord, to_discord, reminder_receiver.clone()),
+        slack::handle(from_slack, to_slack, reminder_receiver),
     );
 }
diff --git a/src/slack.rs b/src/slack.rs
index 9698109..1481cf1 100644
--- a/src/slack.rs
+++ b/src/slack.rs
@@ -1,4 +1,5 @@
 use crate::agenda::{self, parse_message, AgendaPoint, Emoji};
+use crate::reminder::ReminderType;
 
 use futures::join;
 use slack::{Event, Message};
@@ -9,7 +10,7 @@ use std::{
 };
 use tokio::{
     runtime::Runtime,
-    sync::mpsc,
+    sync::{mpsc, watch},
     task::{spawn, spawn_blocking},
 };
 use tokio_compat_02::FutureExt;
@@ -137,11 +138,11 @@ impl slack::EventHandler for Handler {
                                                         timestamp: Some(msg.ts.unwrap()),
                                                     },
                                                 )
-                                                .compat(),
+                                                    .compat(),
                                             )
                                             .unwrap();
                                     }
-                                    _ => {}
+                                    _ => {} // parse_message return
                                 }
                             }
                         }
@@ -161,6 +162,7 @@ impl slack::EventHandler for Handler {
 pub async fn handle(
     sender: mpsc::UnboundedSender<AgendaPoint>,
     receiver: mpsc::UnboundedReceiver<AgendaPoint>,
+    reminder: watch::Receiver<ReminderType>,
 ) {
     println!("Setting up Slack");
 
@@ -186,14 +188,15 @@ pub async fn handle(
     );
     let slack_sender = client.sender().clone();
 
-    let (_, _) = join!(
+    let (_, _, _) = join!(
+        spawn(receive_from_discord(receiver, slack_sender.clone(), channel.clone())),
+        spawn(handle_reminders(reminder, slack_sender, channel)),
         spawn_blocking(move || {
             match client.run(&mut handler) {
                 Ok(_) => {}
                 Err(e) => println!("Error: {}", e),
             }
         }),
-        spawn(receive_from_discord(receiver, slack_sender, channel))
     );
 }
 
@@ -214,3 +217,23 @@ async fn receive_from_discord(
         }
     }
 }
+
+async fn handle_reminders(
+    mut reminder: watch::Receiver<ReminderType>,
+    sender: slack::Sender,
+    channel: Option<String>,
+) {
+    if let Some(channel) = channel {
+        while let Some(reminder) = reminder.recv().await {
+            match reminder {
+                ReminderType::OneHour => {
+                    sender.send_typing(&channel).unwrap();
+                    sender
+                        .send_message(&channel, &format!("Meeting in one hour!\n{}", agenda::read_agenda()))
+                        .unwrap();
+                },
+                ReminderType::Void => {}
+            }
+        }
+    }
+}
-- 
cgit v1.2.1