tg_flows/types/

chat_member.rs

use std::ops::Deref;

use serde::{Deserialize, Serialize};

use crate::types::{UntilDate, User};

/// This object contains information about one member of the chat.
///
/// [The official docs](https://core.telegram.org/bots/api#chatmember).
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct ChatMember {
    /// Information about the user.
    pub user: User,

    /// The member's status in the chat.
    #[serde(flatten)]
    pub kind: ChatMemberKind,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[serde(tag = "status")]
pub enum ChatMemberKind {
    #[serde(rename = "creator")]
    Owner(Owner),
    Administrator(Administrator),
    Member,
    Restricted(Restricted),
    Left,
    #[serde(rename = "kicked")]
    Banned(Banned),
}

/// Owner of the group. This struct is part of the [`ChatMemberKind`] enum.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct Owner {
    /// Custom title for this user.
    pub custom_title: Option<String>,

    /// True, if the user's presence in the chat is hidden
    pub is_anonymous: bool,
}

/// Administrator of the group. This struct is part of the [`ChatMemberKind`]
/// enum.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct Administrator {
    /// Custom title for this user.
    pub custom_title: Option<String>,

    /// `true` if the user's presence in the chat is hidden
    pub is_anonymous: bool,

    /// `true` if the bot is allowed to edit administrator privileges of that
    /// user.
    pub can_be_edited: bool,

    /// `true` if the administrator can access the chat event log, chat
    /// statistics, message statistics in channels, see channel members, see
    /// anonymous administrators in supergroups and ignore slow mode. Implied by
    /// any other administrator privilege
    pub can_manage_chat: bool,

    /// `true` if the administrator can change the chat title, photo and other
    /// settings.
    pub can_change_info: bool,

    /// `true` if the administrator can post in the channel, channels only.
    #[serde(default)]
    pub can_post_messages: bool,

    /// `true` if the administrator can edit messages of other users and can pin
    /// messages, channels only.
    #[serde(default)]
    pub can_edit_messages: bool,

    /// `true` if the administrator can delete messages of other users.
    pub can_delete_messages: bool,

    /// `true` if the administrator can manage video chats.
    pub can_manage_video_chats: bool,

    /// `true` if the administrator can invite new users to the chat.
    pub can_invite_users: bool,

    /// `true` if the administrator can restrict, ban or unban chat members.
    pub can_restrict_members: bool,

    /// `true` if the administrator can pin messages, supergroups only.
    #[serde(default)]
    pub can_pin_messages: bool,

    /// `true`, if the user is allowed to create, rename, close, and reopen
    /// forum topics; supergroups only
    #[serde(default)]
    pub can_manage_topics: bool,

    /// `true` if the administrator can add new administrators with a subset of
    /// his own privileges or demote administrators that he has promoted,
    /// directly or indirectly (promoted by administrators that were appointed
    /// by the user).
    pub can_promote_members: bool,
}

/// User, restricted in the group. This struct is part of the [`ChatMemberKind`]
/// enum.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct Restricted {
    /// Date when restrictions will be lifted for this user.
    pub until_date: UntilDate,

    /// `true` if the user is a member of the chat at the moment of the request.
    pub is_member: bool,

    /// `true` if the user can send text messages, contacts, locations and
    /// venues.
    pub can_send_messages: bool,

    /// `true` if the user is allowed to send audios, documents, photos, videos,
    /// video notes and voice notes.
    pub can_send_media_messages: bool,

    /// `true` if the user is allowed to send animations, games, stickers and
    /// use inline bots.
    pub can_send_other_messages: bool,

    /// `true` if the user is allowed to add web page previews to their
    /// messages.
    pub can_add_web_page_previews: bool,

    /// `true` if the user is allowed to change the chat title, photo
    /// and other settings.
    pub can_change_info: bool,

    /// `true` if the user is allowed to invite new users to the chat.
    pub can_invite_users: bool,

    /// `true` if the user is allowed to pin messages.
    pub can_pin_messages: bool,

    /// `true`, if the user is allowed to create, rename, close, and reopen
    /// forum topics
    pub can_manage_topics: bool,

    /// `true` if the user is allowed to send polls.
    pub can_send_polls: bool,
}

