Store original User enum

Author: Lonami

lib/grammers-client/src/types/chat/user.rs

@@ -62,7 +62,7 @@ impl RestrictionReason {
 /// [@BotFather]: https://t.me/BotFather
 #[derive(Clone)]
 pub struct User {
-    pub raw: tl::types::User,
+    pub raw: tl::enums::User,
 }
 
 impl fmt::Debug for User {
@@ -74,73 +74,30 @@ impl fmt::Debug for User {
 // TODO: photo
 impl User {
     pub fn from_raw(user: tl::enums::User) -> Self {
-        Self {
-            raw: match user {
-                tl::enums::User::Empty(empty) => tl::types::User {
-                    is_self: false,
-                    contact: false,
-                    mutual_contact: false,
-                    deleted: false,
-                    bot: false,
-                    bot_chat_history: false,
-                    bot_nochats: false,
-                    verified: false,
-                    restricted: false,
-                    min: false,
-                    bot_inline_geo: false,
-                    support: false,
-                    scam: false,
-                    apply_min_photo: false,
-                    fake: false,
-                    bot_attach_menu: false,
-                    premium: false,
-                    attach_menu_enabled: false,
-                    bot_can_edit: false,
-                    close_friend: false,
-                    stories_hidden: false,
-                    stories_unavailable: true,
-                    contact_require_premium: false,
-                    bot_business: false,
-                    bot_has_main_app: false,
-                    id: empty.id,
-                    access_hash: None,
-                    first_name: None,
-                    last_name: None,
-                    username: None,
-                    phone: None,
-                    photo: None,
-                    status: None,
-                    bot_info_version: None,
-                    restriction_reason: None,
-                    bot_inline_placeholder: None,
-                    lang_code: None,
-                    emoji_status: None,
-                    usernames: None,
-                    stories_max_id: None,
-                    color: None,
-                    profile_color: None,
-                    bot_active_users: None,
-                },
-                tl::enums::User::User(user) => user,
-            },
+        Self { raw: user }
+    }
+
+    fn user(&self) -> Option<&tl::types::User> {
+        match &self.raw {
+            tl::enums::User::User(u) => Some(u),
+            tl::enums::User::Empty(_) => None,
         }
     }
 
     /// Return the user presence status (also known as "last seen").
     pub fn status(&self) -> &grammers_tl_types::enums::UserStatus {
-        self.raw
-            .status
-            .as_ref()
+        self.user()
+            .and_then(|u| u.status.as_ref())
             .unwrap_or(&grammers_tl_types::enums::UserStatus::Empty)
     }
 
     /// Return the unique identifier for this user.
     pub fn id(&self) -> i64 {
-        self.raw.id
+        self.raw.id()
     }
 
     pub(crate) fn access_hash(&self) -> Option<i64> {
-        self.raw.access_hash
+        self.user().and_then(|u| u.access_hash)
     }
 
     /// Pack this user into a smaller representation that can be loaded later.
@@ -161,15 +118,16 @@ impl User {
     /// The name will be `None` if the account was deleted. It may also be `None` if you received
     /// it previously.
     pub fn first_name(&self) -> Option<&str> {
-        self.raw.first_name.as_deref()
+        self.user().and_then(|u| u.first_name.as_deref())
     }
 
     /// Return the last name of this user, if any.
     pub fn last_name(&self) -> Option<&str> {
-        self.raw
-            .last_name
-            .as_deref()
-            .and_then(|name| if name.is_empty() { None } else { Some(name) })
+        self.user().and_then(|u| {
+            u.last_name
+                .as_deref()
+                .and_then(|name| if name.is_empty() { None } else { Some(name) })
+        })
     }
 
     /// Return the full name of this user.
@@ -196,7 +154,7 @@ impl User {
     /// Outside of the application, people may link to this user with one of Telegram's URLs, such
     /// as https://t.me/username.
     pub fn username(&self) -> Option<&str> {
-        self.raw.username.as_deref()
+        self.user().and_then(|u| u.username.as_deref())
     }
 
     /// Return collectible usernames of this chat, if any.
@@ -206,9 +164,8 @@ impl User {
     /// Outside of the application, people may link to this user with one of its username, such
     /// as https://t.me/username.
     pub fn usernames(&self) -> Vec<&str> {
-        self.raw
-            .usernames
-            .as_deref()
+        self.user()
+            .and_then(|u| u.usernames.as_deref())
             .map_or(Vec::new(), |usernames| {
                 usernames
                     .iter()
@@ -222,12 +179,12 @@ impl User {
     /// Return the phone number of this user, if they are not a bot and their privacy settings
     /// allow you to see it.
     pub fn phone(&self) -> Option<&str> {
-        self.raw.phone.as_deref()
+        self.user().and_then(|u| u.phone.as_deref())
     }
 
     /// Return the photo of this user, if any.
     pub fn photo(&self) -> Option<&tl::types::UserProfilePhoto> {
-        match self.raw.photo.as_ref() {
+        match self.user().and_then(|u| u.photo.as_ref()) {
             Some(maybe_photo) => match maybe_photo {
                 tl::enums::UserProfilePhoto::Empty => None,
                 tl::enums::UserProfilePhoto::Photo(photo) => Some(photo),
@@ -239,32 +196,32 @@ impl User {
     /// Does this user represent the account that's currently logged in?
     pub fn is_self(&self) -> bool {
         // TODO if is_self is false, check in chat cache if id == ourself
-        self.raw.is_self
+        self.user().map(|u| u.is_self).unwrap_or(false)
     }
 
     /// Is this user in your account's contact list?
     pub fn contact(&self) -> bool {
-        self.raw.contact
+        self.user().map(|u| u.contact).unwrap_or(false)
     }
 
     /// Is this user a mutual contact?
     ///
     /// Contacts are mutual if both the user of the current account and this user have eachother
     /// in their respective contact list.
     pub fn mutual_contact(&self) -> bool {
-        self.raw.mutual_contact
+        self.user().map(|u| u.mutual_contact).unwrap_or(false)
     }
 
     /// Has the account of this user been deleted?
     pub fn deleted(&self) -> bool {
-        self.raw.deleted
+        self.user().map(|u| u.deleted).unwrap_or(false)
     }
 
     /// Is the current account a bot?
     ///
     /// Bot accounts are those created by [@BotFather](https://t.me/BotFather).
     pub fn is_bot(&self) -> bool {
-        self.raw.bot
+        self.user().map(|u| u.bot).unwrap_or(false)
     }
 
     /// If the current user is a bot, does it have [privacy mode] enabled?
@@ -275,45 +232,45 @@ impl User {
     ///
     /// [privacy mode]: https://core.telegram.org/bots#privacy-mode
     pub fn bot_privacy(&self) -> bool {
-        !self.raw.bot_chat_history
+        self.user().map(|u| !u.bot_chat_history).unwrap_or(false)
     }
 
     /// If the current user is a bot, can it be added to groups?
     pub fn bot_supports_chats(self) -> bool {
-        self.raw.bot_nochats
+        self.user().map(|u| u.bot_nochats).unwrap_or(false)
     }
 
     /// Has the account of this user been verified?
     ///
     /// Verified accounts, such as [@BotFather](https://t.me/BotFather), have a special icon next
     /// to their names in official applications (commonly a blue starred checkmark).
     pub fn verified(&self) -> bool {
-        self.raw.verified
+        self.user().map(|u| u.verified).unwrap_or(false)
     }
 
     /// Does this user have restrictions applied to their account?
     pub fn restricted(&self) -> bool {
-        self.raw.restricted
+        self.user().map(|u| u.restricted).unwrap_or(false)
     }
 
     /// If the current user is a bot, does it want geolocation information on inline queries?
     pub fn bot_inline_geo(&self) -> bool {
-        self.raw.bot_inline_geo
+        self.user().map(|u| u.bot_inline_geo).unwrap_or(false)
     }
 
     /// Is this user an official member of the support team?
     pub fn support(&self) -> bool {
-        self.raw.support
+        self.user().map(|u| u.support).unwrap_or(false)
     }
 
     /// Has this user been flagged for trying to scam other people?
     pub fn scam(&self) -> bool {
-        self.raw.scam
+        self.user().map(|u| u.scam).unwrap_or(false)
     }
 
     /// The reason(s) why this user is restricted, could be empty.
     pub fn restriction_reason(&self) -> Vec<RestrictionReason> {
-        if let Some(reasons) = &self.raw.restriction_reason {
+        if let Some(reasons) = self.user().and_then(|u| u.restriction_reason.as_ref()) {
             reasons.iter().map(RestrictionReason::from_raw).collect()
         } else {
             Vec::new()
@@ -323,12 +280,13 @@ impl User {
     /// Return the placeholder for inline queries if the current user is a bot and has said
     /// placeholder configured.
     pub fn bot_inline_placeholder(&self) -> Option<&str> {
-        self.raw.bot_inline_placeholder.as_deref()
+        self.user()
+            .and_then(|u| u.bot_inline_placeholder.as_deref())
     }
 
     /// Language code of the user, if any.
     pub fn lang_code(&self) -> Option<&str> {
-        self.raw.lang_code.as_deref()
+        self.user().and_then(|u| u.lang_code.as_deref())
     }
 }