send AgendaPoint instead of String between services

5 files changed, 85 insertions, 28 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 68b3d74..3ae0c4e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,5 +9,7 @@ edition = "2018"
 [dependencies]
 discord = { git = "https://github.com/SpaceManiac/discord-rs" } #TODO no voice
 futures = "0.3"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 slack = "0.25"
 tokio = { version = "0.2", features = ["full"] } #TODO actual features
diff --git a/src/agenda.rs b/src/agenda.rs
new file mode 100644
index 0000000..3cfcfb7
--- /dev/null
+++ b/src/agenda.rs
@@ -0,0 +1,50 @@
+use serde::{
+    Deserialize,
+    Serialize,
+};
+use std::{
+    fmt,
+    fs,
+};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct AgendaPoint {
+    pub title: String,
+    pub adder: String,
+}
+
+impl fmt::Display for AgendaPoint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} ({})", self.title, self.adder)
+    }
+}
+
+impl AgendaPoint {
+    pub fn to_add_message(&self) -> String {
+        format!("'{}' added by {}", self.title, self.adder)
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Agenda {
+    points: Vec<AgendaPoint>,
+}
+
+pub fn read_agenda() -> Agenda {
+    serde_json::from_str::<Agenda>(
+        &fs::read_to_string("agenda.json")
+            .expect("Can't read agenda.json"))
+        .expect("Error parsing agenda.json")
+}
+
+pub fn write_agenda(agenda: Agenda) {
+    fs::write(std::path::Path::new("agenda.json"),
+              serde_json::to_string_pretty(&agenda).expect("Can't serialize agenda"))
+        .expect("Can't write agenda.json");
+}
+
+pub fn add_point(point: AgendaPoint) {
+    let mut agenda = read_agenda();
+    agenda.points.push(point);
+    write_agenda(agenda);
+}
diff --git a/src/discord.rs b/src/discord.rs
index c451ad7..e422171 100644
--- a/src/discord.rs
+++ b/src/discord.rs
@@ -1,3 +1,5 @@
+use crate::agenda::AgendaPoint;
+
 use discord::{
     model::{
         ChannelId,
@@ -17,8 +19,8 @@ use tokio::{
 
 pub async fn handle(
     token: Option<String>,
-    sender: mpsc::UnboundedSender<String>,
-    receiver: mpsc::UnboundedReceiver<String>,
+    sender: mpsc::UnboundedSender<AgendaPoint>,
+    receiver: mpsc::UnboundedReceiver<AgendaPoint>,
 ) {
     println!("Setting up Discord");
 
@@ -40,17 +42,16 @@ pub async fn handle(
 fn receive_events(
     our_id: discord::model::UserId,
     mut connection: discord::Connection,
-    sender: mpsc::UnboundedSender<String>
+    sender: mpsc::UnboundedSender<AgendaPoint>
 ) {
     loop {
         match connection.recv_event() {
             Ok(Event::MessageCreate(message)) => {
                 if message.author.id != our_id {
-                    sender.send(format!("{:?}:{} says: {}",
-                                        message.channel_id,
-                                        message.author.name,
-                                        message.content))
-                        .unwrap();
+                    sender.send(AgendaPoint{
+                        title: message.content,
+                        adder: message.author.name,
+                    }).unwrap();
                 }
             }
             Ok(_) => {}
@@ -66,13 +67,13 @@ fn receive_events(
 }
 
 async fn receive_from_slack(
-    mut receiver: mpsc::UnboundedReceiver<String>,
+    mut receiver: mpsc::UnboundedReceiver<AgendaPoint>,
     client: discord::Discord,
 ) {
-    while let Some(s) = receiver.recv().await {
-        println!("Discord received '{}'", s);
+    while let Some(point) = receiver.recv().await {
+        println!("Discord received '{}'", point);
         client.send_message(ChannelId(697057150106599488), //TODO
-                            &s,
+                            &point.to_add_message(),
                             "",
                             false
         );
diff --git a/src/main.rs b/src/main.rs
index 9cdd2e0..8d8fa5c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,9 @@
+mod agenda;
 mod discord;
 mod slack;
 
+use crate::agenda::AgendaPoint;
+
 use futures::join;
 use tokio::sync::mpsc;
 
@@ -11,8 +14,8 @@ async fn main() {
 
     println!("Hello, world!");
 
-    let (from_discord, to_slack) = mpsc::unbounded_channel::<String>();
-    let (from_slack, to_discord) = mpsc::unbounded_channel::<String>();
+    let (from_discord, to_slack) = mpsc::unbounded_channel::<AgendaPoint>();
+    let (from_slack, to_discord) = mpsc::unbounded_channel::<AgendaPoint>();
 
     join!(
         discord::handle(discord_token, from_discord, to_discord),
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<String>,
+    sender: mpsc::UnboundedSender<AgendaPoint>,
 }
 
 impl Handler {
-    fn new(sender: mpsc::UnboundedSender<String>) -> Self {
+    fn new(sender: mpsc::UnboundedSender<AgendaPoint>) -> Self {
         Self {
             sender
         }
     }
 
-    fn sender(&self) -> &mpsc::UnboundedSender<String> {
+    fn sender(&self) -> &mpsc::UnboundedSender<AgendaPoint> {
         &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<String>,
-    sender: mpsc::UnboundedSender<String>,
-    receiver: mpsc::UnboundedReceiver<String>,
+    sender: mpsc::UnboundedSender<AgendaPoint>,
+    receiver: mpsc::UnboundedReceiver<AgendaPoint>,
 ) {
     println!("Setting up Slack");
 
@@ -85,16 +86,16 @@ pub async fn handle(
 }
 
 async fn receive_from_discord(
-    mut receiver: mpsc::UnboundedReceiver<String>,
+    mut receiver: mpsc::UnboundedReceiver<AgendaPoint>,
     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");
     }
 }