chatterbox 2.4.0

streamlined text notifications via telegram, email, slack, discord, gotify and resend
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

use reqwest::header::HeaderMap;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tokio::sync::broadcast::Receiver;

use crate::dispatcher::{Example, Handler};
use crate::message::Message;
use log::debug;

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct Telegram {
    pub bot_token: String,
    pub chat_id: u64,
}

impl Example for Telegram {
    fn example() -> Self {
        Telegram {
            bot_token: "92349823049:DFIPJEXAMPLE-EXAMPLE123d-EXAMPLE".to_string(),
            chat_id: 1234567890,
        }
    }
}

impl Handler for Telegram {
    fn start_handler(self, receiver: Receiver<String>) {
        let mut handler = TelegramHandler {
            config: self,
            receiver,
        };
        tokio::spawn(async move {
            handler.start().await;
        });
    }
}

async fn send_message(
    bot_token: &str,
    chat_id: &u64,
    message: Message,
) -> Result<(), reqwest::Error> {
    let url = format!("https://api.telegram.org/bot{}/sendMessage", bot_token);
    let text = message.html();
    let mut params: HashMap<&str, &str> = HashMap::new();
    let chat_id = chat_id.to_string();
    params.insert("text", &text);
    params.insert("chat_id", &chat_id);
    params.insert("parse_mode", "html");

    let mut headers = HeaderMap::new();
    headers.insert("Accept", "application/json".parse().unwrap());
    headers.insert(
        "User-Agent",
        "Telegram Bot SDK - (https://github.com/irazasyed/telegram-bot-sdk)"
            .parse()
            .unwrap(),
    );
    headers.insert("Content-Type", "application/json".parse().unwrap());

    debug!("dispatching telegram message");

    let client = reqwest::Client::new();
    client
        .post(url)
        .headers(headers)
        .json(&params)
        .send()
        .await?;
    debug!("sent telegram message");
    Ok(())
}

pub struct TelegramHandler {
    pub(crate) config: Telegram,
    pub(crate) receiver: Receiver<String>,
}

impl TelegramHandler {
    pub async fn start(&mut self) {
        while let Ok(data) = self.receiver.recv().await {
            let message = Message::from_json(data);
            send_message(&self.config.bot_token, &self.config.chat_id, message)
                .await
                .expect("failed sending message");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use std;

    #[test]
    fn test_example() {
        Telegram::example();
    }

    #[tokio::test]
    async fn test_dispatch_example() {
        let bot_token = std::env::var("CHATTERBOX_TELEGRAM_BOT_TOKEN").unwrap_or_default();
        let chat_id = std::env::var("CHATTERBOX_TELEGRAM_CHAT_ID").unwrap_or_default();
        let chat_id = chat_id.parse::<u64>().unwrap();
        let test_message = Message::test_example();
        send_message(&bot_token, &chat_id, test_message)
            .await
            .unwrap();
    }
}