1use rsb_derive::Builder;
6use rvstruct::ValueStruct;
7use serde::{Deserialize, Serialize};
8use serde_with::skip_serializing_none;
9
10use crate::models::*;
11use crate::ratectl::*;
12use crate::*;
13use futures::future::{BoxFuture, FutureExt};
14use std::collections::HashSet;
15
16impl<'a, SCHC> SlackClientSession<'a, SCHC>
17where
18 SCHC: SlackClientHttpConnector + Send,
19{
20 pub async fn conversations_archive(
24 &self,
25 req: &SlackApiConversationsArchiveRequest,
26 ) -> ClientResult<SlackApiConversationsArchiveResponse> {
27 self.http_session_api
28 .http_post(
29 "conversations.archive",
30 req,
31 Some(&SLACK_TIER2_METHOD_CONFIG),
32 )
33 .await
34 }
35
36 pub async fn conversations_close(
40 &self,
41 req: &SlackApiConversationsCloseRequest,
42 ) -> ClientResult<SlackApiConversationsCloseResponse> {
43 self.http_session_api
44 .http_post("conversations.close", req, Some(&SLACK_TIER2_METHOD_CONFIG))
45 .await
46 }
47
48 pub async fn conversations_create(
52 &self,
53 req: &SlackApiConversationsCreateRequest,
54 ) -> ClientResult<SlackApiConversationsCreateResponse> {
55 self.http_session_api
56 .http_post(
57 "conversations.create",
58 req,
59 Some(&SLACK_TIER2_METHOD_CONFIG),
60 )
61 .await
62 }
63
64 pub async fn conversations_history(
68 &self,
69 req: &SlackApiConversationsHistoryRequest,
70 ) -> ClientResult<SlackApiConversationsHistoryResponse> {
71 self.http_session_api
72 .http_get(
73 "conversations.history",
74 &vec![
75 ("channel", req.channel.as_ref().map(|x| x.value())),
76 ("cursor", req.cursor.as_ref().map(|x| x.value())),
77 ("limit", req.limit.map(|v| v.to_string()).as_ref()),
78 ("inclusive", req.inclusive.map(|v| v.to_string()).as_ref()),
79 (
80 "include_all_metadata",
81 req.include_all_metadata.map(|v| v.to_string()).as_ref(),
82 ),
83 ("latest", req.latest.as_ref().map(|x| x.value())),
84 ("oldest", req.oldest.as_ref().map(|x| x.value())),
85 ],
86 Some(&SLACK_TIER3_METHOD_CONFIG),
87 )
88 .await
89 }
90
91 pub async fn conversations_info(
95 &self,
96 req: &SlackApiConversationsInfoRequest,
97 ) -> ClientResult<SlackApiConversationsInfoResponse> {
98 self.http_session_api
99 .http_get(
100 "conversations.info",
101 &vec![
102 ("channel", Some(req.channel.value())),
103 (
104 "include_num_members",
105 req.include_num_members.map(|v| v.to_string()).as_ref(),
106 ),
107 (
108 "include_locale",
109 req.include_locale.map(|v| v.to_string()).as_ref(),
110 ),
111 ],
112 Some(&SLACK_TIER3_METHOD_CONFIG),
113 )
114 .await
115 }
116
117 pub async fn conversations_invite(
121 &self,
122 req: &SlackApiConversationsInviteRequest,
123 ) -> ClientResult<SlackApiConversationsInviteResponse> {
124 self.http_session_api
125 .http_post(
126 "conversations.invite",
127 req,
128 Some(&SLACK_TIER3_METHOD_CONFIG),
129 )
130 .await
131 }
132
133 pub async fn conversations_join(
137 &self,
138 req: &SlackApiConversationsJoinRequest,
139 ) -> ClientResult<SlackApiConversationsJoinResponse> {
140 self.http_session_api
141 .http_post("conversations.join", req, Some(&SLACK_TIER3_METHOD_CONFIG))
142 .await
143 }
144
145 pub async fn conversations_kick(
149 &self,
150 req: &SlackApiConversationsKickRequest,
151 ) -> ClientResult<SlackApiConversationsKickResponse> {
152 self.http_session_api
153 .http_post("conversations.kick", req, Some(&SLACK_TIER3_METHOD_CONFIG))
154 .await
155 }
156
157 pub async fn conversations_leave(
161 &self,
162 req: &SlackApiConversationsLeaveRequest,
163 ) -> ClientResult<SlackApiConversationsLeaveResponse> {
164 self.http_session_api
165 .http_post("conversations.leave", req, Some(&SLACK_TIER3_METHOD_CONFIG))
166 .await
167 }
168
169 pub async fn conversations_list(
173 &self,
174 req: &SlackApiConversationsListRequest,
175 ) -> ClientResult<SlackApiConversationsListResponse> {
176 self.http_session_api
177 .http_get(
178 "conversations.list",
179 &vec![
180 ("cursor", req.cursor.as_ref().map(|x| x.value())),
181 ("limit", req.limit.map(|v| v.to_string()).as_ref()),
182 (
183 "exclude_archived",
184 req.exclude_archived.map(|v| v.to_string()).as_ref(),
185 ),
186 (
187 "types",
188 req.types
189 .as_ref()
190 .map(|xs| {
191 xs.iter()
192 .map(|x| x.to_string())
193 .collect::<Vec<String>>()
194 .join(",")
195 })
196 .as_ref(),
197 ),
198 ],
199 Some(&SLACK_TIER2_METHOD_CONFIG),
200 )
201 .await
202 }
203
204 pub async fn conversations_members(
208 &self,
209 req: &SlackApiConversationsMembersRequest,
210 ) -> ClientResult<SlackApiConversationsMembersResponse> {
211 self.http_session_api
212 .http_get(
213 "conversations.members",
214 &vec![
215 ("channel", req.channel.as_ref().map(|x| x.value())),
216 ("cursor", req.cursor.as_ref().map(|x| x.value())),
217 ("limit", req.limit.map(|v| v.to_string()).as_ref()),
218 ],
219 Some(&SLACK_TIER4_METHOD_CONFIG),
220 )
221 .await
222 }
223
224 pub async fn conversations_open(
229 &self,
230 req: &SlackApiConversationsOpenRequest,
231 ) -> ClientResult<SlackApiConversationsOpenResponse<SlackBasicChannelInfo>> {
232 self.http_session_api
233 .http_post(
234 "conversations.open",
235 &req.clone().without_return_im(),
236 Some(&SLACK_TIER3_METHOD_CONFIG),
237 )
238 .await
239 }
240
241 pub async fn conversations_open_full(
246 &self,
247 req: &SlackApiConversationsOpenRequest,
248 ) -> ClientResult<SlackApiConversationsOpenResponse<SlackChannelInfo>> {
249 self.http_session_api
250 .http_post(
251 "conversations.open",
252 &req.clone().with_return_im(true),
253 Some(&SLACK_TIER3_METHOD_CONFIG),
254 )
255 .await
256 }
257
258 pub async fn conversations_rename(
262 &self,
263 req: &SlackApiConversationsRenameRequest,
264 ) -> ClientResult<SlackApiConversationsRenameResponse> {
265 self.http_session_api
266 .http_post(
267 "conversations.rename",
268 req,
269 Some(&SLACK_TIER2_METHOD_CONFIG),
270 )
271 .await
272 }
273
274 pub async fn conversations_replies(
278 &self,
279 req: &SlackApiConversationsRepliesRequest,
280 ) -> ClientResult<SlackApiConversationsRepliesResponse> {
281 self.http_session_api
282 .http_get(
283 "conversations.replies",
284 &vec![
285 ("channel", Some(req.channel.value())),
286 ("ts", Some(req.ts.value())),
287 ("cursor", req.cursor.as_ref().map(|x| x.value())),
288 ("limit", req.limit.map(|v| v.to_string()).as_ref()),
289 ("inclusive", req.inclusive.map(|v| v.to_string()).as_ref()),
290 ("latest", req.latest.as_ref().map(|x| x.value())),
291 ("oldest", req.oldest.as_ref().map(|x| x.value())),
292 ],
293 Some(&SLACK_TIER3_METHOD_CONFIG),
294 )
295 .await
296 }
297
298 pub async fn conversations_set_purpose(
302 &self,
303 req: &SlackApiConversationsSetPurposeRequest,
304 ) -> ClientResult<SlackApiConversationsSetPurposeResponse> {
305 self.http_session_api
306 .http_post(
307 "conversations.setPurpose",
308 req,
309 Some(&SLACK_TIER2_METHOD_CONFIG),
310 )
311 .await
312 }
313
314 pub async fn conversations_set_topic(
318 &self,
319 req: &SlackApiConversationsSetTopicRequest,
320 ) -> ClientResult<SlackApiConversationsSetTopicResponse> {
321 self.http_session_api
322 .http_post(
323 "conversations.setTopic",
324 req,
325 Some(&SLACK_TIER2_METHOD_CONFIG),
326 )
327 .await
328 }
329
330 pub async fn conversations_unarchive(
334 &self,
335 req: &SlackApiConversationsUnarchiveRequest,
336 ) -> ClientResult<SlackApiConversationsUnarchiveResponse> {
337 self.http_session_api
338 .http_post(
339 "conversations.setTopic",
340 req,
341 Some(&SLACK_TIER2_METHOD_CONFIG),
342 )
343 .await
344 }
345}
346
347#[skip_serializing_none]
348#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
349pub struct SlackApiConversationsArchiveRequest {
350 pub channel: SlackChannelId,
351}
352
353#[skip_serializing_none]
354#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
355pub struct SlackApiConversationsArchiveResponse {}
356
357#[skip_serializing_none]
358#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
359pub struct SlackApiConversationsCloseRequest {
360 pub channel: SlackChannelId,
361}
362
363#[skip_serializing_none]
364#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
365pub struct SlackApiConversationsCloseResponse {
366 pub no_op: Option<bool>,
367 pub already_closed: Option<bool>,
368}
369
370#[skip_serializing_none]
371#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
372pub struct SlackApiConversationsCreateRequest {
373 pub name: String,
374 pub is_private: Option<bool>,
375 pub user_ds: Option<HashSet<SlackUserId>>,
376}
377
378#[skip_serializing_none]
379#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
380pub struct SlackApiConversationsCreateResponse {
381 pub channel: SlackChannelInfo,
382}
383
384#[skip_serializing_none]
385#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
386pub struct SlackApiConversationsHistoryRequest {
387 pub channel: Option<SlackChannelId>,
388 pub cursor: Option<SlackCursorId>,
389 pub latest: Option<SlackTs>,
390 pub limit: Option<u16>,
391 pub oldest: Option<SlackTs>,
392 pub inclusive: Option<bool>,
393 pub include_all_metadata: Option<bool>,
394}
395
396#[skip_serializing_none]
397#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
398pub struct SlackApiConversationsHistoryResponse {
399 pub messages: Vec<SlackHistoryMessage>,
400 pub response_metadata: Option<SlackResponseMetadata>,
401 pub has_more: Option<bool>,
402 pub pin_count: Option<u64>,
403}
404
405impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiConversationsHistoryRequest
406where
407 SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
408{
409 type ResponseType = SlackApiConversationsHistoryResponse;
410 type CursorType = SlackCursorId;
411 type ResponseItemType = SlackHistoryMessage;
412
413 fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
414 self.clone().opt_cursor(new_cursor.cloned())
415 }
416
417 fn scroll<'a, 's>(
418 &'a self,
419 session: &'a SlackClientSession<'s, SCHC>,
420 ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
421 async move { session.conversations_history(self).await }.boxed()
422 }
423}
424
425impl SlackApiScrollableResponse for SlackApiConversationsHistoryResponse {
426 type CursorType = SlackCursorId;
427 type ResponseItemType = SlackHistoryMessage;
428
429 fn next_cursor(&self) -> Option<&Self::CursorType> {
430 self.response_metadata
431 .as_ref()
432 .and_then(|rm| rm.next_cursor.as_ref())
433 }
434
435 fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
436 Box::new(self.messages.iter())
437 }
438}
439
440#[skip_serializing_none]
441#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
442pub struct SlackApiConversationsInfoRequest {
443 pub channel: SlackChannelId,
444 pub include_locale: Option<bool>,
445 pub include_num_members: Option<bool>,
446}
447
448#[skip_serializing_none]
449#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
450pub struct SlackApiConversationsInfoResponse {
451 pub channel: SlackChannelInfo,
452}
453
454#[skip_serializing_none]
455#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
456pub struct SlackApiConversationsInviteRequest {
457 pub channel: SlackChannelId,
458 pub users: Vec<SlackUserId>,
459}
460
461#[skip_serializing_none]
462#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
463pub struct SlackApiConversationsInviteResponse {
464 pub channel: SlackChannelInfo,
465}
466
467#[skip_serializing_none]
468#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
469pub struct SlackApiConversationsJoinRequest {
470 pub channel: SlackChannelId,
471}
472
473#[skip_serializing_none]
474#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
475pub struct SlackApiConversationsJoinResponse {
476 pub channel: SlackChannelInfo,
477 pub response_metadata: Option<SlackResponseMetadata>,
478}
479
480#[skip_serializing_none]
481#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
482pub struct SlackApiConversationsKickRequest {
483 pub channel: SlackChannelId,
484 pub user: SlackUserId,
485}
486
487#[skip_serializing_none]
488#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
489pub struct SlackApiConversationsKickResponse {}
490
491#[skip_serializing_none]
492#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
493pub struct SlackApiConversationsLeaveRequest {
494 pub channel: SlackChannelId,
495}
496
497#[skip_serializing_none]
498#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
499pub struct SlackApiConversationsLeaveResponse {
500 pub not_in_channel: Option<bool>,
501}
502
503#[skip_serializing_none]
504#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
505pub struct SlackApiConversationsListRequest {
506 pub cursor: Option<SlackCursorId>,
507 pub limit: Option<u16>,
508 pub exclude_archived: Option<bool>,
509 pub types: Option<Vec<SlackConversationType>>,
510}
511
512#[skip_serializing_none]
513#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
514pub struct SlackApiConversationsListResponse {
515 pub channels: Vec<SlackChannelInfo>,
516 pub response_metadata: Option<SlackResponseMetadata>,
517}
518
519impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiConversationsListRequest
520where
521 SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
522{
523 type ResponseType = SlackApiConversationsListResponse;
524 type CursorType = SlackCursorId;
525 type ResponseItemType = SlackChannelInfo;
526
527 fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
528 self.clone().opt_cursor(new_cursor.cloned())
529 }
530
531 fn scroll<'a, 's>(
532 &'a self,
533 session: &'a SlackClientSession<'s, SCHC>,
534 ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
535 async move { session.conversations_list(self).await }.boxed()
536 }
537}
538
539impl SlackApiScrollableResponse for SlackApiConversationsListResponse {
540 type CursorType = SlackCursorId;
541 type ResponseItemType = SlackChannelInfo;
542
543 fn next_cursor(&self) -> Option<&Self::CursorType> {
544 self.response_metadata
545 .as_ref()
546 .and_then(|rm| rm.next_cursor.as_ref())
547 }
548
549 fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
550 Box::new(self.channels.iter())
551 }
552}
553
554#[skip_serializing_none]
555#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
556pub struct SlackApiConversationsMembersRequest {
557 pub channel: Option<SlackChannelId>,
558 pub cursor: Option<SlackCursorId>,
559 pub limit: Option<u16>,
560}
561
562#[skip_serializing_none]
563#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
564pub struct SlackApiConversationsMembersResponse {
565 pub members: Vec<SlackUserId>,
566 pub response_metadata: Option<SlackResponseMetadata>,
567}
568
569impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiConversationsMembersRequest
570where
571 SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
572{
573 type ResponseType = SlackApiConversationsMembersResponse;
574 type CursorType = SlackCursorId;
575 type ResponseItemType = SlackUserId;
576
577 fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
578 self.clone().opt_cursor(new_cursor.cloned())
579 }
580
581 fn scroll<'a, 's>(
582 &'a self,
583 session: &'a SlackClientSession<'s, SCHC>,
584 ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
585 async move { session.conversations_members(self).await }.boxed()
586 }
587}
588
589impl SlackApiScrollableResponse for SlackApiConversationsMembersResponse {
590 type CursorType = SlackCursorId;
591 type ResponseItemType = SlackUserId;
592
593 fn next_cursor(&self) -> Option<&Self::CursorType> {
594 self.response_metadata
595 .as_ref()
596 .and_then(|rm| rm.next_cursor.as_ref())
597 }
598
599 fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
600 Box::new(self.members.iter())
601 }
602}
603
604#[skip_serializing_none]
605#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
606pub struct SlackApiConversationsOpenRequest {
607 pub channel: Option<SlackChannelId>,
608 pub return_im: Option<bool>,
609 pub users: Option<Vec<SlackUserId>>,
610}
611
612#[skip_serializing_none]
613#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
614pub struct SlackApiConversationsOpenResponse<T>
615where
616 T: HasChannelInfo,
617{
618 pub channel: T,
619 pub already_open: Option<bool>,
620 pub no_op: Option<bool>,
621}
622
623#[skip_serializing_none]
624#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
625pub struct SlackApiConversationsRenameRequest {
626 pub channel: SlackChannelId,
627 pub name: String,
628}
629
630#[skip_serializing_none]
631#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
632pub struct SlackApiConversationsRenameResponse {
633 pub channel: SlackChannelInfo,
634}
635
636#[skip_serializing_none]
637#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
638pub struct SlackApiConversationsRepliesRequest {
639 pub channel: SlackChannelId,
640 pub ts: SlackTs,
641 pub cursor: Option<SlackCursorId>,
642 pub latest: Option<SlackTs>,
643 pub limit: Option<u16>,
644 pub oldest: Option<SlackTs>,
645 pub inclusive: Option<bool>,
646}
647
648#[skip_serializing_none]
649#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
650pub struct SlackApiConversationsRepliesResponse {
651 pub messages: Vec<SlackHistoryMessage>,
652 pub response_metadata: Option<SlackResponseMetadata>,
653 pub has_more: Option<bool>,
654}
655
656impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiConversationsRepliesRequest
657where
658 SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
659{
660 type ResponseType = SlackApiConversationsRepliesResponse;
661 type CursorType = SlackCursorId;
662 type ResponseItemType = SlackHistoryMessage;
663
664 fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
665 self.clone().opt_cursor(new_cursor.cloned())
666 }
667
668 fn scroll<'a, 's>(
669 &'a self,
670 session: &'a SlackClientSession<'s, SCHC>,
671 ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
672 async move { session.conversations_replies(self).await }.boxed()
673 }
674}
675
676impl SlackApiScrollableResponse for SlackApiConversationsRepliesResponse {
677 type CursorType = SlackCursorId;
678 type ResponseItemType = SlackHistoryMessage;
679
680 fn next_cursor(&self) -> Option<&Self::CursorType> {
681 self.response_metadata
682 .as_ref()
683 .and_then(|rm| rm.next_cursor.as_ref())
684 }
685
686 fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
687 Box::new(self.messages.iter())
688 }
689}
690
691#[skip_serializing_none]
692#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
693pub struct SlackApiConversationsSetPurposeRequest {
694 pub channel: SlackChannelId,
695 pub purpose: String,
696}
697
698#[skip_serializing_none]
699#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
700pub struct SlackApiConversationsSetPurposeResponse {
701 pub purpose: Option<String>,
702}
703
704#[skip_serializing_none]
705#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
706pub struct SlackApiConversationsSetTopicRequest {
707 pub channel: SlackChannelId,
708 pub topic: String,
709}
710
711#[skip_serializing_none]
712#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
713pub struct SlackApiConversationsSetTopicResponse {
714 pub topic: Option<String>,
715}
716
717#[skip_serializing_none]
718#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
719pub struct SlackApiConversationsUnarchiveRequest {
720 pub channel: SlackChannelId,
721}
722
723#[skip_serializing_none]
724#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
725pub struct SlackApiConversationsUnarchiveResponse {}