summary refs log tree commit diff
path: root/src/system/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/system/mod.rs')
-rw-r--r--src/system/mod.rs79
1 files changed, 39 insertions, 40 deletions
diff --git a/src/system/mod.rs b/src/system/mod.rs
index 8e642ea..0f5f23c 100644
--- a/src/system/mod.rs
+++ b/src/system/mod.rs
@@ -12,7 +12,7 @@ pub use types::SystemThreadCommand;
 use crate::SystemUiEvent;
 use std::{num::NonZeroU64, sync::Arc};
 use tokio::sync::Mutex;
-use plugin::SeancePlugin;
+use plugin::get_plugins;
 
 use std::sync::mpsc::Sender as ThreadSender;
 use types::{Member, Response, System};
@@ -39,12 +39,9 @@ impl Manager {
         let mut message_receiver = aggregator::MessageAggregator::start(&system);
         let logger = Logger::new(system_name.clone(), system_config.clone(), ui_sender.clone());
 
-        let mut plugins : Vec<Box<dyn SeancePlugin>> = vec![
-            Box::new(plugin::ProxyPrefixes),
-            Box::new(plugin::Autoproxy::new()),
-        ];
+        let (all_plugins, by_command) = get_plugins();
 
-        loop {
+        'member_event: loop {
             match message_receiver.recv().await {
                 None => (),
                 Some(MemberEvent::GatewayConnect(member_token)) => {
@@ -57,47 +54,49 @@ impl Manager {
                     logger.log_disconnect(member_token).await;
                 },
                 Some(MemberEvent::Message(message, seen_by)) => {
-                    if message.content.starts_with(&system.command_prefix) {
-                        logger.log_line(None, format!("Handling command: {}", message.content)).await;
-                        for plugin in &mut plugins {
-                            match plugin.handle_command(&logger, &system, &message).await {
-                                plugin::CommandOutcome::Skipped => continue,
-                                plugin::CommandOutcome::Handled => break,
-                                plugin::CommandOutcome::Errored {message} => {
-                                    logger.log_err(None, message).await;
-                                    break
-                                },
+                    if let Some(command_string) = message.content.strip_prefix(&system.command_prefix) {
+                        let mut words = command_string.split_whitespace();
+                        if let Some(command) = words.next() {
+                            if let Some(plugin) = by_command.get(command) {
+                                logger.log_line(None, format!("Handling command: {command}")).await;
+                                let args : Vec<_> = words.collect();
+
+                                plugin.handle_command(&logger, &system, &message, args).await;
+                                continue 'member_event;
+                            } else {
+                                logger.log_line(None, format!("Unknown command: {command}")).await;
                             }
                         }
-                    } else {
-                        let mut message_response = Response::Noop { delete_source: false };
-                        for plugin in &plugins {
-                            plugin.handle_message(&logger, &system, &message, &mut message_response).await;
-                        }
+                    }
+
+                    // Handle as message
+                    let mut message_response = Response::Noop { delete_source: false };
+                    for plugin in &all_plugins {
+                        plugin.handle_message(&logger, &system, &message, &mut message_response).await;
+                    }
 
-                        match message_response.clone() {
-                            Response::Noop { delete_source } => {
-                                if delete_source {
-                                    let client = system.members.iter().find(|m| m.discord_token == seen_by).map(|m| m.client.clone())
-                                        .expect("No such client");
+                    match message_response.clone() {
+                        Response::Noop { delete_source } => {
+                            if delete_source {
+                                let client = system.members.iter().find(|m| m.discord_token == seen_by).map(|m| m.client.clone())
+                                    .expect("No such client");
 
-                                    let _ = client.lock().await.delete_message(message.channel_id, message.id)
-                                        .await;
+                                let _ = client.lock().await.delete_message(message.channel_id, message.id)
+                                    .await;
+                            }
+                        },
+                        Response::Proxy { member, content } => {
+                            if let Ok(new_message) = util::duplicate_message(&member.client, &message, content.as_str()).await {
+                                if let Err(err) = {member.client.lock().await.delete_message(message.channel_id, message.id).await.map(|_| ()).map_err(|err| err.to_string()).clone() } {
+                                    logger.log_err(Some(member.discord_token), format!("Could not proxy message: {err}")).await;
+                                    {let _ = member.client.lock().await.delete_message(new_message.channel_id, new_message.id).await;}
                                 }
-                            },
-                            Response::Proxy { member, content } => {
-                                if let Ok(new_message) = util::duplicate_message(&member.client, &message, content.as_str()).await {
-                                    if let Err(err) = {member.client.lock().await.delete_message(message.channel_id, message.id).await.map(|_| ()).map_err(|err| err.to_string()).clone() } {
-                                        logger.log_err(Some(member.discord_token), format!("Could not proxy message: {err}")).await;
-                                        {let _ = member.client.lock().await.delete_message(new_message.channel_id, new_message.id).await;}
-                                    }
 
-                                    for plugin in &plugins {
-                                        plugin.post_response(&logger, &system, &new_message, message.channel_id, &message_response).await;
-                                    }
+                                for plugin in &all_plugins {
+                                    plugin.post_response(&logger, &system, &new_message, message.channel_id, &message_response).await;
                                 }
-                            },
-                        }
+                            }
+                        },
                     }
                 },
             }