Refactor logging

1 files changed, 26 insertions, 8 deletions

diff --git a/src/system/aggregator.rs b/src/system/aggregator.rs
index 822c698..552ea8e 100644
--- a/src/system/aggregator.rs
+++ b/src/system/aggregator.rs
@@ -13,26 +13,44 @@ enum IncomingMessage {
     Partial {message: MessageUpdate, timestamp: Timestamp, seen_by: DiscordToken},
 }
 
+pub enum MemberEvent {
+    Message(Message, DiscordToken),
+    GatewayConnect(DiscordToken),
+    GatewayDisconnect(DiscordToken),
+    GatewayError(DiscordToken),
+}
+
 impl MessageAggregator {
-    pub fn start(system: &System) -> Receiver<(Message, DiscordToken)> {
+    pub fn start(system: &System) -> Receiver<MemberEvent> {
         let incoming_channel = channel::<IncomingMessage>(32);
-        let outgoing_channel = channel::<(Message, DiscordToken)>(32);
+        let outgoing_channel = channel::<MemberEvent>(32);
 
         // Start incoming task for each member
         for member in system.members.iter() {
             let followed_user = system.followed_user.clone();
             let sender = incoming_channel.0.clone();
             let member = member.clone();
+            let outgoing_channel = outgoing_channel.0.clone();
 
             tokio::spawn(async move {
                 loop {
                     let next_event = {member.shard.lock().await.next_event().await};
 
                     match next_event {
-                        Err(err) => println!("Error"),
+                        Err(source) => {
+                            if source.is_fatal() {
+                                let _ = outgoing_channel.send(MemberEvent::GatewayDisconnect(member.discord_token.clone())).await;
+                                return
+                            } else {
+                                let _ = outgoing_channel.send(MemberEvent::GatewayError(member.discord_token.clone())).await;
+                            }
+                        },
+                        Ok(twilight_gateway::Event::Ready(ready)) => {
+                            let _ = outgoing_channel.send(MemberEvent::GatewayConnect(member.discord_token.clone())).await;
+                        },
                         Ok(twilight_gateway::Event::MessageCreate(message)) => {
                             if message.author.id == followed_user {
-                                sender.send(IncomingMessage::Complete {
+                                let _ = sender.send(IncomingMessage::Complete {
                                     message: message.0.clone(),
                                     timestamp: message.timestamp.clone(),
                                     seen_by: member.discord_token.clone()
@@ -41,7 +59,7 @@ impl MessageAggregator {
                         },
                         Ok(twilight_gateway::Event::MessageUpdate(message)) => {
                             if message.author.is_some() && {message.author.as_ref().unwrap().id == followed_user} {
-                                sender.send(IncomingMessage::Partial {
+                                let _ = sender.send(IncomingMessage::Partial {
                                     message: (*message).clone(),
                                     timestamp: message.edited_timestamp.unwrap_or(message.timestamp.expect("No message timestamp")),
                                     seen_by: member.discord_token.clone()
@@ -66,7 +84,7 @@ impl MessageAggregator {
                     Some(IncomingMessage::Complete { message, timestamp, seen_by }) => {
                         if let None = message_cache.get(&message.id) {
                             message_cache.put(message.id.clone(), (message.clone(), timestamp, seen_by.clone()));
-                            sender.send((message, seen_by)).await;
+                            sender.send(MemberEvent::Message(message, seen_by)).await;
                         }
                         
                     },
@@ -76,13 +94,13 @@ impl MessageAggregator {
                                 let mut updated_message = previous_message.clone();
                                 updated_message.content = message.content.unwrap_or(updated_message.content);
                                 message_cache.put(message.id.clone(), (updated_message.clone(), timestamp, seen_by.clone()));
-                                sender.send((updated_message, seen_by)).await;
+                                sender.send(MemberEvent::Message(updated_message, seen_by)).await;
                             }
                         } else {
                             let client = system.members.iter().find(|m| m.discord_token == seen_by).map(|m| m.client.clone()).expect("Could not find client");
                             if let Ok(updated_message) = client.lock().await.message(message.channel_id, message.id).await.unwrap().model().await.map(|r|r.clone()) {
                                 message_cache.put(message.id.clone(), (updated_message.clone(), timestamp, seen_by.clone()));
-                                sender.send((updated_message, seen_by)).await;
+                                sender.send(MemberEvent::Message(updated_message, seen_by)).await;
                             };
                         }