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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
use crate::internal::prelude::*;
use crate::model::prelude::*;
use std::collections::HashMap;
/// A builder to optionally edit certain fields of a [`Guild`]. This is meant
/// for usage with [`Guild::edit`].
///
/// **Note**: Editing a guild requires that the current user have the
/// [Manage Guild] permission.
///
/// [`Guild::edit`]: ../model/guild/struct.Guild.html#method.edit
/// [`Guild`]: ../model/guild/struct.Guild.html
/// [Manage Guild]: ../model/permissions/struct.Permissions.html#associatedconstant.MANAGE_GUILD
#[derive(Clone, Debug, Default)]
pub struct EditGuild(pub HashMap<&'static str, Value>);
impl EditGuild {
/// Set the "AFK voice channel" that users are to move to if they have been
/// AFK for an amount of time, configurable by [`afk_timeout`].
///
/// The given channel must be either some valid voice channel, or `None` to
/// not set an AFK channel. The library does not check if a channel is
/// valid.
///
/// [`afk_timeout`]: #method.afk_timeout
#[inline]
pub fn afk_channel<C: Into<ChannelId>>(&mut self, channel: Option<C>) -> &mut Self {
self._afk_channel(channel.map(Into::into));
self
}
fn _afk_channel(&mut self, channel: Option<ChannelId>) {
self.0.insert(
"afk_channel_id",
match channel {
Some(channel) => Value::Number(Number::from(channel.0)),
None => Value::Null,
},
);
}
/// Set the amount of time a user is to be moved to the AFK channel -
/// configured via [`afk_channel`] - after being AFK.
///
/// [`afk_channel`]: #method.afk_channel
pub fn afk_timeout(&mut self, timeout: u64) -> &mut Self {
self.0.insert(
"afk_timeout",
Value::Number(Number::from(timeout)),
);
self
}
/// Set the icon of the guild. Pass `None` to remove the icon.
///
/// # Examples
///
/// Using the utility function - [`utils::read_image`] - to read an image
/// from the cwd and encode it in base64 to send to Discord.
///
/// ```rust,no_run
/// # use serenity::{http::Http, model::id::GuildId};
/// #
/// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
/// # let http = Http::default();
/// # let mut guild = GuildId(0).to_partial_guild(&http).await?;
/// use serenity::utils;
///
/// // assuming a `guild` has already been bound
///
/// let base64_icon = utils::read_image("./guild_icon.png")?;
///
/// guild.edit(&http, |mut g| {
/// g.icon(Some(&base64_icon))
/// })
/// .await?;
/// # Ok(())
/// # }
/// ```
///
/// [`utils::read_image`]: ../utils/fn.read_image.html
pub fn icon(&mut self, icon: Option<&str>) -> &mut Self {
self.0.insert(
"icon",
icon.map_or_else(|| Value::Null, |x| Value::String(x.to_string())),
);
self
}
/// Set the name of the guild.
///
/// **Note**: Must be between (and including) 2-100 chracters.
pub fn name<S: ToString>(&mut self, name: S) -> &mut Self {
self.0.insert("name", Value::String(name.to_string()));
self
}
/// Transfers the ownership of the guild to another user by Id.
///
/// **Note**: The current user must be the owner of the guild.
#[inline]
pub fn owner<U: Into<UserId>>(&mut self, user_id: U) -> &mut Self {
self._owner(user_id.into());
self
}
fn _owner(&mut self, user_id: UserId) {
let id = Value::Number(Number::from(user_id.0));
self.0.insert("owner_id", id);
}
/// Set the voice region of the server.
///
/// # Examples
///
/// Setting the region to [`Region::UsWest`]:
///
/// ```rust,no_run
/// # use serenity::{http::Http, model::id::GuildId};
/// #
/// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
/// # let http = Http::default();
/// # let mut guild = GuildId(0).to_partial_guild(&http).await?;
/// use serenity::model::guild::Region;
///
/// // assuming a `guild` has already been bound
///
/// guild.edit(&http, |g| {
/// g.region(Region::UsWest)
/// })
/// .await?;
/// # Ok(())
/// # }
/// ```
///
/// [`Region::UsWest`]: ../model/guild/enum.Region.html#variant.UsWest
pub fn region(&mut self, region: Region) -> &mut Self {
self.0.insert("region", Value::String(region.name().to_string()));
self
}
/// Set the splash image of the guild on the invitation page.
///
/// Requires that the guild have the `INVITE_SPLASH` feature enabled.
/// You can check this through a guild's [`features`] list.
///
/// [`features`]: ../model/guild/struct.Guild.html#structfield.features
pub fn splash(&mut self, splash: Option<&str>) -> &mut Self {
let splash = splash.map_or(Value::Null, |x| Value::String(x.to_string()));
self.0.insert("splash", splash);
self
}
/// Set the verification level of the guild. This can restrict what a
/// user must have prior to being able to send messages in a guild.
///
/// Refer to the documentation for [`VerificationLevel`] for more
/// information on each variant.
///
///
/// # Examples
///
/// Setting the verification level to [`High`][`VerificationLevel::High`]:
///
/// ```rust,no_run
/// # use serenity::{http::Http, model::id::GuildId};
/// #
/// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
/// # let http = Http::default();
/// # let mut guild = GuildId(0).to_partial_guild(&http).await?;
/// use serenity::model::guild::VerificationLevel;
///
/// // assuming a `guild` has already been bound
///
/// let edit = guild.edit(&http, |g| {
/// g.verification_level(VerificationLevel::High)
/// })
/// .await;
///
/// if let Err(why) = edit {
/// println!("Error setting verification level: {:?}", why);
/// }
/// # Ok(())
/// # }
/// ```
/// [`VerificationLevel`]: ../model/guild/enum.VerificationLevel.html
/// [`VerificationLevel::High`]: ../model/guild/enum.VerificationLevel.html#variant.High
#[inline]
pub fn verification_level<V>(&mut self, verification_level: V) -> &mut Self
where V: Into<VerificationLevel> {
self._verification_level(verification_level.into());
self
}
fn _verification_level(&mut self, verification_level: VerificationLevel) {
let num = Value::Number(Number::from(verification_level.num()));
self.0.insert("verification_level", num);
}
}