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/discord.rs | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 src/discord.rs (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs new file mode 100644 index 0000000..06baec6 --- /dev/null +++ b/src/discord.rs @@ -0,0 +1,54 @@ +use discord::{ + model::Event, + Discord, +}; +use futures::join; +use tokio::{ + sync::mpsc, + task::{ + spawn, + spawn_blocking, + }, +}; + +pub async fn handle( + token: Option, + _sender: mpsc::UnboundedSender, + mut receiver: mpsc::UnboundedReceiver, +) { + println!("Setting up Discord"); + + let token = std::env::var("DISCORD_API_TOKEN") + .unwrap_or(token.unwrap()); + let client = Discord::from_bot_token(&token); + + if let Ok(client) = client { + let (mut connection, _) = client.connect().expect("discord connect failed"); //TODO + println!("Discord ready"); + + let (_, _) = join!( //TODO + spawn_blocking(move || { + loop { + match connection.recv_event() { + Ok(Event::MessageCreate(message)) => { + println!("{} says: {}", message.author.name, message.content); + } + Ok(_) => {} + Err(discord::Error::Closed(code, body)) => { + println!("Discord closed with code {:?}: {}", code, body); + break; + } + Err(err) => { + println!("Error: {:?}", err); + } + } + } + }), + spawn(async move { + while let Some(s) = receiver.recv().await { + println!("Discord received '{}' from slack", s); + } + }) + ); + } +} -- 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/discord.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index 06baec6..7c469b2 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -13,25 +13,24 @@ use tokio::{ pub async fn handle( token: Option, - _sender: mpsc::UnboundedSender, + sender: mpsc::UnboundedSender, mut receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Discord"); - let token = std::env::var("DISCORD_API_TOKEN") - .unwrap_or(token.unwrap()); + let token = std::env::var("DISCORD_API_TOKEN").unwrap_or(token.unwrap()); let client = Discord::from_bot_token(&token); if let Ok(client) = client { let (mut connection, _) = client.connect().expect("discord connect failed"); //TODO println!("Discord ready"); - let (_, _) = join!( //TODO + let (_, _) = join!( //TODO? spawn_blocking(move || { loop { match connection.recv_event() { Ok(Event::MessageCreate(message)) => { - println!("{} says: {}", message.author.name, message.content); + sender.send(format!("{} says: {}", message.author.name, message.content)).unwrap(); } Ok(_) => {} Err(discord::Error::Closed(code, body)) => { -- cgit v1.2.1 From 5cdc929bf8bbf2d09c097e8042eeb0068977442d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 14:08:40 +0100 Subject: send messages to discord channel --- src/discord.rs | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index 7c469b2..62a1f9e 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -1,5 +1,8 @@ use discord::{ - model::Event, + model::{ + ChannelId, + Event, + }, Discord, }; use futures::join; @@ -30,7 +33,11 @@ pub async fn handle( loop { match connection.recv_event() { Ok(Event::MessageCreate(message)) => { - sender.send(format!("{} says: {}", message.author.name, message.content)).unwrap(); + sender.send(format!("{:?}:{} says: {}", + message.channel_id, + message.author.name, + message.content)) + .unwrap(); } Ok(_) => {} Err(discord::Error::Closed(code, body)) => { @@ -46,6 +53,11 @@ pub async fn handle( spawn(async move { while let Some(s) = receiver.recv().await { println!("Discord received '{}' from slack", s); + client.send_message(ChannelId(697057150106599488), //TODO + &s, + "", + false + ); } }) ); -- cgit v1.2.1 From ef5645df28e7cfefe4f0ad65123f48c7df38a8e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Wed, 11 Nov 2020 14:16:03 +0100 Subject: don't react to our own discord messages --- src/discord.rs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index 62a1f9e..62e5ee3 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -26,6 +26,7 @@ pub async fn handle( if let Ok(client) = client { let (mut connection, _) = client.connect().expect("discord connect failed"); //TODO + let our_id = client.get_current_user().unwrap().id; println!("Discord ready"); let (_, _) = join!( //TODO? @@ -33,11 +34,13 @@ pub async fn handle( loop { match connection.recv_event() { Ok(Event::MessageCreate(message)) => { - sender.send(format!("{:?}:{} says: {}", - message.channel_id, - message.author.name, - message.content)) - .unwrap(); + if message.author.id != our_id { + sender.send(format!("{:?}:{} says: {}", + message.channel_id, + message.author.name, + message.content)) + .unwrap(); + } } Ok(_) => {} Err(discord::Error::Closed(code, body)) => { -- 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/discord.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index 62e5ee3..b6a22ad 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -4,6 +4,7 @@ use discord::{ Event, }, Discord, + Error, }; use futures::join; use tokio::{ @@ -43,19 +44,19 @@ pub async fn handle( } } Ok(_) => {} - Err(discord::Error::Closed(code, body)) => { + Err(Error::Closed(code, body)) => { println!("Discord closed with code {:?}: {}", code, body); break; } - Err(err) => { - println!("Error: {:?}", err); + Err(e) => { + println!("Error: {:?}", e); } } } }), spawn(async move { while let Some(s) = receiver.recv().await { - println!("Discord received '{}' from slack", s); + println!("Discord received '{}'", s); client.send_message(ChannelId(697057150106599488), //TODO &s, "", -- 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/discord.rs | 80 +++++++++++++++++++++++++++++++++------------------------- 1 file changed, 46 insertions(+), 34 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index b6a22ad..c451ad7 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -18,7 +18,7 @@ use tokio::{ pub async fn handle( token: Option, sender: mpsc::UnboundedSender, - mut receiver: mpsc::UnboundedReceiver, + receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Discord"); @@ -26,44 +26,56 @@ pub async fn handle( let client = Discord::from_bot_token(&token); if let Ok(client) = client { - let (mut connection, _) = client.connect().expect("discord connect failed"); //TODO + let (connection, _) = client.connect().expect("Discord connect failed"); //TODO let our_id = client.get_current_user().unwrap().id; println!("Discord ready"); let (_, _) = join!( //TODO? - spawn_blocking(move || { - 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(); - } - } - Ok(_) => {} - Err(Error::Closed(code, body)) => { - println!("Discord closed with code {:?}: {}", code, body); - break; - } - Err(e) => { - println!("Error: {:?}", e); - } - } - } - }), - spawn(async move { - while let Some(s) = receiver.recv().await { - println!("Discord received '{}'", s); - client.send_message(ChannelId(697057150106599488), //TODO - &s, - "", - false - ); + spawn_blocking(move || receive_events(our_id, connection, sender)), + spawn(receive_from_slack(receiver, client)) + ); + } +} + +fn receive_events( + our_id: discord::model::UserId, + mut connection: discord::Connection, + sender: mpsc::UnboundedSender +) { + 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(); } - }) + } + Ok(_) => {} + Err(Error::Closed(code, body)) => { + println!("Discord closed with code {:?}: {}", code, body); + break; + } + Err(e) => { + println!("Discord error: {:?}", e); + } + } + } +} + +async fn receive_from_slack( + mut receiver: mpsc::UnboundedReceiver, + client: discord::Discord, +) { + while let Some(s) = receiver.recv().await { + println!("Discord received '{}'", s); + client.send_message(ChannelId(697057150106599488), //TODO + &s, + "", + false ); } + } -- 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/discord.rs | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) (limited to 'src/discord.rs') 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, - sender: mpsc::UnboundedSender, - receiver: mpsc::UnboundedReceiver, + sender: mpsc::UnboundedSender, + receiver: mpsc::UnboundedReceiver, ) { 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 + sender: mpsc::UnboundedSender ) { 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, + mut receiver: mpsc::UnboundedReceiver, 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 ); -- 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/discord.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index e422171..9e6550c 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -76,7 +76,7 @@ async fn receive_from_slack( &point.to_add_message(), "", false - ); + ).unwrap(); } } -- 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/discord.rs | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index 9e6550c..fe64b24 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -17,14 +17,16 @@ use tokio::{ }, }; +const TOKEN: Option<&str> = None; +const CHANNEL: Option = None; + pub async fn handle( - token: Option, sender: mpsc::UnboundedSender, receiver: mpsc::UnboundedReceiver, ) { println!("Setting up Discord"); - let token = std::env::var("DISCORD_API_TOKEN").unwrap_or(token.unwrap()); + let token = std::env::var("DISCORD_API_TOKEN").unwrap_or_else(|_| TOKEN.expect("Missing Discord token").to_string()); let client = Discord::from_bot_token(&token); if let Ok(client) = client { @@ -72,10 +74,16 @@ async fn receive_from_slack( ) { while let Some(point) = receiver.recv().await { println!("Discord received '{}'", point); - client.send_message(ChannelId(697057150106599488), //TODO - &point.to_add_message(), - "", - false + client.send_message( + ChannelId( + match std::env::var("DISCORD_CHANNEL") { + Ok(var) => var.parse().unwrap(), + Err(_) => CHANNEL.expect("Missing Discord channel"), + } + ), + &point.to_add_message(), + "", + false ).unwrap(); } -- 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/discord.rs | 58 +++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 37 insertions(+), 21 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index fe64b24..ea7ad03 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -1,4 +1,7 @@ -use crate::agenda::AgendaPoint; +use crate::agenda::{ + parse_message, + AgendaPoint +}; use discord::{ model::{ @@ -9,6 +12,10 @@ use discord::{ Error, }; use futures::join; +use std::sync::{ + Arc, + Mutex, +}; use tokio::{ sync::mpsc, task::{ @@ -27,16 +34,23 @@ 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 (_, _) = join!( //TODO? - spawn_blocking(move || receive_events(our_id, connection, sender)), - spawn(receive_from_slack(receiver, client)) + spawn(receive_from_slack(receiver, Arc::clone(&client), channel_id)), + spawn_blocking(move || receive_events(our_id, connection, sender, client, channel_id)), ); } } @@ -44,17 +58,25 @@ pub async fn handle( fn receive_events( our_id: discord::model::UserId, mut connection: discord::Connection, - sender: mpsc::UnboundedSender + sender: mpsc::UnboundedSender, + client: Arc>, + channel_id: ChannelId, ) { loop { match connection.recv_event() { Ok(Event::MessageCreate(message)) => { - if message.author.id != our_id { - sender.send(AgendaPoint{ - title: message.content, - adder: message.author.name, - }).unwrap(); + if let Ok(Some(s)) = parse_message(&message.content, &message.author.name) { + client.lock().unwrap().send_message(channel_id, + &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)) => { @@ -70,21 +92,15 @@ fn receive_events( async fn receive_from_slack( mut receiver: mpsc::UnboundedReceiver, - client: discord::Discord, + client: Arc>, + channel_id: ChannelId ) { while let Some(point) = receiver.recv().await { println!("Discord received '{}'", point); - client.send_message( - ChannelId( - match std::env::var("DISCORD_CHANNEL") { - Ok(var) => var.parse().unwrap(), - Err(_) => CHANNEL.expect("Missing Discord channel"), - } - ), - &point.to_add_message(), - "", - false - ).unwrap(); + client.lock().unwrap().send_message(channel_id, + &point.to_add_message(), + "", + false).unwrap(); } } -- 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/discord.rs | 74 +++++++++++++++++++++++++++++++++++----------------------- 1 file changed, 45 insertions(+), 29 deletions(-) (limited to 'src/discord.rs') 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::().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, client: Arc>, - channel_id: ChannelId, + channel: Option, ) { 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::>()); + } + } + 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, client: Arc>, - channel_id: ChannelId + channel: Option ) { - 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(); + } } } -- 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/discord.rs | 44 ++++++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 20 deletions(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index 3933aba..a41b96a 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -64,31 +64,35 @@ fn receive_events( 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::>()); + if channel.is_none() { + 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::>()); + } } } Ok(Event::MessageCreate(message)) => { 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 channel == message.channel_id { + if let Ok(Some(s)) = parse_message( + &message.content, + &message.author.name, + &sender, + ) { + client.lock().unwrap().send_message(channel, + &s, + "", + false).unwrap(); + } } } } -- cgit v1.2.1 From 96b9a8f66f62e64bc4907e12de0772392f7804c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= Date: Mon, 16 Nov 2020 15:45:01 +0100 Subject: change slack channel type sig Yes, I have these commented and use hard-coded tokens. What are you going to do about it? --- src/discord.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/discord.rs') diff --git a/src/discord.rs b/src/discord.rs index a41b96a..0507da8 100644 --- a/src/discord.rs +++ b/src/discord.rs @@ -26,7 +26,7 @@ use tokio::{ }; const TOKEN: Option<&str> = None; -const CHANNEL: Option = None; +const CHANNEL: Option = None; pub async fn handle( sender: mpsc::UnboundedSender, -- cgit v1.2.1