twilight_http/request/guild/member/
add_guild_member.rs1use crate::{
2 client::Client,
3 error::Error,
4 request::{Request, TryIntoRequest},
5 response::{Response, ResponseFuture},
6 routing::Route,
7};
8use serde::Serialize;
9use std::future::IntoFuture;
10use twilight_model::{
11 guild::PartialMember,
12 id::{
13 marker::{GuildMarker, RoleMarker, UserMarker},
14 Id,
15 },
16};
17use twilight_validate::request::{nickname as validate_nickname, ValidationError};
18
19#[derive(Serialize)]
20struct AddGuildMemberFields<'a> {
21 pub access_token: &'a str,
22 #[serde(skip_serializing_if = "Option::is_none")]
23 pub deaf: Option<bool>,
24 #[serde(skip_serializing_if = "Option::is_none")]
25 pub mute: Option<bool>,
26 #[serde(skip_serializing_if = "Option::is_none")]
27 pub nick: Option<&'a str>,
28 #[serde(skip_serializing_if = "Option::is_none")]
29 pub roles: Option<&'a [Id<RoleMarker>]>,
30}
31
32#[must_use = "requests must be configured and executed"]
33pub struct AddGuildMember<'a> {
34 fields: Result<AddGuildMemberFields<'a>, ValidationError>,
35 guild_id: Id<GuildMarker>,
36 http: &'a Client,
37 user_id: Id<UserMarker>,
38}
39
40impl<'a> AddGuildMember<'a> {
47 pub(crate) const fn new(
48 http: &'a Client,
49 guild_id: Id<GuildMarker>,
50 user_id: Id<UserMarker>,
51 access_token: &'a str,
52 ) -> Self {
53 Self {
54 fields: Ok(AddGuildMemberFields {
55 access_token,
56 deaf: None,
57 mute: None,
58 nick: None,
59 roles: None,
60 }),
61 guild_id,
62 http,
63 user_id,
64 }
65 }
66
67 pub fn deaf(mut self, deaf: bool) -> Self {
70 if let Ok(fields) = self.fields.as_mut() {
71 fields.deaf = Some(deaf);
72 }
73
74 self
75 }
76
77 pub fn mute(mut self, mute: bool) -> Self {
79 if let Ok(fields) = self.fields.as_mut() {
80 fields.mute = Some(mute);
81 }
82
83 self
84 }
85
86 pub fn nick(mut self, nick: &'a str) -> Self {
98 self.fields = self.fields.and_then(|mut fields| {
99 validate_nickname(nick)?;
100
101 fields.nick.replace(nick);
102
103 Ok(fields)
104 });
105
106 self
107 }
108
109 pub fn roles(mut self, roles: &'a [Id<RoleMarker>]) -> Self {
111 if let Ok(fields) = self.fields.as_mut() {
112 fields.roles = Some(roles);
113 }
114
115 self
116 }
117}
118
119impl IntoFuture for AddGuildMember<'_> {
120 type Output = Result<Response<PartialMember>, Error>;
121
122 type IntoFuture = ResponseFuture<PartialMember>;
123
124 fn into_future(self) -> Self::IntoFuture {
125 let http = self.http;
126
127 match self.try_into_request() {
128 Ok(request) => http.request(request),
129 Err(source) => ResponseFuture::error(source),
130 }
131 }
132}
133
134impl TryIntoRequest for AddGuildMember<'_> {
135 fn try_into_request(self) -> Result<Request, Error> {
136 let fields = self.fields.map_err(Error::validation)?;
137
138 Request::builder(&Route::AddGuildMember {
139 guild_id: self.guild_id.get(),
140 user_id: self.user_id.get(),
141 })
142 .json(&fields)
143 .build()
144 }
145}