robespierre_http/
server_members.rs

1use robespierre_models::{
2    autumn::Attachment,
3    id::{ServerId, UserId},
4    servers::{Ban, Member, MemberField, PartialMember},
5    users::User,
6};
7
8use super::impl_prelude::*;
9
10impl Http {
11    /// Fetches member in server
12    pub async fn fetch_member(&self, server_id: ServerId, user_id: UserId) -> Result<Member> {
13        Ok(self
14            .client
15            .get(ep!(self, "/servers/{}/members/{}" server_id, user_id))
16            .send()
17            .await?
18            .error_for_status()?
19            .json()
20            .await?)
21    }
22
23    /// Edits member in server
24    pub async fn edit_member(
25        &self,
26        server_id: ServerId,
27        user_id: UserId,
28        member: PartialMember,
29        remove: MemberField,
30    ) -> Result {
31        #[derive(serde::Serialize)]
32        struct PatchMemberRequest {
33            #[serde(flatten)]
34            member: PartialMember,
35            remove: MemberField,
36        }
37        self.client
38            .patch(ep!(self, "/servers/{}/members/{}" server_id, user_id))
39            .json(&PatchMemberRequest { member, remove })
40            .send()
41            .await?
42            .error_for_status()?;
43        Ok(())
44    }
45
46    /// Kicks member out of server
47    pub async fn kick_member(&self, server_id: ServerId, user_id: UserId) -> Result {
48        self.client
49            .delete(ep!(self, "/servers/{}/members/{}" server_id, user_id))
50            .send()
51            .await?
52            .error_for_status()?;
53
54        Ok(())
55    }
56
57    /// Fetches all members in a server
58    pub async fn fetch_all_members(&self, server_id: ServerId) -> Result<FetchMembersResult> {
59        Ok(self
60            .client
61            .get(ep!(self, "/servers/{}/members" server_id))
62            .send()
63            .await?
64            .error_for_status()?
65            .json()
66            .await?)
67    }
68
69    /// Bans an user from the server
70    pub async fn ban_user(
71        &self,
72        server_id: ServerId,
73        user_id: UserId,
74        reason: Option<&str>,
75    ) -> Result {
76        #[derive(serde::Serialize)]
77        struct BanRequest<'a> {
78            #[serde(skip_serializing_if = "Option::is_none")]
79            reason: Option<&'a str>,
80        }
81        self.client
82            .put(ep!(self, "/servers/{}/bans/{}" server_id, user_id))
83            .json(&BanRequest { reason })
84            .send()
85            .await?
86            .error_for_status()?;
87
88        Ok(())
89    }
90
91    /// Unbans an user from the server
92    pub async fn unban_user(&self, server_id: ServerId, user_id: UserId) -> Result {
93        self.client
94            .delete(ep!(self, "/servers/{}/bans/{}" server_id, user_id))
95            .send()
96            .await?
97            .error_for_status()?;
98
99        Ok(())
100    }
101
102    /// Fetches all the users who are banned and the reasons associated with their bans if available
103    pub async fn fetch_bans(&self, server_id: ServerId) -> Result<FetchBansResult> {
104        Ok(self
105            .client
106            .get(ep!(self, "/servers/{}/bans" server_id))
107            .send()
108            .await?
109            .error_for_status()?
110            .json()
111            .await?)
112    }
113}
114
115/// Result when fetching members
116#[derive(serde::Deserialize)]
117pub struct FetchMembersResult {
118    pub users: Vec<User>,
119    pub members: Vec<Member>,
120}
121
122/// Result when fetching bans
123#[derive(serde::Deserialize)]
124pub struct FetchBansResult {
125    pub users: Vec<FetchBansUser>,
126    pub bans: Vec<Ban>,
127}
128
129#[derive(serde::Deserialize)]
130pub struct FetchBansUser {
131    #[serde(rename = "_id")]
132    pub id: UserId,
133    pub username: String,
134    #[serde(default)]
135    pub avatar: Option<Attachment>,
136}