doxing-emulator 0.2.0

Doxing emulator
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! # `doxing-emulator` library crate
//!
//! If you are reading this, you are reading the documentation for the `doxing-emulator` library crate. For the cli, kindly refer to the README file.

#![deny(missing_docs)]
#![warn(clippy::all, clippy::nursery, clippy::pedantic, clippy::cargo)]
#![allow(clippy::multiple_crate_versions, reason = "Dependency")]

mod commands;
mod dox_impl;
mod inline;
mod non_command;
mod setup;

use anyhow::{Result, bail};
pub use commands::{Command, Commands};
use frakti::{
    AsyncTelegramApi, ParseMode,
    client_cyper::Bot,
    inline_mode::InlineQueryResult,
    methods::{AnswerInlineQueryParams, GetUpdatesParams, SendMessageParams},
    types::ReplyParameters,
    updates::UpdateContent,
};
use log::{error, info, trace};
use non_command::handle_non_command;
use serde::Deserialize;
use setup::{setup_commands, setup_rights};

/// Configuration for the bot.
#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct Config {
    /// The token for the bot.
    pub token: String,
}

/// Runs the bot.
///
/// ## Errors
///
/// Errors if setting up or determining username failed.
pub async fn run(config: Config) -> Result<()> {
    let token = config.token;
    let bot = Bot::new(&token);
    setup_commands(&bot).await?;
    setup_rights(&bot).await?;

    let me = bot.get_me().await?.result;
    let Some(username) = me.username else {
        bail!("Cannot get username of the bot");
    };
    info!("Bot started: @{username}");

    // Handle incoming messages
    let mut update_params = GetUpdatesParams::builder().build();
    loop {
        match bot.get_updates(&update_params).await {
            Ok(updates) => {
                // Update offset
                let Some(last) = updates.result.last() else {
                    continue;
                };
                update_params.offset.replace((last.update_id + 1).into());
                // Process each update
                for update in updates.result {
                    trace!("Received update: {update:?}");
                    match update.content {
                        UpdateContent::Message(msg) => {
                            // Handling messages
                            let bot = bot.clone();
                            let username = username.clone();
                            compio::runtime::spawn(async move {
                                let parsed = Commands::parse(msg.text.as_ref(), &username);
                                let chat_id = msg.chat.id;
                                let message_id = msg.message_id;
                                let reply = match parsed {
                                    // Commands
                                    Some(command) => {
                                        Some(command.execute(&bot, *msg, &username).await)
                                    }
                                    // Non-commands, can be forwarded messages or others
                                    None => handle_non_command(&bot, *msg).await,
                                };
                                if let Some(reply) = reply {
                                    info!("Reply: {reply}");
                                    let reply_param =
                                        ReplyParameters::builder().message_id(message_id).build();
                                    let send_message_param = SendMessageParams::builder()
                                        .chat_id(chat_id)
                                        .text(reply)
                                        .reply_parameters(reply_param)
                                        .parse_mode(ParseMode::Html)
                                        .build();
                                    _ = bot
                                        .send_message(&send_message_param)
                                        .await
                                        .inspect_err(|e| error!("Failed to send message: {e}"));
                                }
                            })
                            .detach();
                        }
                        UpdateContent::InlineQuery(inline) => {
                            // Handling inline queries
                            let bot = bot.clone();
                            compio::runtime::spawn(async move {
                                let article = inline::handle_inline_query(&bot, &inline).await;
                                info!("Answer: {:?}", article.input_message_content);
                                let result = InlineQueryResult::Article(article);
                                let answer_param = AnswerInlineQueryParams::builder()
                                    .inline_query_id(inline.id)
                                    .results(vec![result])
                                    .button(inline::help_button())
                                    .cache_time(60)
                                    .build();
                                _ = bot
                                    .answer_inline_query(&answer_param)
                                    .await
                                    .inspect_err(|e| error!("Failed to answer inline query: {e}"));
                            })
                            .detach();
                        }
                        _ => {}
                    }
                }
            }
            Err(err) => {
                error!("Error getting updates: {err}");
            }
        }
    }
}