1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
use crate::agenda::{
parse_message,
AgendaPoint
};
use futures::join;
use slack::{
Event,
Message,
};
use tokio::{
sync::mpsc,
task::{
spawn,
spawn_blocking,
},
};
const TOKEN: Option<&str> = None;
const CHANNEL: Option<&str> = None;
struct Handler {
sender: mpsc::UnboundedSender<AgendaPoint>,
slack_sender: slack::Sender,
slack_channel: String,
}
impl Handler {
fn new(
sender: mpsc::UnboundedSender<AgendaPoint>,
slack_sender: slack::Sender,
slack_channel: String
) -> Self {
Self {
sender,
slack_sender,
slack_channel,
}
}
fn sender(&self) -> &mpsc::UnboundedSender<AgendaPoint> {
&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) => {
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();
}
}
_ => {}
}
}
_ => {}
}
}
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(
sender: mpsc::UnboundedSender<AgendaPoint>,
receiver: mpsc::UnboundedReceiver<AgendaPoint>,
) {
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 || {
match client.run(&mut handler) {
Ok(_) => {}
Err(e) => {
println!("Error: {}", e)
}
}
}),
spawn(receive_from_discord(receiver, slack_sender))
);
}
async fn receive_from_discord(
mut receiver: mpsc::UnboundedReceiver<AgendaPoint>,
sender: slack::Sender,
) {
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");
}
}
|