/// User that was banned in the chat and can't return to it or view chat
/// messages. This struct is part of the [`ChatMemberKind`] enum.
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct Banned {
    /// Date when restrictions will be lifted for this user.
    pub until_date: UntilDate,
}

/// This allows calling [`ChatMemberKind`]'s methods directly on [`ChatMember`].
///
/// ```no_run
/// use teloxide_core::types::ChatMember;
///
/// let member: ChatMember = todo!();
///
/// let _ = member.status();
/// let _ = member.kind.status();
/// ```
impl Deref for ChatMember {
    type Target = ChatMemberKind;

    fn deref(&self) -> &Self::Target {
        &self.kind
    }
}

/// Simple methods for checking a user status.
impl ChatMemberKind {
    /// Returns chat member status.
    #[must_use]
    pub fn status(&self) -> ChatMemberStatus {
        match self {
            ChatMemberKind::Owner(_) => ChatMemberStatus::Owner,
            ChatMemberKind::Administrator(_) => ChatMemberStatus::Administrator,
            ChatMemberKind::Member => ChatMemberStatus::Member,
            ChatMemberKind::Restricted(_) => ChatMemberStatus::Restricted,
            ChatMemberKind::Left => ChatMemberStatus::Left,
            ChatMemberKind::Banned(_) => ChatMemberStatus::Banned,
        }
    }

    /// Returns `true` if the user is the [owner] of the given chat.
    ///
    /// [owner]: ChatMemberKind::Owner
    #[must_use]
    pub fn is_owner(&self) -> bool {
        matches!(self, Self::Owner { .. })
    }

    /// Returns `true` if the user is an [administrator] of the given chat.
    ///
    /// [administrator]: ChatMemberKind::Administrator
    ///
    /// **Note**: this function **doesn't** return `true` if the user is the
    /// owner of the given chat. See also: [`is_privileged`].
    ///
    /// [`is_privileged`]: ChatMemberKind::is_privileged
    #[must_use]
    pub fn is_administrator(&self) -> bool {
        matches!(self, Self::Administrator { .. })
    }

    /// Returns `true` if the user is a common [member] of the given chat.
    ///
    /// ⚠️ Don't confuse this with [`is_present`]. This method merely checks
    /// for [`ChatMemberKind::Member`] variant which is not enough to determine
    /// if the user is joinned to the chat. Use [`is_present`] for that instead.
    ///
    /// [member]: ChatMemberKind::Member
    /// [`is_present`]: ChatMemberKind::is_present
    #[must_use]
    pub fn is_member(&self) -> bool {
        matches!(self, Self::Member { .. })
    }

    /// Returns `true` if the user is [restricted] in the given chat.
    ///
    /// [restricted]: ChatMemberKind::Restricted
    #[must_use]
    pub fn is_restricted(&self) -> bool {
        matches!(self, Self::Restricted { .. })
    }

    /// Returns `true` if the user [left] the given chat.
    ///
    /// ⚠️ Don't confuse this with [`is_present`]. This method merely checks
    /// for [`ChatMemberKind::Left`] variant which is not enough to determine
    /// if the user is joinned to the chat. Use [`is_present`] for that instead.
    ///
    /// [left]: ChatMemberKind::Left
    /// [`is_present`]: ChatMemberKind::is_present
    #[must_use]
    pub fn is_left(&self) -> bool {
        matches!(self, Self::Left { .. })
    }

    /// Returns `true` if the user is [banned] in the given chat.
    ///
    /// [banned]: ChatMemberKind::Banned
    #[must_use]
    pub fn is_banned(&self) -> bool {
        matches!(self, Self::Banned { .. })
    }

    /// Returns `true` if the user is [kicked] from the given chat.
    ///
    /// [kicked]: ChatMemberKind::Banned
    #[deprecated = "use `is_banned` instead"]
    #[must_use]
    pub fn is_kicked(&self) -> bool {
        self.is_banned()
    }

    /// Returns `true` if the user is the [creator] (owner) of the given chat.
    ///
    /// [creator]: ChatMemberKind::Owner
    #[deprecated = "use `is_owner` instead"]
    #[must_use]
    pub fn is_creator(&self) -> bool {
        self.is_owner()
    }
}

