slack_morphism/api/
users.rs

1//!
2//! Support for Slack Users 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::scroller::*;
13use crate::SlackClientSession;
14use crate::{ClientResult, SlackClientHttpConnector};
15use futures::future::{BoxFuture, FutureExt};
16
17impl<'a, SCHC> SlackClientSession<'a, SCHC>
18where
19    SCHC: SlackClientHttpConnector + Send,
20{
21    ///
22    /// https://api.slack.com/methods/users.conversations
23    ///
24    pub async fn users_conversations(
25        &self,
26        req: &SlackApiUsersConversationsRequest,
27    ) -> ClientResult<SlackApiUsersConversationsResponse> {
28        self.http_session_api
29            .http_get(
30                "users.conversations",
31                &vec![
32                    ("user", req.user.as_ref().map(|x| x.value())),
33                    ("cursor", req.cursor.as_ref().map(|x| x.value())),
34                    ("limit", req.limit.map(|v| v.to_string()).as_ref()),
35                    (
36                        "exclude_archived",
37                        req.exclude_archived.map(|v| v.to_string()).as_ref(),
38                    ),
39                    (
40                        "types",
41                        req.types
42                            .as_ref()
43                            .map(|xs| {
44                                xs.iter()
45                                    .map(|x| x.to_string())
46                                    .collect::<Vec<String>>()
47                                    .join(",")
48                            })
49                            .as_ref(),
50                    ),
51                ],
52                Some(&SLACK_TIER3_METHOD_CONFIG),
53            )
54            .await
55    }
56
57    ///
58    /// https://api.slack.com/methods/users.getPresence
59    ///
60    pub async fn users_get_presence(
61        &self,
62        req: &SlackApiUsersGetPresenceRequest,
63    ) -> ClientResult<SlackApiUsersGetPresenceResponse> {
64        self.http_session_api
65            .http_get(
66                "users.getPresence",
67                &vec![("user", Some(req.user.value()))],
68                Some(&SLACK_TIER3_METHOD_CONFIG),
69            )
70            .await
71    }
72
73    ///
74    /// https://api.slack.com/methods/users.identity
75    ///
76    pub async fn users_identity(&self) -> ClientResult<SlackApiUsersGetPresenceResponse> {
77        self.http_session_api
78            .http_get(
79                "users.identity",
80                &crate::client::SLACK_HTTP_EMPTY_GET_PARAMS.clone(),
81                Some(&SLACK_TIER4_METHOD_CONFIG),
82            )
83            .await
84    }
85
86    ///
87    /// https://api.slack.com/methods/users.info
88    ///
89    pub async fn users_info(
90        &self,
91        req: &SlackApiUsersInfoRequest,
92    ) -> ClientResult<SlackApiUsersInfoResponse> {
93        self.http_session_api
94            .http_get(
95                "users.info",
96                &vec![
97                    ("user", Some(req.user.value())),
98                    (
99                        "include_locale",
100                        req.include_locale.map(|v| v.to_string()).as_ref(),
101                    ),
102                ],
103                Some(&SLACK_TIER4_METHOD_CONFIG),
104            )
105            .await
106    }
107
108    ///
109    /// https://api.slack.com/methods/users.list
110    ///
111    pub async fn users_list(
112        &self,
113        req: &SlackApiUsersListRequest,
114    ) -> ClientResult<SlackApiUsersListResponse> {
115        self.http_session_api
116            .http_get(
117                "users.list",
118                &vec![
119                    ("cursor", req.cursor.as_ref().map(|v| v.value())),
120                    ("team_id", req.team_id.as_ref().map(|v| v.value())),
121                    ("limit", req.limit.map(|v| v.to_string()).as_ref()),
122                    (
123                        "include_locale",
124                        req.include_locale.map(|v| v.to_string()).as_ref(),
125                    ),
126                ],
127                Some(&SLACK_TIER2_METHOD_CONFIG),
128            )
129            .await
130    }
131
132    ///
133    /// https://api.slack.com/methods/users.lookupByEmail
134    ///
135    pub async fn users_lookup_by_email(
136        &self,
137        req: &SlackApiUsersLookupByEmailRequest,
138    ) -> ClientResult<SlackApiUsersLookupByEmailResponse> {
139        self.http_session_api
140            .http_get(
141                "users.lookupByEmail",
142                &vec![("email", Some(req.email.value()))],
143                Some(&SLACK_TIER3_METHOD_CONFIG),
144            )
145            .await
146    }
147
148    ///
149    /// https://api.slack.com/methods/users.setPresence
150    ///
151    pub async fn users_set_presence(
152        &self,
153        req: &SlackApiUsersSetPresenceRequest,
154    ) -> ClientResult<SlackApiUsersSetPresenceResponse> {
155        self.http_session_api
156            .http_post("users.setPresence", req, Some(&SLACK_TIER2_METHOD_CONFIG))
157            .await
158    }
159
160    ///
161    /// https://api.slack.com/methods/users.profile.get
162    ///
163    pub async fn users_profile_get(
164        &self,
165        req: &SlackApiUsersProfileGetRequest,
166    ) -> ClientResult<SlackApiUsersProfileGetResponse> {
167        self.http_session_api
168            .http_get(
169                "users.profile.get",
170                &vec![
171                    ("user", req.user.as_ref().map(|v| v.value())),
172                    (
173                        "include_locale",
174                        req.include_locale.map(|v| v.to_string()).as_ref(),
175                    ),
176                ],
177                Some(&SLACK_TIER4_METHOD_CONFIG),
178            )
179            .await
180    }
181
182    ///
183    /// https://api.slack.com/methods/users.profile.set
184    ///
185    pub async fn users_profile_set(
186        &self,
187        req: &SlackApiUsersProfileSetRequest,
188    ) -> ClientResult<SlackApiUsersProfileSetResponse> {
189        self.http_session_api
190            .http_post("users.profile.set", req, Some(&SLACK_TIER3_METHOD_CONFIG))
191            .await
192    }
193}
194
195#[skip_serializing_none]
196#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
197pub struct SlackApiUsersConversationsRequest {
198    pub cursor: Option<SlackCursorId>,
199    pub limit: Option<u16>,
200    pub exclude_archived: Option<bool>,
201    pub types: Option<Vec<SlackConversationType>>,
202    pub user: Option<SlackUserId>,
203}
204
205#[skip_serializing_none]
206#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
207pub struct SlackApiUsersConversationsResponse {
208    pub channels: Vec<SlackChannelInfo>,
209    pub response_metadata: Option<SlackResponseMetadata>,
210}
211
212impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiUsersConversationsRequest
213where
214    SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
215{
216    type ResponseType = SlackApiUsersConversationsResponse;
217    type CursorType = SlackCursorId;
218    type ResponseItemType = SlackChannelInfo;
219
220    fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
221        self.clone().opt_cursor(new_cursor.cloned())
222    }
223
224    fn scroll<'a, 's>(
225        &'a self,
226        session: &'a SlackClientSession<'s, SCHC>,
227    ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
228        async move { session.users_conversations(self).await }.boxed()
229    }
230}
231
232impl SlackApiScrollableResponse for SlackApiUsersConversationsResponse {
233    type CursorType = SlackCursorId;
234    type ResponseItemType = SlackChannelInfo;
235
236    fn next_cursor(&self) -> Option<Self::CursorType> {
237        self.response_metadata
238            .as_ref()
239            .and_then(|rm| rm.next_cursor.as_ref())
240            .cloned()
241    }
242
243    fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
244        Box::new(self.channels.iter())
245    }
246}
247
248#[skip_serializing_none]
249#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
250pub struct SlackApiUsersListRequest {
251    pub cursor: Option<SlackCursorId>,
252    pub include_locale: Option<bool>,
253    pub limit: Option<u16>,
254    pub team_id: Option<SlackTeamId>,
255}
256
257#[skip_serializing_none]
258#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
259pub struct SlackApiUsersListResponse {
260    pub members: Vec<SlackUser>,
261    pub response_metadata: Option<SlackResponseMetadata>,
262}
263
264impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiUsersListRequest
265where
266    SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
267{
268    type ResponseType = SlackApiUsersListResponse;
269    type CursorType = SlackCursorId;
270    type ResponseItemType = SlackUser;
271
272    fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
273        self.clone().opt_cursor(new_cursor.cloned())
274    }
275
276    fn scroll<'a, 's>(
277        &'a self,
278        session: &'a SlackClientSession<'s, SCHC>,
279    ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
280        async move { session.users_list(self).await }.boxed()
281    }
282}
283
284impl SlackApiScrollableResponse for SlackApiUsersListResponse {
285    type CursorType = SlackCursorId;
286    type ResponseItemType = SlackUser;
287
288    fn next_cursor(&self) -> Option<Self::CursorType> {
289        self.response_metadata
290            .as_ref()
291            .and_then(|rm| rm.next_cursor.as_ref())
292            .cloned()
293    }
294
295    fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
296        Box::new(self.members.iter())
297    }
298}
299
300#[skip_serializing_none]
301#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
302pub struct SlackApiUsersGetPresenceRequest {
303    pub user: SlackUserId,
304}
305
306#[skip_serializing_none]
307#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
308pub struct SlackApiUsersGetPresenceResponse {
309    pub presence: String,
310    pub online: Option<bool>,
311    pub auto_away: Option<bool>,
312    pub manual_away: Option<bool>,
313    pub connection_count: Option<u64>,
314    pub last_activity: Option<SlackDateTime>,
315}
316
317#[skip_serializing_none]
318#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
319pub struct SlackApiUsersIdentityResponse {
320    pub user: SlackUserProfile,
321    pub team: SlackBasicTeamInfo,
322}
323
324#[skip_serializing_none]
325#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
326pub struct SlackApiUsersInfoRequest {
327    pub user: SlackUserId,
328    pub include_locale: Option<bool>,
329}
330
331#[skip_serializing_none]
332#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
333pub struct SlackApiUsersInfoResponse {
334    pub user: SlackUser,
335}
336
337#[skip_serializing_none]
338#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
339pub struct SlackApiUsersLookupByEmailRequest {
340    pub email: EmailAddress,
341}
342
343#[skip_serializing_none]
344#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
345pub struct SlackApiUsersLookupByEmailResponse {
346    pub user: SlackUser,
347}
348
349#[skip_serializing_none]
350#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
351pub struct SlackApiUsersSetPresenceRequest {
352    pub presence: String,
353}
354
355#[skip_serializing_none]
356#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
357pub struct SlackApiUsersSetPresenceResponse {}
358
359#[skip_serializing_none]
360#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
361pub struct SlackApiUsersProfileGetRequest {
362    pub user: Option<SlackUserId>,
363    pub include_locale: Option<bool>,
364}
365
366#[skip_serializing_none]
367#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
368pub struct SlackApiUsersProfileGetResponse {
369    pub profile: SlackUserProfile,
370}
371
372#[skip_serializing_none]
373#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
374pub struct SlackApiUsersProfileSetRequest {
375    pub profile: SlackUserProfile,
376    pub user: Option<SlackUserId>,
377}
378
379#[skip_serializing_none]
380#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
381pub struct SlackApiUsersProfileSetResponse {
382    pub profile: SlackUserProfile,
383}
slack_morphism/api/users.rs

slack_morphism/api/
users.rs
