slack_morphism/api/
usergroups.rs

1//!
2//! Support for Slack User Groups API methods
3//!
4
5use 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::SlackClientSession;
13use crate::{ClientResult, SlackClientHttpConnector};
14
15impl<'a, SCHC> SlackClientSession<'a, SCHC>
16where
17    SCHC: SlackClientHttpConnector + Send,
18{
19    ///
20    /// https://api.slack.com/methods/usergroups.list
21    ///
22    pub async fn usergroups_list(
23        &self,
24        req: &SlackApiUserGroupsListRequest,
25    ) -> ClientResult<SlackApiUserGroupsListResponse> {
26        self.http_session_api
27            .http_get(
28                "usergroups.list",
29                &vec![
30                    (
31                        "include_count",
32                        req.include_count.map(|v| v.to_string()).as_ref(),
33                    ),
34                    (
35                        "include_disabled",
36                        req.include_disabled.map(|v| v.to_string()).as_ref(),
37                    ),
38                    (
39                        "include_users",
40                        req.include_users.map(|v| v.to_string()).as_ref(),
41                    ),
42                    ("team_id", req.team_id.as_ref().map(|x| x.value())),
43                ],
44                Some(&SLACK_TIER2_METHOD_CONFIG),
45            )
46            .await
47    }
48
49    ///
50    /// https://api.slack.com/methods/usergroups.users.list
51    ///
52    pub async fn usergroups_users_list(
53        &self,
54        req: &SlackApiUserGroupsUsersListRequest,
55    ) -> ClientResult<SlackApiUserGroupsUsersListResponse> {
56        self.http_session_api
57            .http_get(
58                "usergroups.users.list",
59                &vec![
60                    ("usergroup", Some(req.usergroup.value())),
61                    (
62                        "include_disabled",
63                        req.include_disabled.map(|v| v.to_string()).as_ref(),
64                    ),
65                    ("team_id", req.team_id.as_ref().map(|x| x.value())),
66                ],
67                Some(&SLACK_TIER2_METHOD_CONFIG),
68            )
69            .await
70    }
71}
72
73#[skip_serializing_none]
74#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
75pub struct SlackApiUserGroupsListRequest {
76    pub include_count: Option<bool>,
77    pub include_disabled: Option<bool>,
78    pub include_users: Option<bool>,
79    pub team_id: Option<SlackTeamId>,
80}
81
82#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
83pub struct SlackApiUserGroupsListResponse {
84    pub usergroups: Vec<SlackUserGroup>,
85}
86
87#[skip_serializing_none]
88#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
89pub struct SlackApiUserGroupsUsersListRequest {
90    pub usergroup: SlackUserGroupId,
91    pub include_disabled: Option<bool>,
92    pub team_id: Option<SlackTeamId>,
93}
94
95#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
96pub struct SlackApiUserGroupsUsersListResponse {
97    pub users: Vec<SlackUserId>,
98}