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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use serde::{Deserialize, Serialize};

use crate::{
    models::{Attachment, Category, Id, Server, SystemMessageChannels},
    Context, Result,
};

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

/// Specifies a field to remove on server update.
#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
pub enum ServerField {
    /// Server icon.
    Icon,
    /// Server banner.
    Banner,
    /// Server description.
    Description,
}

/// A server details were updated.
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct ServerUpdateEvent {
    /// Server id.
    #[serde(rename = "id")]
    pub server_id: Id,
    /// A partial server object.
    pub data: PartialServer,
    /// A specified field to remove on server update.
    pub clear: Option<ServerField>,
}

impl ServerUpdateEvent {
    /// Fetch the server.
    pub async fn server(&self, cx: &Context) -> Result<Server> {
        Server::fetch(cx, &self.server_id).await
    }
}

/// A partial server.
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct PartialServer {
    /// Server name.
    pub name: Option<String>,
    /// Server description.
    pub description: Option<String>,
    /// Server icon.
    pub icon: Option<Attachment>,
    /// Server banner.
    pub banner: Option<Attachment>,
    /// Server categories.
    #[serde(default)]
    pub categories: Vec<Category>,
    /// Server system message channels.
    pub system_messages: Option<SystemMessageChannels>,
    /// Whether server is not safe for work.
    pub nsfw: Option<bool>,
}

#[cfg(feature = "cache")]
#[async_trait::async_trait]
impl UpdateCache for ServerUpdateEvent {
    async fn update(&self, cx: &Context) {
        if let Some(server) = cx.cache.servers.write().await.get_mut(&self.server_id) {
            if let Some(field) = self.clear {
                match field {
                    ServerField::Icon => server.icon = None,
                    ServerField::Banner => server.banner = None,
                    ServerField::Description => server.description = None,
                }
            }

            if let Some(ref name) = self.data.name {
                server.name = name.clone();
            }

            if let Some(ref description) = self.data.description {
                server.description = Some(description.clone());
            }

            if let Some(ref icon) = self.data.icon {
                server.icon = Some(icon.clone());
            }

            if let Some(ref banner) = self.data.banner {
                server.banner = Some(banner.clone());
            }

            if !self.data.categories.is_empty() {
                server.categories = self.data.categories.clone();
            }

            if let Some(ref system_messages) = self.data.system_messages {
                server.system_messages = system_messages.clone();
            }

            if let Some(nsfw) = self.data.nsfw {
                server.nsfw = nsfw;
            }
        }
    }
}