ruvolt 0.5.0

An API wrapper for Revolt written in Rust.
Documentation 
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

use serde::{Deserialize, Serialize};

use crate::{
    models::{Attachment, Id, User, UserProfile, UserStatus},
    Context, Result,
};

#[cfg(feature = "cache")]
use crate::cache::UpdateCache;

/// Specifies a field to remove on user update.
#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
pub enum UserField {
    /// User profile content.
    ProfileContent,
    /// User profile background.
    ProfileBackground,
    /// User status text.
    StatusText,
    /// User avatar.
    Avatar,
}

/// A user has been updated.
#[derive(Debug, Deserialize, Clone, PartialEq)]
pub struct UserUpdateEvent {
    /// User id.
    #[serde(rename = "id")]
    pub user_id: Id,
    /// A partial user.
    pub data: PartialUser,
    /// A specified field to remove on user update.
    pub clear: Option<UserField>,
}

impl UserUpdateEvent {
    /// Fetch the user.
    pub async fn user(&self, cx: &Context) -> Result<User> {
        User::fetch(cx, &self.user_id).await
    }
}

/// A partial user
#[derive(Debug, Deserialize, Clone, PartialEq)]
pub struct PartialUser {
    /// User status.
    pub status: Option<UserStatus>,
    /// User profile.
    pub profile: Option<UserProfile>,
    /// User avatar.
    pub avatar: Option<Attachment>,
    /// Whether the user is online.
    pub online: Option<bool>,
}

#[cfg(feature = "cache")]
#[async_trait::async_trait]
impl UpdateCache for UserUpdateEvent {
    async fn update(&self, cx: &Context) {
        if let Some(user) = cx.cache.users.write().await.get_mut(&self.user_id) {
            if let Some(field) = self.clear {
                match field {
                    UserField::StatusText => {
                        if let Some(ref mut status) = user.status {
                            status.text = None;
                        }
                    }
                    UserField::Avatar => user.avatar = None,
                    _ => {}
                }
            }

            if let Some(ref status) = self.data.status {
                user.status = Some(status.clone());
            }

            if let Some(ref avatar) = self.data.avatar {
                user.avatar = Some(avatar.clone());
            }

            if let Some(online) = self.data.online {
                user.online = online;
            }
        }
    }
}