/// Compound methods for checking a user status.
impl ChatMemberKind {
    /// Returns `true` if the user is privileged in the given chat. i.e. if the
    /// user is either the [owner] or an [administrator] in the given chat.
    ///
    /// [owner]: ChatMemberKind::Owner
    /// [administrator]: ChatMemberKind::Administrator
    #[must_use]
    pub fn is_privileged(&self) -> bool {
        self.is_administrator() || self.is_owner()
    }

    /// Returns `true` if the user is currently present in the chat. i.e. if the
    /// user **hasn't** [left] or been [banned]. It also returns `false` if the
    /// user left the chat, but was [restricted].
    ///
    /// [left]: ChatMemberKind::Left
    /// [banned]: ChatMemberKind::Banned
    /// [restricted]: ChatMemberKind::Restricted
    #[must_use]
    pub fn is_present(&self) -> bool {
        let is_restricted_non_member =
            matches!(self, Self::Restricted(Restricted { is_member: false, .. }));

        !(self.is_left() || self.is_banned() || is_restricted_non_member)
    }
}

impl ChatMemberKind {
    /// Getter for [`Administrator::custom_title`] and [`Owner::custom_title`]
    /// fields.
    #[must_use]
    pub fn custom_title(&self) -> Option<&str> {
        match &self {
            Self::Administrator(Administrator { custom_title, .. })
            | Self::Owner(Owner { custom_title, .. }) => custom_title.as_deref(),
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => None,
        }
    }

