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

use crate::api;
use std::borrow::Cow;

pub struct MessageBuilder {
	msg: api::MessageCreate,
}

impl MessageBuilder {
	pub fn new() -> MessageBuilder {
		MessageBuilder {
			msg: Default::default(),
		}
	}

	pub fn content(&mut self, content: Cow<str>) -> &mut Self {
		self.msg.content = content.into_owned();
		self
	}

	pub fn nonce(&mut self, nonce: Cow<str>) -> &mut Self {
		self.msg.nonce = Some(nonce.into_owned());
		self
	}

	pub fn tts(&mut self, tts: bool) -> &mut Self {
		self.msg.tts = Some(tts);
		self
	}

	pub fn mention_nobody(&mut self) -> &mut Self {
		self.msg.allowed_mentions = Some(api::AllowedMentions::nobody());
		self
	}

	pub fn mention_parsed(&mut self) -> &mut Self {
		self.msg.allowed_mentions = Some(api::AllowedMentions::parse_any());
		self
	}

	pub fn allow_mention_parse(&mut self, ty: api::AllowedMentionTypes) -> &mut Self {
		let am = self.msg.allowed_mentions.get_or_insert_with(Default::default);
		let parse = am.parse.get_or_insert_with(Vec::new);
		if !parse.contains(&ty) {
			parse.push(ty);
		}
		self
	}

	pub fn allow_mention_role(&mut self, role: api::Snowflake) -> &mut Self {
		let am = self.msg.allowed_mentions.get_or_insert_with(Default::default);
		let roles = am.roles.get_or_insert_with(Vec::new);
		if !roles.contains(&role) {
			roles.push(role);
		}
		self
	}

	pub fn allow_mention_user(&mut self, user: api::Snowflake) -> &mut Self {
		let am = self.msg.allowed_mentions.get_or_insert_with(Default::default);
		let users = am.users.get_or_insert_with(Vec::new);
		if !users.contains(&user) {
			users.push(user);
		}
		self
	}

	pub fn embed_title(&mut self, title: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		me.title = Some(title.into_owned());
		self
	}

	pub fn embed_type(&mut self, ty: api::EmbedType) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		me.r#type = Some(ty);
		self
	}

	pub fn embed_description(&mut self, desc: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		me.description = Some(desc.into_owned());
		self
	}

	pub fn embed_url(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		me.url = Some(url.into_owned());
		self
	}

	pub fn embed_timestamp(&mut self, ts: api::TimeStamp) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		me.timestamp = Some(ts);
		self
	}

	pub fn embed_color(&mut self, color: u64) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		me.color = Some(color);
		self
	}

	pub fn embed_footer_text(&mut self, text: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let footer = me.footer.get_or_insert_with(Default::default);
		footer.text = text.into_owned();
		self
	}

	pub fn embed_footer_icon(&mut self, icon: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let footer = me.footer.get_or_insert_with(Default::default);
		footer.icon_url = Some(icon.into_owned());
		self
	}

	pub fn embed_image(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let image = me.image.get_or_insert_with(Default::default);
		image.url = Some(url.into_owned());
		self
	}

	pub fn embed_thumbnail(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let thumbnail = me.thumbnail.get_or_insert_with(Default::default);
		thumbnail.url = Some(url.into_owned());
		self
	}

	pub fn embed_video(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let video = me.video.get_or_insert_with(Default::default);
		video.url = Some(url.into_owned());
		self
	}

	pub fn embed_provider_name(&mut self, name: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let provider = me.provider.get_or_insert_with(Default::default);
		provider.name = Some(name.into_owned());
		self
	}

	pub fn embed_provider_url(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let provider = me.provider.get_or_insert_with(Default::default);
		provider.url = Some(url.into_owned());
		self
	}

	pub fn embed_author_name(&mut self, name: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let author = me.author.get_or_insert_with(Default::default);
		author.name = Some(name.into_owned());
		self
	}

	pub fn embed_author_url(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let author = me.author.get_or_insert_with(Default::default);
		author.url = Some(url.into_owned());
		self
	}

	pub fn embed_author_icon(&mut self, url: Cow<str>) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let author = me.author.get_or_insert_with(Default::default);
		author.icon_url = Some(url.into_owned());
		self
	}

	pub fn embed_field(&mut self, name: Cow<str>, value: Cow<str>, inline: bool) -> &mut Self {
		let me = self.msg.embed.get_or_insert_with(Default::default);
		let fields = me.fields.get_or_insert_with(Vec::new);
		let ct = fields.iter_mut().filter(|x| x.name == name).map(|x| {
			x.value = value.clone().into_owned();
			x.inline = Some(inline);
			()
		}).count();
		if ct == 0 {
			fields.push(api::EmbedField{
				name: name.into_owned(),
				value: value.into_owned(),
				inline: Some(inline),
			});
		}
		self
	}
}