secubot 2.9.0

Yet another Discord bot!
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::sync::Arc;

use poise::{
    serenity_prelude::{
        self as serenity, model::application::interaction::Interaction::ApplicationCommand,
        ApplicationCommandInteraction, CommandDataOption,
    },
    Event, Framework, FrameworkContext,
};
use tracing::{debug, info};

use crate::{ctx_data::CtxData, settings::Feature, tasks, Error, Result};

pub async fn on_error(error: poise::FrameworkError<'_, Arc<CtxData>, Error>) {
    // This is our custom error handler
    // They are many errors that can occur, so we only handle the ones we want to
    // customize and forward the rest to the default handler
    match error {
        poise::FrameworkError::Setup { error, .. } => panic!("Failed to start bot: {error:?}"),
        poise::FrameworkError::Command { error, ctx } => {
            debug!("Error in command `{}`: {:?}", ctx.command().name, error,);
        }
        error => {
            if let Err(e) = poise::builtins::on_error(error).await {
                debug!("Error while handling error: {}", e);
            }
        }
    }
}

pub async fn event_handler<'a>(
    ctx: &'a serenity::Context,
    event: &'a Event<'_>,
    _framework_context: FrameworkContext<'a, Arc<CtxData>, Error>,
    ctx_data: &'a CtxData,
) -> Result<()> {
    // debug!("Got an event in event handler: {:?}", event.name());

    // TODO: use message for URLs?
    match event {
        Event::Ready { data_about_bot } => info!("{} is connected!", data_about_bot.user.name),

        Event::InteractionCreate {
            interaction:
                ApplicationCommand(ApplicationCommandInteraction {
                    data,
                    channel_id,
                    user,
                    ..
                }),
        } => {
            let args = if data.options.is_empty() {
                String::new()
            } else {
                let mut buf = String::new();
                gather_options(&mut buf, &data.options);
                buf
            };

            debug!(
                "INTR: cmd[{}] args[{}] channelid[{}] userid[{}] username[{}]",
                data.name,
                args.trim_start(),
                channel_id.0,
                user.id,
                user.name
            );
        }

        #[allow(unused_variables)]
        Event::MessageDelete {
            channel_id,
            deleted_message_id,
            guild_id,
        } => {
            if ctx_data
                .settings
                .is_feature_enabled(&Feature::NotifyOnDeletedMessages, &ctx, channel_id)
                .await
            {
                if let Err(e) = channel_id.say(&ctx, "<deleted>").await {
                    debug!("Error while sending <deleted>: {:?}", e);
                };
            }
        }

        #[allow(unused_variables)]
        Event::MessageDeleteBulk {
            channel_id,
            multiple_deleted_messages_ids,
            guild_id,
        } => {
            if ctx_data
                .settings
                .is_feature_enabled(&Feature::NotifyOnDeletedMessages, &ctx, channel_id)
                .await
            {
                let text = format!("<{}x deleted>", multiple_deleted_messages_ids.len());
                if let Err(e) = channel_id.say(&ctx, &text).await {
                    debug!("Error while sending {}: {:?}", text, e);
                };
            }
        }

        _ => (),
    };
    Ok(())
}

pub async fn setup<'a>(
    ctx: &'a serenity::Context,
    _ready: &'a serenity::Ready,
    framework: &Framework<Arc<CtxData>, Error>,
    ctx_data: Arc<CtxData>,
) -> Result<Arc<CtxData>> {
    // let empty: &[poise::structs::Command<CtxData, Error>] = &[];
    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
    // TODO: add this back at some point
    // for guild in settings.commands.guilds {
    //     let commands = COMMANDS
    //         .iter()
    //         .filter(|cmd| guild.commands.contains(&cmd.name))
    //         .collect();
    //     poise::builtins::register_in_guild(ctx, commands,
    // serenity::GuildId(guild.id)).await?; }

    tasks::start_tasks(&ctx_data, ctx.http.clone());
    Ok(ctx_data)
}

fn gather_options(buf: &mut String, opts: &Vec<CommandDataOption>) {
    for opt in opts {
        buf.push(' ');
        buf.push_str(&opt.name);

        if let Some(val) = &opt.value {
            buf.push(' ');
            buf.push_str(&val.to_string());
        }

        gather_options(buf, &opt.options);
    }
}