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
|
mod aggregator;
mod types;
mod plugin;
mod util;
mod log;
use aggregator::MemberEvent;
use log::Logger;
use twilight_gateway::{Intents, Shard, ShardId};
use twilight_http::Client;
pub use types::SystemThreadCommand;
use crate::SystemUiEvent;
use std::{num::NonZeroU64, sync::Arc};
use tokio::sync::Mutex;
use plugin::get_plugins;
use std::sync::mpsc::Sender as ThreadSender;
use types::{Member, Response, System};
pub struct Manager;
impl Manager {
pub async fn start(system_name: String, system_config: crate::config::System, ui_sender : ThreadSender<(String, SystemUiEvent)>) {
let gateway_intents = Intents::GUILD_MEMBERS | Intents::GUILD_PRESENCES | Intents::GUILD_MESSAGES | Intents::MESSAGE_CONTENT;
let system = System {
followed_user: NonZeroU64::try_from(system_config.reference_user_id.parse::<u64>().unwrap()).unwrap().into(),
command_prefix: "!".to_string(),
members: system_config.members.iter().map(|member| Member {
discord_token: member.discord_token.clone(),
message_pattern: member.message_pattern.clone(),
shard: Arc::new(Mutex::new(Shard::new(
ShardId::ONE,
member.discord_token.clone(),
gateway_intents.clone(),
))),
client: Arc::new(Mutex::new(Client::new(member.discord_token.clone())))
}).collect(),
};
let mut message_receiver = aggregator::MessageAggregator::start(&system);
let logger = Logger::new(system_name.clone(), system_config.clone(), ui_sender.clone());
let (all_plugins, by_command) = get_plugins();
'member_event: loop {
match message_receiver.recv().await {
None => (),
Some(MemberEvent::GatewayConnect(member_token)) => {
logger.log_connect(member_token).await;
},
Some(MemberEvent::GatewayError(member_token)) => {
logger.log_err(Some(member_token), "Non-fatal gateway error".to_string()).await;
},
Some(MemberEvent::GatewayDisconnect(member_token)) => {
logger.log_disconnect(member_token).await;
},
Some(MemberEvent::Message(message, seen_by)) => {
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;
}
}
}
// 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");
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;}
}
for plugin in &all_plugins {
plugin.post_response(&logger, &system, &new_message, message.channel_id, &message_response).await;
}
}
},
}
},
}
}
}
}
|
