tgbot/types/message/sender/
mod.rs

1use serde::{Deserialize, Serialize};
2
3use crate::types::{Chat, ChatPeerId, ChatUsername, User, UserPeerId, UserUsername};
4
5#[cfg(test)]
6mod tests;
7
8/// Represents a sender of a message.
9#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
10#[allow(clippy::large_enum_variant)]
11#[serde(untagged, from = "RawMessageSender", into = "RawMessageSender")]
12pub enum MessageSender {
13    /// For messages sent by a chat.
14    ///
15    /// For example, the channel itself for channel posts, the supergroup itself for messages
16    /// from anonymous group administrators, the linked channel
17    /// for messages automatically forwarded to the discussion group.
18    Chat(Chat),
19    /// For messages sent by a user.
20    User(User),
21    /// For messages without a sender chat and a user.
22    Unknown,
23}
24
25impl From<Chat> for MessageSender {
26    fn from(value: Chat) -> Self {
27        Self::Chat(value)
28    }
29}
30
31impl From<User> for MessageSender {
32    fn from(value: User) -> Self {
33        Self::User(value)
34    }
35}
36
37impl MessageSender {
38    /// Returns the sender user.
39    pub fn get_user(&self) -> Option<&User> {
40        match self {
41            MessageSender::User(user) => Some(user),
42            _ => None,
43        }
44    }
45
46    /// Returns the ID of the sender user.
47    pub fn get_user_id(&self) -> Option<UserPeerId> {
48        self.get_user().map(|user| user.id)
49    }
50
51    /// Returns the username of the sender user.
52    pub fn get_user_username(&self) -> Option<&UserUsername> {
53        self.get_user().and_then(|user| user.username.as_ref())
54    }
55
56    /// Returns the sender chat.
57    pub fn get_chat(&self) -> Option<&Chat> {
58        match self {
59            MessageSender::Chat(chat) => Some(chat),
60            _ => None,
61        }
62    }
63
64    /// Returns the ID of the sender chat.
65    pub fn get_chat_id(&self) -> Option<ChatPeerId> {
66        self.get_chat().map(|chat| chat.get_id())
67    }
68
69    /// Returns the username of the sender chat.
70    pub fn get_chat_username(&self) -> Option<&ChatUsername> {
71        self.get_chat().and_then(|chat| chat.get_username())
72    }
73}
74
75#[serde_with::skip_serializing_none]
76#[derive(Clone, Debug, Deserialize, Serialize)]
77struct RawMessageSender {
78    sender_chat: Option<Chat>,
79    from: Option<User>,
80}
81
82impl From<RawMessageSender> for MessageSender {
83    fn from(raw: RawMessageSender) -> Self {
84        match (raw.sender_chat, raw.from) {
85            (Some(chat), None) => MessageSender::Chat(chat),
86            (None, Some(user)) => MessageSender::User(user),
87            _ => MessageSender::Unknown,
88        }
89    }
90}
91
92impl From<MessageSender> for RawMessageSender {
93    fn from(value: MessageSender) -> Self {
94        match value {
95            MessageSender::Chat(chat) => Self {
96                sender_chat: Some(chat),
97                from: None,
98            },
99            MessageSender::User(user) => Self {
100                sender_chat: None,
101                from: Some(user),
102            },
103            MessageSender::Unknown => Self {
104                sender_chat: None,
105                from: None,
106            },
107        }
108    }
109}