tgbot 0.47.0

A Telegram Bot library
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

use serde::Serialize;

use crate::{
    api::{Method, Payload, PayloadError},
    types::{ChatId, Integer},
};

/// Adds a message to a list of pinned messages in a chat.
///
/// If the chat is not a private chat, the bot must be an administrator
/// in the chat for this to work and must have the `can_pin_messages`
/// admin right in a supergroup or `can_edit_messages` admin right in a channel.
#[serde_with::skip_serializing_none]
#[derive(Clone, Debug, Serialize)]
pub struct PinChatMessage {
    chat_id: ChatId,
    message_id: Integer,
    business_connection_id: Option<String>,
    disable_notification: Option<bool>,
}

impl PinChatMessage {
    /// Creates a new `PinChatMessage`
    ///
    /// # Arguments
    ///
    /// * `chat_id` - Unique identifier of the target chat.
    /// * `message_id` - Identifier of a message to pin.
    pub fn new<T>(chat_id: T, message_id: Integer) -> Self
    where
        T: Into<ChatId>,
    {
        PinChatMessage {
            chat_id: chat_id.into(),
            message_id,
            business_connection_id: None,
            disable_notification: None,
        }
    }

    /// Sets a new business connection ID.
    ///
    /// # Arguments
    ///
    /// * `value` - Unique identifier of the business connection
    ///   on behalf of which the message will be pinned.
    pub fn with_business_connection_id<T>(mut self, value: T) -> Self
    where
        T: Into<String>,
    {
        self.business_connection_id = Some(value.into());
        self
    }

    /// Sets a new value for the `disable_notification` flag.
    ///
    /// # Arguments
    ///
    /// * `value` - Indicates whether to notify all chat members about the new pinned message;
    ///   notifications are always disabled in channels and private chats.
    pub fn with_disable_notification(mut self, value: bool) -> Self {
        self.disable_notification = Some(value);
        self
    }
}

impl Method for PinChatMessage {
    type Response = bool;

    fn into_payload(self) -> Result<Payload, PayloadError> {
        Payload::json("pinChatMessage", self)
    }
}

/// Removes a message from a list of pinned messages in a chat.
///
/// If the chat is not a private chat, the bot must be an administrator
/// in the chat for this to work and must have the `can_pin_messages`
/// admin right in a supergroup or `can_edit_messages` admin right in a channel.
#[serde_with::skip_serializing_none]
#[derive(Clone, Debug, Serialize)]
pub struct UnpinChatMessage {
    chat_id: ChatId,
    business_connection_id: Option<String>,
    message_id: Option<Integer>,
}

impl UnpinChatMessage {
    /// Creates a new `UnpinChatMessage`.
    ///
    /// # Arguments
    ///
    /// * `chat_id` - Unique identifier of the target chat.
    pub fn new<T>(chat_id: T) -> Self
    where
        T: Into<ChatId>,
    {
        UnpinChatMessage {
            chat_id: chat_id.into(),
            business_connection_id: None,
            message_id: None,
        }
    }

    /// Sets a new business connection ID.
    ///
    /// # Arguments
    ///
    /// * `value` - Unique identifier of the business connection
    ///   on behalf of which the message will be unpinned.
    pub fn with_business_connection_id<T>(mut self, value: T) -> Self
    where
        T: Into<String>,
    {
        self.business_connection_id = Some(value.into());
        self
    }

    /// Sets a new message ID.
    ///
    /// # Arguments
    ///
    /// * `value` - Identifier of a message to unpin.
    ///
    /// If not specified, the most recent pinned message (by sending date) will be unpinned.
    pub fn with_message_id(mut self, value: Integer) -> Self {
        self.message_id = Some(value);
        self
    }
}

impl Method for UnpinChatMessage {
    type Response = bool;

    fn into_payload(self) -> Result<Payload, PayloadError> {
        Payload::json("unpinChatMessage", self)
    }
}

/// Clears a list of pinned messages in a chat.
///
/// If the chat is not a private chat, the bot must be an administrator
/// in the chat for this to work and must have the `can_pin_messages`
/// admin right in a supergroup or `can_edit_messages` admin right in a channel.
#[derive(Clone, Debug, Serialize)]
pub struct UnpinAllChatMessages {
    chat_id: ChatId,
}

impl UnpinAllChatMessages {
    /// Creates a new `UnpinAllChatMessages`.
    ///
    /// # Arguments
    ///
    /// * `chat_id` - Unique identifier of the target chat.
    pub fn new<T>(chat_id: T) -> Self
    where
        T: Into<ChatId>,
    {
        UnpinAllChatMessages {
            chat_id: chat_id.into(),
        }
    }
}

impl Method for UnpinAllChatMessages {
    type Response = bool;

    fn into_payload(self) -> Result<Payload, PayloadError> {
        Payload::json("unpinAllChatMessages", self)
    }
}