rustycord 0.1.5

A fast, lightweight, and feature-rich Discord bot library written in Rust.
Documentation 
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

use serde::Serialize;

use crate::{
    client::Client, gateway::gateway::PresenceUpdate, logger::setup_logger, response::UserResponse,
};

#[derive(Debug, Serialize)]
pub struct ClientBuilderWS {
    pub intents: Option<i32>,
    pub reconnect: Option<bool>,
    pub shard: usize,
    pub presence: Option<PresenceUpdate>,
}
pub struct BotBase {
    pub intents: Option<i32>,
    pub client: Option<Client>,
    pub presence: Option<PresenceUpdate>,
}

impl BotBase {
    pub async fn new(intents: Option<i32>) -> Self {
        log::debug!("🤖 Creating new BotBase instance");
        if let Some(intents) = intents {
            log::debug!("🎯 Bot intents configured: {}", intents);
        } else {
            log::debug!("🎯 Bot intents not specified, will use defaults");
        }
        BotBase {
            intents: intents,
            client: None,
            presence: None,
        }
    }

    /// login the bot
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use rustycord::bot::BotBase;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    /// let mut bot_base = BotBase::new(None).await;
    /// let result = bot_base.login("your_token_here".to_string()).await;
    /// println!("Login result: {:?}", result);
    /// # }
    /// ```
    pub async fn login(&mut self, token: String) -> UserResponse {
        log::info!("🔑 Initializing bot login...");
        let mut _client = Client::new();
        let res = _client.login(token).await;
        log::info!("🔒 Logged in as: {:?}", res.username);
        self.client = Some(_client);
        res
    }

    /// start the bot
    ///
    /// # Arguments
    ///
    /// * `token` - the token of the bot
    /// * `reconnect` - if the bot should reconnect
    ///
    pub async fn start(&mut self, token: String, reconnect: Option<bool>) -> () {
        log::info!("🚀 Starting bot...");
        self.login(token).await;
        log::info!("📡 Establishing WebSocket connection...");
        self.connect(self.intents, reconnect).await;
    }

    pub async fn stop(&self) -> bool {
        true
    }

    pub async fn connect(&mut self, intents: Option<i32>, reconnect: Option<bool>) {
        log::debug!("🌐 Connecting to Discord gateway...");
        self.client
            .as_mut()
            .unwrap()
            .ws_connect(intents, reconnect, None)
            .await;
        log::info!("✅ Successfully connected to Discord gateway");
    }

    pub async fn set_presence(&mut self, presence: PresenceUpdate) {
        self.presence = Some(presence);
    }

    // pub async fn set_shard(&mut self, shard: usize) {
    //     let ws = ClientBuilderWS {
    //         intents: self.intents,
    //         reconnect: Some(true),
    //         shard: shard,
    //         presence: self.presence,
    //     };
    // }
    pub async fn run(&mut self, token: String, log_level: Option<String>) -> bool {
        let level: String = log_level.unwrap_or_else(|| "info".to_string());

        log::info!("⚙️ Initializing logger with level: {}", level);
        let _ = setup_logger(level);
        log::info!("🤖 rustycord bot starting up...");
        self.start(token, Some(true)).await;
        true
    }
}

pub struct Bot {}

impl Bot {
    pub async fn builder(intents: Option<i32>) -> BotBase {
        let bot = BotBase::new(intents).await;
        bot
    }
}