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    }
241
242    fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
243        Box::new(self.channels.iter())
244    }
245}
246
247#[skip_serializing_none]
248#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
249pub struct SlackApiUsersListRequest {
250    pub cursor: Option<SlackCursorId>,
251    pub include_locale: Option<bool>,
252    pub limit: Option<u16>,
253    pub team_id: Option<SlackTeamId>,
254}
255
256#[skip_serializing_none]
257#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
258pub struct SlackApiUsersListResponse {
259    pub members: Vec<SlackUser>,
260    pub response_metadata: Option<SlackResponseMetadata>,
261}
262
263impl<SCHC> SlackApiScrollableRequest<SCHC> for SlackApiUsersListRequest
264where
265    SCHC: SlackClientHttpConnector + Send + Sync + Clone + 'static,
266{
267    type ResponseType = SlackApiUsersListResponse;
268    type CursorType = SlackCursorId;
269    type ResponseItemType = SlackUser;
270
271    fn with_new_cursor(&self, new_cursor: Option<&Self::CursorType>) -> Self {
272        self.clone().opt_cursor(new_cursor.cloned())
273    }
274
275    fn scroll<'a, 's>(
276        &'a self,
277        session: &'a SlackClientSession<'s, SCHC>,
278    ) -> BoxFuture<'a, ClientResult<Self::ResponseType>> {
279        async move { session.users_list(self).await }.boxed()
280    }
281}
282
283impl SlackApiScrollableResponse for SlackApiUsersListResponse {
284    type CursorType = SlackCursorId;
285    type ResponseItemType = SlackUser;
286
287    fn next_cursor(&self) -> Option<&Self::CursorType> {
288        self.response_metadata
289            .as_ref()
290            .and_then(|rm| rm.next_cursor.as_ref())
291    }
292
293    fn scrollable_items<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::ResponseItemType> + 'a> {
294        Box::new(self.members.iter())
295    }
296}
297
298#[skip_serializing_none]
299#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
300pub struct SlackApiUsersGetPresenceRequest {
301    pub user: SlackUserId,
302}
303
304#[skip_serializing_none]
305#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
306pub struct SlackApiUsersGetPresenceResponse {
307    pub presence: String,
308    pub online: Option<bool>,
309    pub auto_away: Option<bool>,
310    pub manual_away: Option<bool>,
311    pub connection_count: Option<u64>,
312    pub last_activity: Option<SlackDateTime>,
313}
314
315#[skip_serializing_none]
316#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
317pub struct SlackApiUsersIdentityResponse {
318    pub user: SlackUserProfile,
319    pub team: SlackBasicTeamInfo,
320}
321
322#[skip_serializing_none]
323#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
324pub struct SlackApiUsersInfoRequest {
325    pub user: SlackUserId,
326    pub include_locale: Option<bool>,
327}
328
329#[skip_serializing_none]
330#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
331pub struct SlackApiUsersInfoResponse {
332    pub user: SlackUser,
333}
334
335#[skip_serializing_none]
336#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
337pub struct SlackApiUsersLookupByEmailRequest {
338    pub email: EmailAddress,
339}
340
341#[skip_serializing_none]
342#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
343pub struct SlackApiUsersLookupByEmailResponse {
344    pub user: SlackUser,
345}
346
347#[skip_serializing_none]
348#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
349pub struct SlackApiUsersSetPresenceRequest {
350    pub presence: String,
351}
352
353#[skip_serializing_none]
354#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
355pub struct SlackApiUsersSetPresenceResponse {}
356
357#[skip_serializing_none]
358#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
359pub struct SlackApiUsersProfileGetRequest {
360    pub user: Option<SlackUserId>,
361    pub include_locale: Option<bool>,
362}
363
364#[skip_serializing_none]
365#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
366pub struct SlackApiUsersProfileGetResponse {
367    pub profile: SlackUserProfile,
368}
369
370#[skip_serializing_none]
371#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
372pub struct SlackApiUsersProfileSetRequest {
373    pub profile: SlackUserProfile,
374    pub user: Option<SlackUserId>,
375}
376
377#[skip_serializing_none]
378#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Builder)]
379pub struct SlackApiUsersProfileSetResponse {
380    pub profile: SlackUserProfile,
381}
slack_morphism/api/users.rs

slack_morphism/api/
users.rs
