tele 0.1.23

Ergonomic Telegram Bot API SDK for Rust, built on reqx
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
132
133
134
135
136
137

use super::*;
use crate::types::validation::MAX_MESSAGE_TEXT_CHARS;

const DEFAULT_REJECTION_MESSAGE: &str = "request rejected";

/// Structured route-level rejection reason.
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum RouteRejection {
    Message(String),
    GroupOnly,
    SupergroupOnly,
    AdminOnly,
    OwnerOnly,
    ActorRequired,
    SubjectRequired,
    ChatContextRequired,
    MissingActorCapabilities(Vec<ChatAdministratorCapability>),
    MissingBotCapabilities(Vec<ChatAdministratorCapability>),
    Throttled,
}

impl RouteRejection {
    pub fn message(&self) -> String {
        match self {
            Self::Message(message) => normalize_user_message(message, DEFAULT_REJECTION_MESSAGE),
            Self::GroupOnly => "this route is only available in group chats".to_owned(),
            Self::SupergroupOnly => "this route is only available in supergroups".to_owned(),
            Self::AdminOnly => "chat administrators only".to_owned(),
            Self::OwnerOnly => "chat owner only".to_owned(),
            Self::ActorRequired => "this route requires an actor user".to_owned(),
            Self::SubjectRequired => "this route requires a subject user".to_owned(),
            Self::ChatContextRequired => "this route requires a chat context".to_owned(),
            Self::MissingActorCapabilities(missing) => format!(
                "missing required capabilities: {}",
                missing
                    .iter()
                    .map(ChatAdministratorCapability::as_str)
                    .collect::<Vec<_>>()
                    .join(", ")
            ),
            Self::MissingBotCapabilities(missing) => format!(
                "bot is missing required capabilities: {}",
                missing
                    .iter()
                    .map(ChatAdministratorCapability::as_str)
                    .collect::<Vec<_>>()
                    .join(", ")
            ),
            Self::Throttled => "too many matching requests, please retry shortly".to_owned(),
        }
    }

    pub fn custom(message: impl Into<String>) -> Self {
        let message = message.into();
        Self::Message(normalize_user_message(&message, DEFAULT_REJECTION_MESSAGE))
    }
}

pub(crate) fn normalize_user_message(message: &str, default_message: &str) -> String {
    let mut normalized = message
        .trim()
        .chars()
        .map(|character| {
            if is_disallowed_rejection_character(character) {
                ' '
            } else {
                character
            }
        })
        .take(MAX_MESSAGE_TEXT_CHARS)
        .collect::<String>();
    normalized = normalized.trim().to_owned();

    if normalized.is_empty() {
        default_message.to_owned()
    } else {
        normalized
    }
}

fn is_disallowed_rejection_character(character: char) -> bool {
    character.is_control() && !matches!(character, '\n' | '\r' | '\t')
}

/// Handler error type that separates route rejections from internal failures.
#[derive(Debug)]
pub enum HandlerError {
    Rejected(RouteRejection),
    Internal(Error),
}

impl HandlerError {
    pub fn user(message: impl Into<String>) -> Self {
        Self::Rejected(RouteRejection::custom(message))
    }

    pub fn rejected(rejection: RouteRejection) -> Self {
        Self::Rejected(rejection)
    }

    pub fn internal(error: Error) -> Self {
        Self::Internal(error)
    }
}

impl From<RouteRejection> for HandlerError {
    fn from(value: RouteRejection) -> Self {
        Self::Rejected(value)
    }
}

impl From<Error> for HandlerError {
    fn from(value: Error) -> Self {
        Self::Internal(value)
    }
}

/// Ergonomic result type for bot handlers.
pub type HandlerResult = std::result::Result<(), HandlerError>;

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

    #[test]
    fn custom_rejection_message_is_sendable_text() {
        let rejection = RouteRejection::custom(" invalid\u{0007}input ");
        assert_eq!(rejection.message(), "invalid input");

        let rejection = RouteRejection::custom(" \n\t ");
        assert_eq!(rejection.message(), DEFAULT_REJECTION_MESSAGE);

        let rejection = RouteRejection::custom("a".repeat(MAX_MESSAGE_TEXT_CHARS + 1));
        assert_eq!(rejection.message().chars().count(), MAX_MESSAGE_TEXT_CHARS);
    }
}