revolt_database/models/servers/ops/
reference.rs

1use revolt_result::Result;
2
3use crate::ReferenceDb;
4use crate::{FieldsRole, FieldsServer, PartialRole, PartialServer, Role, Server};
5
6use super::AbstractServers;
7
8#[async_trait]
9impl AbstractServers for ReferenceDb {
10    /// Insert a new server into database
11    async fn insert_server(&self, server: &Server) -> Result<()> {
12        let mut servers = self.servers.lock().await;
13        if servers.contains_key(&server.id) {
14            Err(create_database_error!("insert", "server"))
15        } else {
16            servers.insert(server.id.to_string(), server.clone());
17            Ok(())
18        }
19    }
20
21    /// Fetch a server by its id
22    async fn fetch_server(&self, id: &str) -> Result<Server> {
23        let servers = self.servers.lock().await;
24        servers
25            .get(id)
26            .cloned()
27            .ok_or_else(|| create_error!(NotFound))
28    }
29
30    /// Fetch a servers by their ids
31    async fn fetch_servers<'a>(&self, ids: &'a [String]) -> Result<Vec<Server>> {
32        let servers = self.servers.lock().await;
33        ids.iter()
34            .map(|id| {
35                servers
36                    .get(id)
37                    .cloned()
38                    .ok_or_else(|| create_error!(NotFound))
39            })
40            .collect()
41    }
42
43    /// Update a server with new information
44    async fn update_server(
45        &self,
46        id: &str,
47        partial: &PartialServer,
48        remove: Vec<FieldsServer>,
49    ) -> Result<()> {
50        let mut servers = self.servers.lock().await;
51        if let Some(server) = servers.get_mut(id) {
52            for field in remove {
53                #[allow(clippy::disallowed_methods)]
54                server.remove_field(&field);
55            }
56
57            server.apply_options(partial.clone());
58            Ok(())
59        } else {
60            Err(create_error!(NotFound))
61        }
62    }
63
64    /// Delete a server by its id
65    async fn delete_server(&self, id: &str) -> Result<()> {
66        let mut servers = self.servers.lock().await;
67        if servers.remove(id).is_some() {
68            Ok(())
69        } else {
70            Err(create_error!(NotFound))
71        }
72    }
73
74    /// Insert a new role into server object
75    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()> {
76        let mut servers = self.servers.lock().await;
77        if let Some(server) = servers.get_mut(server_id) {
78            server.roles.insert(role.id.clone(), role.clone());
79            Ok(())
80        } else {
81            Err(create_error!(NotFound))
82        }
83    }
84
85    /// Update an existing role on a server
86    async fn update_role(
87        &self,
88        server_id: &str,
89        role_id: &str,
90        partial: &PartialRole,
91        remove: Vec<FieldsRole>,
92    ) -> Result<()> {
93        let mut servers = self.servers.lock().await;
94        if let Some(server) = servers.get_mut(server_id) {
95            if let Some(role) = server.roles.get_mut(role_id) {
96                for field in remove {
97                    #[allow(clippy::disallowed_methods)]
98                    role.remove_field(&field);
99                }
100
101                role.apply_options(partial.clone());
102                Ok(())
103            } else {
104                Err(create_error!(NotFound))
105            }
106        } else {
107            Err(create_error!(NotFound))
108        }
109    }
110
111    /// Delete a role from a server
112    ///
113    /// Also updates channels and members.
114    async fn delete_role(&self, server_id: &str, role_id: &str) -> Result<()> {
115        let mut servers = self.servers.lock().await;
116        if let Some(server) = servers.get_mut(server_id) {
117            if server.roles.remove(role_id).is_some() {
118                Ok(())
119            } else {
120                Err(create_error!(NotFound))
121            }
122        } else {
123            Err(create_error!(NotFound))
124        }
125    }
126}