twilight_model/gateway/presence/
mod.rs

1pub mod activity_button;
2
3mod activity;
4mod activity_assets;
5mod activity_emoji;
6mod activity_flags;
7mod activity_party;
8mod activity_secrets;
9mod activity_status_display_type;
10mod activity_timestamps;
11mod activity_type;
12mod client_status;
13mod minimal_activity;
14mod status;
15
16pub use self::{
17    activity::Activity, activity_assets::ActivityAssets, activity_button::ActivityButton,
18    activity_emoji::ActivityEmoji, activity_flags::ActivityFlags, activity_party::ActivityParty,
19    activity_secrets::ActivitySecrets, activity_status_display_type::ActivityStatusDisplayType,
20    activity_timestamps::ActivityTimestamps, activity_type::ActivityType,
21    client_status::ClientStatus, minimal_activity::MinimalActivity, status::Status,
22};
23
24use crate::{
25    id::{
26        Id,
27        marker::{GuildMarker, UserMarker},
28    },
29    user::User,
30};
31use serde::{
32    Deserialize, Serialize,
33    de::{
34        DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor, value::MapAccessDeserializer,
35    },
36};
37use std::fmt::{Formatter, Result as FmtResult};
38
39#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
40pub struct Presence {
41    #[serde(default)]
42    pub activities: Vec<Activity>,
43    pub client_status: ClientStatus,
44    pub guild_id: Id<GuildMarker>,
45    pub status: Status,
46    pub user: UserOrId,
47}
48
49#[allow(clippy::large_enum_variant)]
50#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
51#[serde(untagged)]
52pub enum UserOrId {
53    User(User),
54    UserId { id: Id<UserMarker> },
55}
56
57impl UserOrId {
58    /// ID of the inner object.
59    pub const fn id(&self) -> Id<UserMarker> {
60        match self {
61            UserOrId::User(u) => u.id,
62            UserOrId::UserId { id } => *id,
63        }
64    }
65}
66
67#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq)]
68pub(crate) struct PresenceIntermediary {
69    #[serde(default)]
70    pub activities: Vec<Activity>,
71    pub client_status: ClientStatus,
72    pub guild_id: Option<Id<GuildMarker>>,
73    pub nick: Option<String>,
74    pub status: Status,
75    pub user: UserOrId,
76}
77
78impl PresenceIntermediary {
79    /// Inject guild ID into presence if not already present.
80    pub fn into_presence(self, guild_id: Id<GuildMarker>) -> Presence {
81        Presence {
82            activities: self.activities,
83            client_status: self.client_status,
84            guild_id: self.guild_id.unwrap_or(guild_id),
85            status: self.status,
86            user: self.user,
87        }
88    }
89}
90
91struct PresenceVisitor(Id<GuildMarker>);
92
93impl<'de> Visitor<'de> for PresenceVisitor {
94    type Value = Presence;
95
96    fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
97        f.write_str("Presence struct")
98    }
99
100    fn visit_map<M: MapAccess<'de>>(self, map: M) -> Result<Self::Value, M::Error> {
101        let deser = MapAccessDeserializer::new(map);
102        let presence = PresenceIntermediary::deserialize(deser)?;
103
104        Ok(Presence {
105            activities: presence.activities,
106            client_status: presence.client_status,
107            guild_id: presence.guild_id.unwrap_or(self.0),
108            status: presence.status,
109            user: presence.user,
110        })
111    }
112}
113
114#[derive(Clone, Debug, Eq, PartialEq)]
115pub struct PresenceDeserializer(Id<GuildMarker>);
116
117impl PresenceDeserializer {
118    /// Create a new deserializer for a presence when you know the guild ID but
119    /// the payload probably doesn't contain it.
120    pub const fn new(guild_id: Id<GuildMarker>) -> Self {
121        Self(guild_id)
122    }
123}
124
125impl<'de> DeserializeSeed<'de> for PresenceDeserializer {
126    type Value = Presence;
127
128    fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
129        deserializer.deserialize_map(PresenceVisitor(self.0))
130    }
131}
132
133#[derive(Clone, Debug, Eq, PartialEq)]
134pub struct PresenceListDeserializer(Id<GuildMarker>);
135
136impl PresenceListDeserializer {
137    /// Create a new deserializer for a map of presences when you know the
138    /// Guild ID but the payload probably doesn't contain it.
139    pub const fn new(guild_id: Id<GuildMarker>) -> Self {
140        Self(guild_id)
141    }
142}
143
144struct PresenceListDeserializerVisitor(Id<GuildMarker>);
145
146impl<'de> Visitor<'de> for PresenceListDeserializerVisitor {
147    type Value = Vec<Presence>;
148
149    fn expecting(&self, f: &mut Formatter<'_>) -> FmtResult {
150        f.write_str("a sequence of presences")
151    }
152
153    fn visit_seq<S: SeqAccess<'de>>(self, mut seq: S) -> Result<Self::Value, S::Error> {
154        let mut list = seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);
155
156        while let Some(presence) = seq.next_element_seed(PresenceDeserializer(self.0))? {
157            list.push(presence);
158        }
159
160        Ok(list)
161    }
162}
163
164impl<'de> DeserializeSeed<'de> for PresenceListDeserializer {
165    type Value = Vec<Presence>;
166
167    fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
168        deserializer.deserialize_any(PresenceListDeserializerVisitor(self.0))
169    }
170}
171
172#[cfg(test)]
173mod tests {
174    use super::{
175        Activity, ActivityEmoji, ActivityType, ClientStatus, Presence, PresenceListDeserializer,
176        Status, UserOrId,
177    };
178    use crate::id::Id;
179    use serde::de::DeserializeSeed;
180    use serde_json::Deserializer;
181    use serde_test::Token;
182
183    #[test]
184    #[allow(clippy::too_many_lines)]
185    fn custom() {
186        let activity = Activity {
187            application_id: None,
188            assets: None,
189            buttons: Vec::new(),
190            created_at: Some(1_571_048_061_237),
191            details: None,
192            flags: None,
193            id: Some("aaaaaaaaaaaaaaaa".to_owned()),
194            instance: None,
195            kind: ActivityType::Custom,
196            name: "foo".to_owned(),
197            emoji: Some(ActivityEmoji {
198                name: "Test".to_string(),
199                id: None,
200                animated: None,
201            }),
202            party: None,
203            secrets: None,
204            state: None,
205            timestamps: None,
206            url: None,
207            details_url: None,
208            state_url: None,
209            status_display_type: None,
210        };
211        let value = Presence {
212            activities: vec![activity],
213            client_status: ClientStatus {
214                desktop: Some(Status::Online),
215                mobile: None,
216                web: None,
217                vr: None,
218            },
219            guild_id: Id::new(2),
220            status: Status::Online,
221            user: UserOrId::UserId { id: Id::new(1) },
222        };
223
224        serde_test::assert_de_tokens(
225            &value,
226            &[
227                Token::Struct {
228                    name: "Presence",
229                    len: 4,
230                },
231                Token::Str("user"),
232                Token::Struct {
233                    name: "UserOrId",
234                    len: 1,
235                },
236                Token::Str("id"),
237                Token::Str("1"),
238                Token::StructEnd,
239                Token::Str("guild_id"),
240                Token::NewtypeStruct { name: "Id" },
241                Token::Str("2"),
242                Token::Str("status"),
243                Token::Enum { name: "Status" },
244                Token::Str("online"),
245                Token::Unit,
246                Token::Str("client_status"),
247                Token::Struct {
248                    name: "ClientStatus",
249                    len: 3,
250                },
251                Token::Str("desktop"),
252                Token::Some,
253                Token::Enum { name: "Status" },
254                Token::Str("online"),
255                Token::Unit,
256                Token::Str("mobile"),
257                Token::None,
258                Token::Str("web"),
259                Token::None,
260                Token::StructEnd,
261                Token::Str("activities"),
262                Token::Seq { len: Some(1) },
263                Token::Struct {
264                    name: "Activity",
265                    len: 4,
266                },
267                Token::Str("type"),
268                Token::U8(4),
269                Token::Str("name"),
270                Token::Str("foo"),
271                Token::Str("emoji"),
272                Token::Some,
273                Token::Struct {
274                    name: "ActivityEmoji",
275                    len: 3,
276                },
277                Token::Str("name"),
278                Token::Str("Test"),
279                Token::Str("id"),
280                Token::None,
281                Token::Str("animated"),
282                Token::None,
283                Token::StructEnd,
284                Token::Str("id"),
285                Token::Some,
286                Token::Str("aaaaaaaaaaaaaaaa"),
287                Token::Str("created_at"),
288                Token::Some,
289                Token::U64(1_571_048_061_237),
290                Token::StructEnd,
291                Token::SeqEnd,
292                Token::StructEnd,
293            ],
294        );
295    }
296
297    // Test that presences through the deserializer are given a default guild ID
298    // if they have none.
299    //
300    // Can't test seeded deserializers with serde_test.
301    #[test]
302    fn presence_map_guild_id_default() {
303        let input = r#"[{
304            "user": {
305                "id": "1"
306            },
307            "status": "online",
308            "client_status": {
309                "desktop": "online"
310            },
311            "activities": []
312        }]"#;
313
314        let expected = Vec::from([Presence {
315            activities: vec![],
316            client_status: ClientStatus {
317                desktop: Some(Status::Online),
318                mobile: None,
319                web: None,
320                vr: None,
321            },
322            guild_id: Id::new(2),
323            status: Status::Online,
324            user: UserOrId::UserId { id: Id::new(1) },
325        }]);
326
327        let mut json_deserializer = Deserializer::from_str(input);
328        let deserializer = PresenceListDeserializer::new(Id::new(2));
329        let actual = deserializer.deserialize(&mut json_deserializer).unwrap();
330
331        assert_eq!(actual, expected);
332    }
333}
twilight_model/gateway/presence/mod.rs

twilight_model/gateway/presence/
mod.rs
