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
107
108
109
110
111
112
|
use std::time::Duration;
use color_eyre::eyre::{eyre, Context as _, Report, Result};
use log::*;
use poise::serenity_prelude as serenity;
use poise::{EditTracker, Framework, FrameworkOptions, PrefixFrameworkOptions};
use redis::ConnectionLike;
use storage::Storage;
mod api;
mod colors;
mod commands;
mod consts;
mod handlers;
mod storage;
mod utils;
type Context<'a> = poise::Context<'a, Data, Report>;
#[derive(Clone)]
pub struct Data {
storage: Storage,
}
impl Data {
pub fn new() -> Result<Self> {
let redis_url = std::env::var("REDIS_URL")
.wrap_err_with(|| "Couldn't find Redis URL in environment!")?;
let storage = Storage::new(&redis_url)?;
Ok(Self { storage })
}
}
async fn setup(
ctx: &serenity::Context,
_ready: &serenity::Ready,
framework: &Framework<Data, Report>,
) -> Result<Data> {
let data = Data::new()?;
let mut client = data.storage.client.clone();
if !client.check_connection() {
return Err(eyre!(
"Couldn't connect to storage! Is your daemon running?"
));
}
poise::builtins::register_globally(ctx, &framework.options().commands).await?;
info!("Registered global commands!");
// register "extra" commands in guilds that allow it
info!("Fetching opted guilds");
let guilds = data.storage.get_opted_guilds().await?;
for guild in guilds {
poise::builtins::register_in_guild(ctx, &commands::to_optional_commands(), guild).await?;
info!("Registered guild commands to {}", guild);
}
Ok(data)
}
#[tokio::main]
async fn main() -> Result<()> {
dotenvy::dotenv().ok();
color_eyre::install()?;
env_logger::init();
let token =
std::env::var("TOKEN").wrap_err_with(|| eyre!("Couldn't find token in environment!"))?;
let intents =
serenity::GatewayIntents::non_privileged() | serenity::GatewayIntents::MESSAGE_CONTENT;
let options = FrameworkOptions {
commands: commands::to_global_commands(),
on_error: |error| Box::pin(handlers::handle_error(error)),
command_check: Some(|ctx| {
Box::pin(async move { Ok(ctx.author().id != ctx.framework().bot_id) })
}),
event_handler: |ctx, event, framework, data| {
Box::pin(handlers::handle_event(ctx, event, framework, data))
},
prefix_options: PrefixFrameworkOptions {
prefix: Some("!".into()),
edit_tracker: Some(EditTracker::for_timespan(Duration::from_secs(3600))),
..Default::default()
},
..Default::default()
};
let framework = Framework::builder()
.token(token)
.intents(intents)
.options(options)
.setup(|ctx, ready, framework| Box::pin(setup(ctx, ready, framework)));
tokio::select! {
result = framework.run() => result.map_err(Report::from),
_ = tokio::signal::ctrl_c() => {
info!("Interrupted! Exiting...");
std::process::exit(130);
}
}
}
|