    /// Returns `true` if the user's presence in the chat is hidden.
    ///
    /// I.e. returns `true` if the user is the owner of the chat or an
    /// administrator in the chat and has the [`can_manage_chat`] privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_manage_chat`]: Administrator::can_manage_chat
    #[must_use]
    pub fn is_anonymous(&self) -> bool {
        match self {
            Self::Owner(Owner { is_anonymous, .. })
            | Self::Administrator(Administrator { is_anonymous, .. }) => *is_anonymous,
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Getter for [`Restricted::until_date`] and [`Banned::until_date`] fields.
    #[must_use]
    pub fn until_date(&self) -> Option<UntilDate> {
        match &self {
            Self::Owner(_) | Self::Administrator(_) | Self::Member | Self::Left => None,
            Self::Restricted(Restricted { until_date, .. })
            | Self::Banned(Banned { until_date, .. }) => Some(*until_date),
        }
    }
}

/// Methods for checking admin privileges.
impl ChatMemberKind {
    /// Returns `true` if the user is an administrator in the given chat and the
    /// bot is allowed to edit administrator privileges of that user.
    #[must_use]
    pub fn can_be_edited(&self) -> bool {
        match self {
            Self::Administrator(Administrator { can_be_edited, .. }) => *can_be_edited,
            // Owner can't ever be edited by any bot.
            Self::Owner(_) | Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => {
                false
            }
        }
    }

    /// Returns `true` if the user can access the chat event log, chat
    /// statistics, message statistics in channels, see channel members, see
    /// anonymous administrators in supergroups and ignore slow mode. Implied by
    /// any other administrator privilege.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat
    /// - is an administrator in the given chat and has [`can_manage_chat`]
    ///   privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_manage_chat`]: Administrator::can_manage_chat
    #[must_use]
    pub fn can_manage_chat(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_manage_chat, .. }) => *can_manage_chat,
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can change the chat title, photo and other
    /// settings.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat
    /// - is an administrator in the given chat and has the
    ///   [`Administrator::can_change_info`] privilege.
    /// - is restricted, but does have [`Restricted::can_change_info`] privilege
    /// Returns `false` otherwise.
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_change_info` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_change_info(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_change_info, .. })
            | Self::Restricted(Restricted { can_change_info, .. }) => *can_change_info,
            Self::Member | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can post in the channel, channels only.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat (even if the chat is not a channel)
    /// - is an administrator in the given chat and has [`can_post_messages`]
    ///   privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_post_messages`]: Administrator::can_post_messages
    #[must_use]
    pub fn can_post_messages(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_post_messages, .. }) => *can_post_messages,
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can edit messages of other users and can pin
    /// messages, channels only.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat (even if the chat is not a channel)
    /// - is an administrator in the given chat and has the
    ///   [`can_edit_messages`] privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_edit_messages`]: Administrator::can_edit_messages
    #[must_use]
    pub fn can_edit_messages(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_edit_messages, .. }) => *can_edit_messages,
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can delete messages of other users.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat
    /// - is an administrator in the given chat and has the
    ///   [`can_delete_messages`] privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_delete_messages`]: Administrator::can_delete_messages
    #[must_use]
    pub fn can_delete_messages(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_delete_messages, .. }) => *can_delete_messages,
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can manage video chats.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat
    /// - is an administrator in the given chat and has the
    ///   [`can_manage_video_chats`] privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_manage_video_chats`]: Administrator::can_manage_video_chats
    #[must_use]
    pub fn can_manage_video_chats(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_manage_video_chats, .. }) => {
                *can_manage_video_chats
            }
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    #[deprecated(since = "0.6.0", note = "renamed to `can_manage_video_chats`")]
    #[must_use]
    pub fn can_manage_voice_chats(&self) -> bool {
        self.can_manage_video_chats()
    }

    /// Returns `true` if the user can can invite new users to the chat.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat
    /// - is an administrator in the given chat and has the
    ///   [`Administrator::can_invite_users`] privilege.
    /// - is restricted, but does have [`Restricted::can_invite_users`]
    ///   privilege
    /// Returns `false` otherwise.
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_invite_users` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_invite_users(&self) -> bool {
        match &self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_invite_users, .. })
            | Self::Restricted(Restricted { can_invite_users, .. }) => *can_invite_users,
            Self::Member | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can restrict, ban or unban chat members.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat
    /// - is an administrator in the given chat and has the
    ///   [`can_restrict_members`] privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_restrict_members`]: Administrator::can_restrict_members
    #[must_use]
    pub fn can_restrict_members(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_restrict_members, .. }) => {
                *can_restrict_members
            }
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can pin messages, supergroups only.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat (even if the chat is not a supergroup)
    /// - is an administrator in the given chat and has the
    ///   [`Administrator::can_pin_messages`] privilege.
    /// - is restricted, but does have [`Restricted::can_pin_messages`]
    ///   privilege
    /// Returns `false` otherwise.
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_pin_messages` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_pin_messages(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_pin_messages, .. })
            | Self::Restricted(Restricted { can_pin_messages, .. }) => *can_pin_messages,
            Self::Member | Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user is allowed to manage topics.
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat (even if the chat is not a supergroup)
    /// - is an administrator in the given chat and has the
    ///   [`Administrator::can_manage_topics`] privilege.
    /// - is restricted, but does have [`Restricted::can_manage_topics`]
    ///   privilege
    /// Returns `false` otherwise.
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_manage_topics` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_manage_topics(&self) -> bool {
        match self {
            ChatMemberKind::Owner(_) => true,
            ChatMemberKind::Administrator(Administrator { can_manage_topics, .. })
            | ChatMemberKind::Restricted(Restricted { can_manage_topics, .. }) => {
                *can_manage_topics
            }
            ChatMemberKind::Member | ChatMemberKind::Left | ChatMemberKind::Banned(_) => false,
        }
    }

    /// Returns `true` if the user can add new administrators with a subset of
    /// his own privileges or demote administrators that he has promoted,
    /// directly or indirectly (promoted by administrators that were appointed
    /// by the user).
    ///
    /// I.e. returns `true` if the user
    /// - is the owner of the chat (even if the chat is not a channel)
    /// - is an administrator in the given chat and has the
    ///   [`can_promote_members`] privilege.
    /// Returns `false` otherwise.
    ///
    /// [`can_promote_members`]: Administrator::can_promote_members
    #[must_use]
    pub fn can_promote_members(&self) -> bool {
        match self {
            Self::Owner(_) => true,
            Self::Administrator(Administrator { can_promote_members, .. }) => *can_promote_members,
            Self::Member | Self::Restricted(_) | Self::Left | Self::Banned(_) => false,
        }
    }
}

