slack_messaging/message/builder.rs
1use super::{Block, Message};
2
3impl Message {
4 /// Construct a [`MessageBuilder`].
5 pub fn builder() -> MessageBuilder {
6 MessageBuilder::default()
7 }
8}
9
10/// Builder for [`Message`] object.
11#[derive(Debug, Default)]
12pub struct MessageBuilder {
13 text: Option<String>,
14 blocks: Vec<Block>,
15 thread_ts: Option<String>,
16 mrkdwn: Option<bool>,
17 response_type: Option<String>,
18 replace_original: Option<bool>,
19 delete_original: Option<bool>,
20}
21
22impl MessageBuilder {
23 /// Set text field.
24 ///
25 /// ```
26 /// # use slack_messaging::Message;
27 /// let message = Message::builder()
28 /// .set_text(Some("New Paid Time Off request from Fred Enriquez".into()))
29 /// .build();
30 ///
31 /// let expected = serde_json::json!({
32 /// "text": "New Paid Time Off request from Fred Enriquez",
33 /// });
34 ///
35 /// let json = serde_json::to_value(message).unwrap();
36 ///
37 /// assert_eq!(json, expected);
38 /// ```
39 pub fn set_text(self, text: Option<String>) -> Self {
40 Self { text, ..self }
41 }
42
43 /// Set text field.
44 ///
45 /// ```
46 /// # use slack_messaging::Message;
47 /// let message = Message::builder()
48 /// .text("New Paid Time Off request from Fred Enriquez")
49 /// .build();
50 ///
51 /// let expected = serde_json::json!({
52 /// "text": "New Paid Time Off request from Fred Enriquez",
53 /// });
54 ///
55 /// let json = serde_json::to_value(message).unwrap();
56 ///
57 /// assert_eq!(json, expected);
58 /// ```
59 pub fn text(self, text: impl Into<String>) -> Self {
60 self.set_text(Some(text.into()))
61 }
62
63 /// Set blocks field. The argument is a vector composed from any objects
64 /// that can transform into the enum [Block](crate::blocks::Block).
65 ///
66 /// ```
67 /// # use slack_messaging::{blocks::{Header, Section}, mrkdwn, Message};
68 /// let message = Message::builder()
69 /// .set_blocks(
70 /// vec![
71 /// Header::builder()
72 /// .text("New request")
73 /// .build()
74 /// .into(),
75 /// Section::builder()
76 /// .text(mrkdwn!("<https://example.com|View request>"))
77 /// .build()
78 /// .into(),
79 /// ]
80 /// )
81 /// .build();
82 ///
83 /// let expected = serde_json::json!({
84 /// "blocks": [
85 /// {
86 /// "type": "header",
87 /// "text": {
88 /// "type": "plain_text",
89 /// "text": "New request"
90 /// }
91 /// },
92 /// {
93 /// "type": "section",
94 /// "text": {
95 /// "type": "mrkdwn",
96 /// "text": "<https://example.com|View request>"
97 /// }
98 /// }
99 /// ]
100 /// });
101 ///
102 /// let json = serde_json::to_value(message).unwrap();
103 ///
104 /// assert_eq!(json, expected);
105 /// ```
106 pub fn set_blocks(self, blocks: Vec<Block>) -> Self {
107 Self { blocks, ..self }
108 }
109
110 /// Add an object to blocks field. The argument is an any object
111 /// that can transform into the enum [Block](crate::blocks::Block).
112 ///
113 /// ```
114 /// # use slack_messaging::{blocks::{Header, Section}, mrkdwn, Message};
115 /// let message = Message::builder()
116 /// .block(
117 /// Header::builder()
118 /// .text("New request")
119 /// .build()
120 /// )
121 /// .block(
122 /// Section::builder()
123 /// .text(mrkdwn!("<https://example.com|View request>"))
124 /// .build()
125 /// )
126 /// .build();
127 ///
128 /// let expected = serde_json::json!({
129 /// "blocks": [
130 /// {
131 /// "type": "header",
132 /// "text": {
133 /// "type": "plain_text",
134 /// "text": "New request"
135 /// }
136 /// },
137 /// {
138 /// "type": "section",
139 /// "text": {
140 /// "type": "mrkdwn",
141 /// "text": "<https://example.com|View request>"
142 /// }
143 /// }
144 /// ]
145 /// });
146 ///
147 /// let json = serde_json::to_value(message).unwrap();
148 ///
149 /// assert_eq!(json, expected);
150 /// ```
151 pub fn block(self, block: impl Into<Block>) -> Self {
152 let Self { mut blocks, .. } = self;
153 blocks.push(block.into());
154 Self { blocks, ..self }
155 }
156
157 /// Set thread_ts field.
158 ///
159 /// ```
160 /// # use slack_messaging::Message;
161 /// let message = Message::builder()
162 /// .set_thread_ts(Some("some ts value".into()))
163 /// .build();
164 ///
165 /// let expected = serde_json::json!({
166 /// "thread_ts": "some ts value",
167 /// });
168 ///
169 /// let json = serde_json::to_value(message).unwrap();
170 ///
171 /// assert_eq!(json, expected);
172 /// ```
173 pub fn set_thread_ts(self, thread_ts: Option<String>) -> Self {
174 Self { thread_ts, ..self }
175 }
176
177 /// Set thread_ts field.
178 ///
179 /// ```
180 /// # use slack_messaging::Message;
181 /// let message = Message::builder()
182 /// .thread_ts("some ts value")
183 /// .build();
184 ///
185 /// let expected = serde_json::json!({
186 /// "thread_ts": "some ts value",
187 /// });
188 ///
189 /// let json = serde_json::to_value(message).unwrap();
190 ///
191 /// assert_eq!(json, expected);
192 /// ```
193 pub fn thread_ts(self, thread_ts: impl Into<String>) -> Self {
194 self.set_thread_ts(Some(thread_ts.into()))
195 }
196
197 /// Set mrkdwn field.
198 ///
199 /// ```
200 /// # use slack_messaging::Message;
201 /// let message = Message::builder()
202 /// .set_mrkdwn(Some(true))
203 /// .build();
204 ///
205 /// let expected = serde_json::json!({
206 /// "mrkdwn": true,
207 /// });
208 ///
209 /// let json = serde_json::to_value(message).unwrap();
210 ///
211 /// assert_eq!(json, expected);
212 /// ```
213 pub fn set_mrkdwn(self, mrkdwn: Option<bool>) -> Self {
214 Self { mrkdwn, ..self }
215 }
216
217 /// Set mrkdwn field.
218 ///
219 /// ```
220 /// # use slack_messaging::Message;
221 /// let message = Message::builder()
222 /// .mrkdwn(true)
223 /// .build();
224 ///
225 /// let expected = serde_json::json!({
226 /// "mrkdwn": true,
227 /// });
228 ///
229 /// let json = serde_json::to_value(message).unwrap();
230 ///
231 /// assert_eq!(json, expected);
232 /// ```
233 pub fn mrkdwn(self, mrkdwn: bool) -> Self {
234 self.set_mrkdwn(Some(mrkdwn))
235 }
236
237 /// Set response_type field.
238 ///
239 /// ```
240 /// # use slack_messaging::Message;
241 /// let message = Message::builder()
242 /// .set_response_type(Some("in_channel".into()))
243 /// .build();
244 ///
245 /// let expected = serde_json::json!({
246 /// "response_type": "in_channel",
247 /// });
248 ///
249 /// let json = serde_json::to_value(message).unwrap();
250 ///
251 /// assert_eq!(json, expected);
252 /// ```
253 pub fn set_response_type(self, response_type: Option<String>) -> Self {
254 Self {
255 response_type,
256 ..self
257 }
258 }
259
260 /// Set response_type field.
261 ///
262 /// ```
263 /// # use slack_messaging::Message;
264 /// let message = Message::builder()
265 /// .response_type("in_channel")
266 /// .build();
267 ///
268 /// let expected = serde_json::json!({
269 /// "response_type": "in_channel",
270 /// });
271 ///
272 /// let json = serde_json::to_value(message).unwrap();
273 ///
274 /// assert_eq!(json, expected);
275 /// ```
276 pub fn response_type(self, response_type: impl Into<String>) -> Self {
277 self.set_response_type(Some(response_type.into()))
278 }
279
280 /// Set replace_original field.
281 ///
282 /// ```
283 /// # use slack_messaging::Message;
284 /// let message = Message::builder()
285 /// .set_replace_original(Some(true))
286 /// .build();
287 ///
288 /// let expected = serde_json::json!({
289 /// "replace_original": true,
290 /// });
291 ///
292 /// let json = serde_json::to_value(message).unwrap();
293 ///
294 /// assert_eq!(json, expected);
295 /// ```
296 pub fn set_replace_original(self, replace_original: Option<bool>) -> Self {
297 Self {
298 replace_original,
299 ..self
300 }
301 }
302
303 /// Set replace_original field.
304 ///
305 /// ```
306 /// # use slack_messaging::Message;
307 /// let message = Message::builder()
308 /// .replace_original(true)
309 /// .build();
310 ///
311 /// let expected = serde_json::json!({
312 /// "replace_original": true,
313 /// });
314 ///
315 /// let json = serde_json::to_value(message).unwrap();
316 ///
317 /// assert_eq!(json, expected);
318 /// ```
319 pub fn replace_original(self, replace_original: bool) -> Self {
320 self.set_replace_original(Some(replace_original))
321 }
322
323 /// Set delete_original field.
324 ///
325 /// ```
326 /// # use slack_messaging::Message;
327 /// let message = Message::builder()
328 /// .set_delete_original(Some(true))
329 /// .build();
330 ///
331 /// let expected = serde_json::json!({
332 /// "delete_original": true,
333 /// });
334 ///
335 /// let json = serde_json::to_value(message).unwrap();
336 ///
337 /// assert_eq!(json, expected);
338 /// ```
339 pub fn set_delete_original(self, delete_original: Option<bool>) -> Self {
340 Self {
341 delete_original,
342 ..self
343 }
344 }
345
346 /// Set delete_original field.
347 ///
348 /// ```
349 /// # use slack_messaging::Message;
350 /// let message = Message::builder()
351 /// .delete_original(true)
352 /// .build();
353 ///
354 /// let expected = serde_json::json!({
355 /// "delete_original": true,
356 /// });
357 ///
358 /// let json = serde_json::to_value(message).unwrap();
359 ///
360 /// assert_eq!(json, expected);
361 /// ```
362 pub fn delete_original(self, delete_original: bool) -> Self {
363 self.set_delete_original(Some(delete_original))
364 }
365
366 /// Build a [`Message`] object.
367 pub fn build(self) -> Message {
368 Message {
369 text: self.text,
370 blocks: self.blocks,
371 thread_ts: self.thread_ts,
372 mrkdwn: self.mrkdwn,
373 response_type: self.response_type,
374 replace_original: self.replace_original,
375 delete_original: self.delete_original,
376 }
377 }
378
379 /// Get text value.
380 pub fn get_text(&self) -> &Option<String> {
381 &self.text
382 }
383
384 /// Get blocks value.
385 pub fn get_blocks(&self) -> &[Block] {
386 &self.blocks
387 }
388
389 /// Get thread_ts value.
390 pub fn get_thread_ts(&self) -> &Option<String> {
391 &self.thread_ts
392 }
393
394 /// Get mrkdwn value.
395 pub fn get_mrkdwn(&self) -> &Option<bool> {
396 &self.mrkdwn
397 }
398
399 /// Get response_type value.
400 pub fn get_response_type(&self) -> &Option<String> {
401 &self.response_type
402 }
403
404 /// Get replace_original value.
405 pub fn get_replace_original(&self) -> &Option<bool> {
406 &self.replace_original
407 }
408
409 /// Get delete_original value.
410 pub fn get_delete_original(&self) -> &Option<bool> {
411 &self.delete_original
412 }
413}