1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use twilight_model::{
    gateway::presence::{Activity, ActivityFlags, ActivityType, Presence, Status},
    id::{
        marker::{ApplicationMarker, GuildMarker, UserMarker},
        Id,
    },
};

/// A cached activity
///
/// It is the same as [`twilight_model::gateway::presence::Activity`] except:
///
/// - `user_id` field is added, making it possible to return a user's activities
///
/// - `guild_id` field is added, making it possible to return the activities of
///   a guild's members
///
/// - `buttons` field is removed, as caching it is likely unnecessary, if you
///   need this field, please create an issue
///
/// - `assets`, `emoji`, `party` and `timestamps` fields are flattened, making
///   this struct easier to cache
///
/// - `secrets` field is removed, as it's not sent to bots
#[derive(Clone, Debug)]
pub struct CachedActivity {
    pub user_id: Id<UserMarker>,
    pub guild_id: Id<GuildMarker>,
    pub application_id: Option<Id<ApplicationMarker>>,
    pub asset_large_image: Option<String>,
    pub asset_large_text: Option<String>,
    pub asset_small_image: Option<String>,
    pub asset_small_text: Option<String>,
    pub created_at: Option<u64>,
    pub details: Option<String>,
    pub emoji_animated: Option<bool>,
    pub emoji_name: Option<String>,
    pub emoji_id: Option<String>,
    pub flags: Option<ActivityFlags>,
    pub id: Option<String>,
    pub instance: Option<bool>,
    pub kind: ActivityType,
    pub name: String,
    pub party_id: Option<String>,
    pub party_size_current: Option<u64>,
    pub party_size_max: Option<u64>,
    pub state: Option<String>,
    pub timestamp_end: Option<u64>,
    pub timestamp_start: Option<u64>,
    pub url: Option<String>,
}

impl CachedActivity {
    /// Create a cached activity from a given activity, user ID and guild ID
    #[must_use]
    pub fn from_activity(
        activity: &Activity,
        user_id: Id<UserMarker>,
        guild_id: Id<GuildMarker>,
    ) -> Self {
        Self {
            user_id,
            guild_id,
            application_id: activity.application_id,
            asset_large_image: activity
                .assets
                .as_ref()
                .and_then(|asset| asset.large_image.clone()),
            asset_large_text: activity
                .assets
                .as_ref()
                .and_then(|asset| asset.large_text.clone()),
            asset_small_image: activity
                .assets
                .as_ref()
                .and_then(|asset| asset.small_image.clone()),
            asset_small_text: activity
                .assets
                .as_ref()
                .and_then(|asset| asset.small_text.clone()),
            created_at: activity.created_at,
            details: activity.details.clone(),
            emoji_animated: activity.emoji.as_ref().and_then(|emoji| emoji.animated),
            emoji_name: activity.emoji.as_ref().map(|emoji| emoji.name.clone()),
            emoji_id: activity.emoji.as_ref().and_then(|emoji| emoji.id.clone()),
            flags: activity.flags,
            id: activity.id.clone(),
            instance: activity.instance,
            kind: activity.kind,
            name: activity.name.clone(),
            party_id: activity.party.as_ref().and_then(|party| party.id.clone()),
            party_size_current: activity
                .party
                .as_ref()
                .and_then(|party| party.size.map(|size| size[0])),
            party_size_max: activity
                .party
                .as_ref()
                .and_then(|party| party.size.map(|size| size[1])),
            state: activity.state.clone(),
            timestamp_end: activity
                .timestamps
                .as_ref()
                .and_then(|timestamp| timestamp.end),
            timestamp_start: activity
                .timestamps
                .as_ref()
                .and_then(|timestamp| timestamp.start),
            url: activity.url.clone(),
        }
    }
}

/// A cached presence
///
/// It's the same as [`twilight_model::gateway::presence::Presence`] except:
///
/// - `user` field is changed to a user ID, since users are cached separately
///
/// - `client_status` field is removed, as caching it is likely unnecessary, if
///   you need this field, please create an issue
///
/// - `activities` field is removed, since they're cached separately
#[derive(Clone, Copy, Debug)]
pub struct CachedPresence {
    pub guild_id: Id<GuildMarker>,
    pub status: Status,
    pub user: Id<UserMarker>,
}

impl From<&Presence> for CachedPresence {
    fn from(presence: &Presence) -> Self {
        Self {
            guild_id: presence.guild_id,
            status: presence.status,
            user: presence.user.id(),
        }
    }
}