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

use std::{
    collections::{HashMap, HashSet},
    env,
    hash::Hash,
};

use config::{Config, ConfigError, Environment, File};
use glob::glob;
use poise::serenity_prelude::{CacheHttp, Channel, ChannelId, GuildId};
use serde_derive::Deserialize;
use tracing::debug;

#[derive(Debug, Deserialize, Clone, PartialEq, Eq, Hash)]
pub enum Feature {
    NotifyOnDeletedMessages,
    PeriodicTodoReminders,
}

impl Feature {
    fn all() -> HashSet<Self> {
        HashSet::from([
            Feature::NotifyOnDeletedMessages,
            Feature::PeriodicTodoReminders,
        ])
    }
}

#[derive(Debug, Deserialize, Clone)]
#[allow(unused)]
pub struct Database {
    pub url: String,
}

impl Default for Database {
    fn default() -> Self {
        Self {
            url: "db.sqlite".to_string(),
        }
    }
}

#[derive(Debug, Deserialize, Clone)]
#[allow(unused)]
pub struct BotSettings {
    #[serde(default = "Feature::all")]
    pub features: HashSet<Feature>,
}

impl Default for BotSettings {
    fn default() -> Self {
        Self {
            features: Feature::all(),
        }
    }
}

#[derive(Debug, Deserialize, Clone)]
#[allow(unused)]
pub struct Settings {
    // pub log_level: String,
    pub discord_token: String,
    #[serde(default)]
    pub database: Database,
    #[serde(default)]
    pub global: BotSettings,
    #[serde(default)]
    pub guilds: HashMap<GuildId, BotSettings>,
}

impl Settings {
    pub fn new() -> Result<Self, ConfigError> {
        let cwd = match env::current_dir() {
            Ok(cwd) => cwd.display().to_string(),
            Err(_) => ".".to_string(),
        };
        // let mode = env::var("SCBT_RUN_MODE").unwrap_or_else(|_| "dev".into());

        debug!(
            "Looking for configuration file {cwd}/config and/or configuration files in {cwd}{}",
            "/config/"
        );

        let config = Config::builder()
            .add_source(File::with_name(&format!("{cwd}/config")).required(false))
            .add_source(
                glob(&format!("{cwd}/config/*"))
                    .unwrap()
                    .map(|path| File::from(path.unwrap()))
                    .collect::<Vec<_>>(),
            )
            .add_source(Environment::with_prefix("SCBT").separator("__"))
            .build()?;

        config.try_deserialize()
    }

    pub async fn is_feature_enabled(
        &self,
        feature: &Feature,
        cache_http: impl CacheHttp,
        channel_id: &ChannelId,
    ) -> bool {
        let channel = channel_id.to_channel(&cache_http).await.ok();
        let default = self.global.features.contains(feature);

        if let Some(Channel::Guild(guild)) = channel {
            self.guilds
                .get(&guild.guild_id)
                .map_or(default, |guild| guild.features.contains(feature))
        } else {
            default
        }
    }
}