Skip to main content

twilight_model/guild/
member.rs

1//! Mostly internal custom serde deserializers.
2
3use super::MemberFlags;
4use crate::{
5    id::{Id, marker::RoleMarker},
6    user::User,
7    util::{ImageHash, Timestamp},
8};
9
10use crate::user::AvatarDecorationData;
11use serde::{Deserialize, Serialize};
12
13/// [`User`] that is in a [`Guild`].
14///
15/// [`Guild`]: super::Guild
16#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
17pub struct Member {
18    /// Member's guild avatar.
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub avatar: Option<ImageHash>,
21    /// Member's avatar decoration data.
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub avatar_decoration_data: Option<AvatarDecorationData>,
24    /// Member's guild banner.
25    #[serde(skip_serializing_if = "Option::is_none")]
26    pub banner: Option<ImageHash>,
27    pub communication_disabled_until: Option<Timestamp>,
28    pub deaf: bool,
29    /// Flags for the member.
30    ///
31    /// Defaults to an empty bitfield.
32    pub flags: MemberFlags,
33    pub joined_at: Option<Timestamp>,
34    pub mute: bool,
35    pub nick: Option<String>,
36    /// Whether the user has yet to pass the guild's [Membership Screening]
37    /// requirements.
38    #[serde(default)]
39    pub pending: bool,
40    #[serde(skip_serializing_if = "Option::is_none")]
41    pub premium_since: Option<Timestamp>,
42    pub roles: Vec<Id<RoleMarker>>,
43    pub user: User,
44}
45
46#[cfg(test)]
47mod tests {
48    use super::Member;
49    use crate::{
50        guild::MemberFlags,
51        id::Id,
52        test::image_hash,
53        user::User,
54        util::datetime::{Timestamp, TimestampParseError},
55    };
56    use serde_test::Token;
57    use std::str::FromStr;
58
59    #[test]
60    #[allow(clippy::too_many_lines)]
61    fn member_deserializer() -> Result<(), TimestampParseError> {
62        let joined_at = Some(Timestamp::from_str("2015-04-26T06:26:56.936000+00:00")?);
63        let premium_since = Timestamp::from_str("2021-03-16T14:29:19.046000+00:00")?;
64        let flags = MemberFlags::BYPASSES_VERIFICATION | MemberFlags::DID_REJOIN;
65
66        let value = Member {
67            avatar: Some(image_hash::AVATAR),
68            avatar_decoration_data: None,
69            banner: Some(image_hash::BANNER),
70            communication_disabled_until: None,
71            deaf: false,
72            flags,
73            joined_at,
74            mute: true,
75            nick: Some("twilight".to_owned()),
76            pending: false,
77            premium_since: Some(premium_since),
78            roles: Vec::new(),
79            user: User {
80                accent_color: None,
81                avatar: None,
82                avatar_decoration: None,
83                avatar_decoration_data: None,
84                banner: None,
85                bot: false,
86                discriminator: 1,
87                email: None,
88                flags: None,
89                global_name: Some("test".to_owned()),
90                id: Id::new(3),
91                locale: None,
92                mfa_enabled: None,
93                name: "twilight".to_owned(),
94                premium_type: None,
95                primary_guild: None,
96                public_flags: None,
97                system: None,
98                verified: None,
99            },
100        };
101
102        serde_test::assert_tokens(
103            &value,
104            &[
105                Token::Struct {
106                    name: "Member",
107                    len: 12,
108                },
109                Token::Str("avatar"),
110                Token::Some,
111                Token::Str(image_hash::AVATAR_INPUT),
112                Token::Str("banner"),
113                Token::Some,
114                Token::Str(image_hash::BANNER_INPUT),
115                Token::Str("communication_disabled_until"),
116                Token::None,
117                Token::Str("deaf"),
118                Token::Bool(false),
119                Token::Str("flags"),
120                Token::U64(flags.bits()),
121                Token::Str("joined_at"),
122                Token::Some,
123                Token::Str("2015-04-26T06:26:56.936000+00:00"),
124                Token::Str("mute"),
125                Token::Bool(true),
126                Token::Str("nick"),
127                Token::Some,
128                Token::Str("twilight"),
129                Token::Str("pending"),
130                Token::Bool(false),
131                Token::Str("premium_since"),
132                Token::Some,
133                Token::Str("2021-03-16T14:29:19.046000+00:00"),
134                Token::Str("roles"),
135                Token::Seq { len: Some(0) },
136                Token::SeqEnd,
137                Token::Str("user"),
138                Token::Struct {
139                    name: "User",
140                    len: 10,
141                },
142                Token::Str("accent_color"),
143                Token::None,
144                Token::Str("avatar"),
145                Token::None,
146                Token::Str("avatar_decoration"),
147                Token::None,
148                Token::Str("avatar_decoration_data"),
149                Token::None,
150                Token::Str("banner"),
151                Token::None,
152                Token::Str("bot"),
153                Token::Bool(false),
154                Token::Str("discriminator"),
155                Token::Str("0001"),
156                Token::Str("global_name"),
157                Token::Some,
158                Token::Str("test"),
159                Token::Str("id"),
160                Token::NewtypeStruct { name: "Id" },
161                Token::Str("3"),
162                Token::Str("username"),
163                Token::Str("twilight"),
164                Token::StructEnd,
165                Token::StructEnd,
166            ],
167        );
168
169        Ok(())
170    }
171
172    #[test]
173    #[allow(clippy::too_many_lines)]
174    fn guild_member_communication_disabled_until() -> Result<(), TimestampParseError> {
175        let communication_disabled_until = Timestamp::from_str("2021-12-23T14:29:19.046000+00:00")?;
176        let joined_at = Some(Timestamp::from_str("2015-04-26T06:26:56.936000+00:00")?);
177        let premium_since = Timestamp::from_str("2021-03-16T14:29:19.046000+00:00")?;
178        let flags = MemberFlags::BYPASSES_VERIFICATION | MemberFlags::DID_REJOIN;
179
180        let value = Member {
181            avatar: Some(image_hash::AVATAR),
182            avatar_decoration_data: None,
183            banner: Some(image_hash::BANNER),
184            communication_disabled_until: Some(communication_disabled_until),
185            deaf: false,
186            flags,
187            joined_at,
188            mute: true,
189            nick: Some("twilight".to_owned()),
190            pending: false,
191            premium_since: Some(premium_since),
192            roles: Vec::new(),
193            user: User {
194                accent_color: None,
195                avatar: None,
196                avatar_decoration: None,
197                avatar_decoration_data: None,
198                banner: None,
199                bot: false,
200                discriminator: 1,
201                email: None,
202                flags: None,
203                global_name: Some("test".to_owned()),
204                id: Id::new(3),
205                locale: None,
206                mfa_enabled: None,
207                name: "twilight".to_owned(),
208                premium_type: None,
209                primary_guild: None,
210                public_flags: None,
211                system: None,
212                verified: None,
213            },
214        };
215
216        serde_test::assert_tokens(
217            &value,
218            &[
219                Token::Struct {
220                    name: "Member",
221                    len: 12,
222                },
223                Token::Str("avatar"),
224                Token::Some,
225                Token::Str(image_hash::AVATAR_INPUT),
226                Token::Str("banner"),
227                Token::Some,
228                Token::Str(image_hash::BANNER_INPUT),
229                Token::Str("communication_disabled_until"),
230                Token::Some,
231                Token::Str("2021-12-23T14:29:19.046000+00:00"),
232                Token::Str("deaf"),
233                Token::Bool(false),
234                Token::Str("flags"),
235                Token::U64(flags.bits()),
236                Token::Str("joined_at"),
237                Token::Some,
238                Token::Str("2015-04-26T06:26:56.936000+00:00"),
239                Token::Str("mute"),
240                Token::Bool(true),
241                Token::Str("nick"),
242                Token::Some,
243                Token::Str("twilight"),
244                Token::Str("pending"),
245                Token::Bool(false),
246                Token::Str("premium_since"),
247                Token::Some,
248                Token::Str("2021-03-16T14:29:19.046000+00:00"),
249                Token::Str("roles"),
250                Token::Seq { len: Some(0) },
251                Token::SeqEnd,
252                Token::Str("user"),
253                Token::Struct {
254                    name: "User",
255                    len: 10,
256                },
257                Token::Str("accent_color"),
258                Token::None,
259                Token::Str("avatar"),
260                Token::None,
261                Token::Str("avatar_decoration"),
262                Token::None,
263                Token::Str("avatar_decoration_data"),
264                Token::None,
265                Token::Str("banner"),
266                Token::None,
267                Token::Str("bot"),
268                Token::Bool(false),
269                Token::Str("discriminator"),
270                Token::Str("0001"),
271                Token::Str("global_name"),
272                Token::Some,
273                Token::Str("test"),
274                Token::Str("id"),
275                Token::NewtypeStruct { name: "Id" },
276                Token::Str("3"),
277                Token::Str("username"),
278                Token::Str("twilight"),
279                Token::StructEnd,
280                Token::StructEnd,
281            ],
282        );
283
284        Ok(())
285    }
286}