aves-tyto 0.5.7

Specialized messaging domain for the Aves async application runtime
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

use std::sync::Arc;

use teloxide_core::Bot;
use url::Url;

use crate::messages::ListenerType;
use crate::types::{MessagingConfig, MessagingCredentials, MessagingError, MessagingSubscriptionError, TelegramConfig};

/// Builds the Telegram transport from settings and supplied credentials.
pub(super) fn configure(
    settings: &MessagingConfig,
    credentials: &MessagingCredentials,
) -> Result<Arc<Bot>, MessagingError> {
    let MessagingCredentials::Telegram { token } = credentials else {
        return Err(MessagingError::ChannelConnectionFailed {
            listener_type: ListenerType::Telegram,
            message: "credential protocol does not match the listener".to_owned(),
        });
    };

    let mut config = settings
        .telegram
        .clone()
        .ok_or_else(|| MessagingError::ChannelConnectionFailed {
            listener_type: ListenerType::Telegram,
            message: "Telegram config block is missing".to_owned(),
        })?;
    config.token = Some(token.clone());

    prepare(&config)
}

fn prepare(config: &TelegramConfig) -> Result<Arc<Bot>, MessagingError> {
    let token = config
        .token
        .as_ref()
        .ok_or_else(|| MessagingError::ChannelConnectionFailed {
            listener_type: ListenerType::Telegram,
            message: "Telegram token is missing".to_owned(),
        })?;
    let bot = build_bot(token, config.api_url.as_deref()).map_err(|error| MessagingError::ChannelConnectionFailed {
        listener_type: ListenerType::Telegram,
        message: error.to_string(),
    })?;
    Ok(Arc::new(bot))
}

fn build_bot(token: &str, api_url: Option<&str>) -> Result<Bot, MessagingSubscriptionError> {
    let bot = Bot::new(token);

    match api_url {
        None => Ok(bot),
        Some(raw_url) => {
            let url = Url::parse(raw_url).map_err(|source| MessagingSubscriptionError::Configuration {
                listener_type: ListenerType::Telegram,
                message: format!("Telegram invalid api_url: {source}"),
            })?;
            Ok(bot.set_api_url(url))
        }
    }
}

#[cfg(test)]
pub(super) fn test_prepare(config: &TelegramConfig) -> Result<Arc<Bot>, MessagingError> {
    prepare(config)
}