Refactor gateway and message aggregation

1 files changed, 0 insertions, 116 deletions

diff --git a/src/listener.rs b/src/listener.rs
deleted file mode 100644
index 3b432cf..0000000
--- a/src/listener.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use tokio::sync::mpsc::Sender;
-use twilight_http::Client;
-use twilight_model::{channel::Message, id::{Id, marker::{ChannelMarker, MessageMarker, UserMarker}}, user::User};
-use twilight_gateway::{error::ReceiveMessageError, Intents, MessageSender, Shard, ShardId};
-use twilight_model::util::Timestamp;
-
-pub struct Listener {
-    pub config: crate::config::Member,
-    pub reference_user_id: Id<UserMarker>,
-}
-
-impl Listener {
-    pub fn new(config: crate::config::Member, reference_user_id: Id<UserMarker>) -> Self {
-        Listener {
-            config,
-            reference_user_id,
-        }
-    }
-
-    pub async fn start_listening(&mut self, channel : Sender<ClientEvent>) {
-        let intents = Intents::GUILD_MEMBERS | Intents::GUILD_PRESENCES | Intents::GUILD_MESSAGES | Intents::MESSAGE_CONTENT;
-
-        let mut shard = Shard::new(ShardId::ONE, self.config.discord_token.clone(), intents);
-        let client = Client::new(self.config.discord_token.clone());
-
-        loop {
-            match shard.next_event().await {
-                Ok(event) => {
-                    match event {
-                        twilight_gateway::Event::Ready(client) => {
-                            println!("Bot started for {}#{}", client.user.name, client.user.discriminator);
-                            channel.send(ClientEvent::Ready {
-                                client_name: self.config.name.clone(),
-                                send_channel: shard.sender(),
-                            }).await;
-                        },
-
-                        twilight_gateway::Event::MessageCreate(message_create) => {
-                            let message = message_create.0;
-
-                            if message.author.id != self.reference_user_id {
-                                continue
-                            }
-
-                            if let Err(_) = channel.send(ClientEvent::Message {
-                                event_time: message.timestamp,
-                                message
-                            }).await {
-                                println!("Client listener error: System context has already closed");
-                                return
-                            }
-                        },
-
-                        twilight_gateway::Event::MessageUpdate(message_update) => {
-                            if message_update.author.is_none() || message_update.author.as_ref().unwrap().id != self.reference_user_id {
-                                continue
-                            }
-
-                            if message_update.edited_timestamp.is_none() {
-                                println!("Message update but no edit timestamp");
-                                continue;
-                            }
-
-                            if message_update.content.is_none() {
-                                println!("Message update but no content");
-                                continue;
-                            }
-
-                            let message = client.message(message_update.channel_id, message_update.id)
-                                .await.expect("Could not load message")
-                                .model().await.expect("Could not deserialize message");
-
-                            if let Err(_) = channel.send(ClientEvent::Message {
-                                event_time: message_update.edited_timestamp.unwrap(),
-                                message,
-                            }).await {
-                                println!("Client listener error: System context has already closed");
-                                return
-                            }
-                        },
-
-                        _ => (),
-                    }
-                },
-                Err(source) => {
-                    if !source.is_fatal() {
-                        println!("Warn: Client encountered an error: {}", source.to_string());
-                        continue;
-                    }
-
-                    if let Err(_) = channel.send(ClientEvent::Error(source)).await {
-                        println!("Client listener error: System context has already closed");
-                        break;
-                    }
-                    break;
-                }
-            };
-        }
-    }
-}
-
-pub enum ClientEvent {
-    Startup,
-    Ready {
-        client_name: String,
-        send_channel: MessageSender,
-    },
-    AutoproxyTimeout {
-        last_message: Timestamp,
-    },
-    Message {
-        event_time: Timestamp,
-        message: Message,
-    },
-    Error(ReceiveMessageError)
-}