/// Methods for checking member rights.
impl ChatMemberKind {
    /// Returns `true` if the user can send text messages, contacts, locations
    /// and venues.
    ///
    /// I.e. returns **`false`** if the user
    /// - has left or has been banned in the chat
    /// - is restricted and doesn't have the [`can_send_messages`] right
    /// Returns `true` otherwise.
    ///
    /// [`can_send_messages`]: Restricted::can_send_messages
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_send_messages` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_send_messages(&self) -> bool {
        match &self {
            Self::Restricted(Restricted { can_send_messages, .. }) => *can_send_messages,
            Self::Owner(_) | Self::Administrator(_) | Self::Member => true,
            Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user is allowed to send audios, documents, photos,
    /// videos, video notes and voice notes.
    ///
    /// I.e. returns **`false`** if the user
    /// - has left or has been banned in the chat
    /// - is restricted and doesn't have the [`can_send_media_messages`] right
    /// Returns `true` otherwise.
    ///
    /// [`can_send_media_messages`]: Restricted::can_send_media_messages
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_send_media_messages` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_send_media_messages(&self) -> bool {
        match &self {
            Self::Restricted(Restricted { can_send_media_messages, .. }) => {
                *can_send_media_messages
            }
            Self::Owner(_) | Self::Administrator(_) | Self::Member => true,
            Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user is allowed to send animations, games,
    /// stickers and use inline bots.
    ///
    /// I.e. returns **`false`** if the user
    /// - has left or has been banned from the chat
    /// - is restricted and doesn't have the [`can_send_media_messages`] right
    /// Returns `true` otherwise.
    ///
    /// [`can_send_media_messages`]: Restricted::can_send_media_messages
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_send_other_messages` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_send_other_messages(&self) -> bool {
        match &self {
            Self::Restricted(Restricted { can_send_other_messages, .. }) => {
                *can_send_other_messages
            }
            Self::Owner(_) | Self::Administrator(_) | Self::Member => true,
            Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user is allowed to add web page previews to their
    /// messages.
    ///
    /// I.e. returns **`false`** if the user
    /// - has left or has been banned from the chat
    /// - is restricted and doesn't have the [`can_send_media_messages`] right
    /// Returns `true` otherwise.
    ///
    /// [`can_send_media_messages`]: Restricted::can_send_media_messages
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_add_web_page_previews` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_add_web_page_previews(&self) -> bool {
        match &self {
            Self::Restricted(Restricted { can_add_web_page_previews, .. }) => {
                *can_add_web_page_previews
            }
            Self::Owner(_) | Self::Administrator(_) | Self::Member => true,
            Self::Left | Self::Banned(_) => false,
        }
    }

    /// Returns `true` if the user is allowed to send polls.
    ///
    /// I.e. returns **`false`** if the user
    /// - has left or has been banned from the chat
    /// - is restricted and doesn't have the [`can_send_polls`] right
    /// Returns `true` otherwise.
    ///
    /// [`can_send_polls`]: Restricted::can_send_polls
    #[deprecated(
        since = "0.9.0",
        note = "Match manually and use `can_send_polls` field directly. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    #[must_use]
    pub fn can_send_polls(&self) -> bool {
        match &self {
            Self::Restricted(Restricted { can_send_polls, .. }) => *can_send_polls,
            Self::Owner(_) | Self::Administrator(_) | Self::Member => true,
            Self::Left | Self::Banned(_) => false,
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChatMemberStatus {
    #[serde(rename = "creator")]
    Owner,
    Administrator,
    Member,
    Restricted,
    Left,
    #[serde(rename = "kicked")]
    Banned,
}

/// Simple methods for checking a user status.
impl ChatMemberStatus {
    /// Returns `true` if the user is the [owner] of the given chat.
    ///
    /// [owner]: ChatMemberKind::Owner
    #[must_use]
    pub fn is_owner(&self) -> bool {
        matches!(self, Self::Owner { .. })
    }

    /// Returns `true` if the user is an [administrator] of the given chat.
    ///
    /// [administrator]: ChatMemberKind::Administrator
    ///
    /// **Note**: this function **doesn't** return `true` if the user is the
    /// owner of the given chat. See also: [`is_privileged`].
    ///
    /// [`is_privileged`]: ChatMemberKind::is_privileged
    #[must_use]
    pub fn is_administrator(&self) -> bool {
        matches!(self, Self::Administrator { .. })
    }

    /// Returns `true` if the user is a common [member] of the given chat.
    ///
    /// ⚠️ Don't confuse this with [`is_present`]. This method merely checks
    /// for [`ChatMemberStatus::Member`] variant which is not enough to
    /// determine if the user is joinned to the chat. Use [`is_present`] for
    /// that instead.
    ///
    /// [member]: ChatMemberKind::Member
    /// [`is_present`]: ChatMemberKind::is_present
    #[must_use]
    pub fn is_member(&self) -> bool {
        matches!(self, Self::Member { .. })
    }

    /// Returns `true` if the user is [restricted] in the given chat.
    ///
    /// [restricted]: ChatMemberKind::Restricted
    #[must_use]
    pub fn is_restricted(&self) -> bool {
        matches!(self, Self::Restricted { .. })
    }

    /// Returns `true` if the user [left] the given chat.
    ///
    /// ⚠️ Don't confuse this with [`is_present`]. This method merely checks
    /// for [`ChatMemberStatus::Left`] variant which is not enough to determine
    /// if the user is joinned to the chat. Use [`is_present`] for that instead.
    ///
    /// [left]: ChatMemberKind::Left
    /// [`is_present`]: ChatMemberKind::is_present
    #[must_use]
    pub fn is_left(&self) -> bool {
        matches!(self, Self::Left { .. })
    }

    /// Returns `true` if the user is [banned] in the given chat.
    ///
    /// [banned]: ChatMemberKind::Banned
    #[must_use]
    pub fn is_banned(&self) -> bool {
        matches!(self, Self::Banned { .. })
    }
}

/// Compound methods for checking a user status.
impl ChatMemberStatus {
    /// Returns `true` if the user is privileged in the given chat. i.e. if the
    /// user is either the [owner] or an [administrator] in the given chat.
    ///
    /// [owner]: ChatMemberKind::Owner
    /// [administrator]: ChatMemberKind::Administrator
    #[must_use]
    pub fn is_privileged(&self) -> bool {
        self.is_administrator() || self.is_owner()
    }

    /// Returns `true` if the user is currently present in the chat. i.e. if the
    /// user **hasn't** [left] or been [banned].
    ///
    /// [left]: ChatMemberKind::Left
    /// [banned]: ChatMemberKind::Banned
    #[must_use]
    #[deprecated(
        since = "0.9.0",
        note = "Use `ChatMemberKind::is_present` method instead. Details: https://github.com/teloxide/teloxide/issues/781"
    )]
    pub fn is_present(&self) -> bool {
        !(self.is_left() || self.is_banned())
    }
}

#[cfg(test)]
mod tests {
    use crate::types::UserId;

    use super::*;

    #[test]
    fn deserialize() {
        let json = r#"{
            "user":{
                "id":1029940401,
                "is_bot":false,
                "first_name":"First",
                "last_name":"Last",
                "username":"fl",
                "language_code":"en"
            },
            "status":"administrator",
            "is_anonymous": false,
            "can_be_edited": false,
            "can_manage_chat": true,
            "can_change_info": true,
            "can_delete_messages": true,
            "can_manage_video_chats": true,
            "can_invite_users": true,
            "can_restrict_members": true,
            "can_pin_messages": true,
            "can_promote_members": true
        }"#;
        let expected = ChatMember {
            user: User {
                id: UserId(1029940401),
                is_bot: false,
                first_name: "First".to_string(),
                last_name: Some("Last".to_string()),
                username: Some("fl".to_string()),
                language_code: Some("en".to_string()),
                is_premium: false,
                added_to_attachment_menu: false,
            },
            kind: ChatMemberKind::Administrator(Administrator {
                custom_title: None,
                is_anonymous: false,
                can_be_edited: false,
                can_manage_chat: true,
                can_change_info: true,
                can_post_messages: false,
                can_edit_messages: false,
                can_delete_messages: true,
                can_manage_video_chats: true,
                can_invite_users: true,
                can_restrict_members: true,
                can_pin_messages: true,
                can_promote_members: true,
                can_manage_topics: false,
            }),
        };
        let actual = serde_json::from_str::<ChatMember>(json).unwrap();
        assert_eq!(actual, expected)
    }
}