slack_api/sync/mods/
usergroups.rs1pub use crate::mod_types::usergroups_types::*;
18use crate::sync::requests::SlackWebRequestSender;
19
20pub fn create<R>(
25 client: &R,
26 token: &str,
27 request: &CreateRequest<'_>,
28) -> Result<CreateResponse, CreateError<R::Error>>
29where
30 R: SlackWebRequestSender,
31{
32 let params = vec![
33 Some(("token", token)),
34 Some(("name", request.name)),
35 request.handle.map(|handle| ("handle", handle)),
36 request
37 .description
38 .map(|description| ("description", description)),
39 request.channels.map(|channels| ("channels", channels)),
40 request
41 .include_count
42 .map(|include_count| ("include_count", if include_count { "1" } else { "0" })),
43 ];
44 let params = params.into_iter().filter_map(|x| x).collect::<Vec<_>>();
45 let url = crate::get_slack_url_for_method("usergroups.create");
46 client
47 .send(&url, ¶ms[..])
48 .map_err(CreateError::Client)
49 .and_then(|result| {
50 serde_json::from_str::<CreateResponse>(&result)
51 .map_err(|e| CreateError::MalformedResponse(result, e))
52 })
53 .and_then(|o| o.into())
54}
55
56pub fn disable<R>(
61 client: &R,
62 token: &str,
63 request: &DisableRequest<'_>,
64) -> Result<DisableResponse, DisableError<R::Error>>
65where
66 R: SlackWebRequestSender,
67{
68 let params = vec![
69 Some(("token", token)),
70 Some(("usergroup", request.usergroup)),
71 request
72 .include_count
73 .map(|include_count| ("include_count", if include_count { "1" } else { "0" })),
74 ];
75 let params = params.into_iter().filter_map(|x| x).collect::<Vec<_>>();
76 let url = crate::get_slack_url_for_method("usergroups.disable");
77 client
78 .send(&url, ¶ms[..])
79 .map_err(DisableError::Client)
80 .and_then(|result| {
81 serde_json::from_str::<DisableResponse>(&result)
82 .map_err(|e| DisableError::MalformedResponse(result, e))
83 })
84 .and_then(|o| o.into())
85}
86
87pub fn enable<R>(
92 client: &R,
93 token: &str,
94 request: &EnableRequest<'_>,
95) -> Result<EnableResponse, EnableError<R::Error>>
96where
97 R: SlackWebRequestSender,
98{
99 let params = vec![
100 Some(("token", token)),
101 Some(("usergroup", request.usergroup)),
102 request
103 .include_count
104 .map(|include_count| ("include_count", if include_count { "1" } else { "0" })),
105 ];
106 let params = params.into_iter().filter_map(|x| x).collect::<Vec<_>>();
107 let url = crate::get_slack_url_for_method("usergroups.enable");
108 client
109 .send(&url, ¶ms[..])
110 .map_err(EnableError::Client)
111 .and_then(|result| {
112 serde_json::from_str::<EnableResponse>(&result)
113 .map_err(|e| EnableError::MalformedResponse(result, e))
114 })
115 .and_then(|o| o.into())
116}
117
118pub fn list<R>(
123 client: &R,
124 token: &str,
125 request: &ListRequest,
126) -> Result<ListResponse, ListError<R::Error>>
127where
128 R: SlackWebRequestSender,
129{
130 let params = vec![
131 Some(("token", token)),
132 request
133 .include_disabled
134 .map(|include_disabled| ("include_disabled", if include_disabled { "1" } else { "0" })),
135 request
136 .include_count
137 .map(|include_count| ("include_count", if include_count { "1" } else { "0" })),
138 request
139 .include_users
140 .map(|include_users| ("include_users", if include_users { "1" } else { "0" })),
141 ];
142 let params = params.into_iter().filter_map(|x| x).collect::<Vec<_>>();
143 let url = crate::get_slack_url_for_method("usergroups.list");
144 client
145 .send(&url, ¶ms[..])
146 .map_err(ListError::Client)
147 .and_then(|result| {
148 serde_json::from_str::<ListResponse>(&result)
149 .map_err(|e| ListError::MalformedResponse(result, e))
150 })
151 .and_then(|o| o.into())
152}
153
154pub fn update<R>(
159 client: &R,
160 token: &str,
161 request: &UpdateRequest<'_>,
162) -> Result<UpdateResponse, UpdateError<R::Error>>
163where
164 R: SlackWebRequestSender,
165{
166 let params = vec![
167 Some(("token", token)),
168 Some(("usergroup", request.usergroup)),
169 request.name.map(|name| ("name", name)),
170 request.handle.map(|handle| ("handle", handle)),
171 request
172 .description
173 .map(|description| ("description", description)),
174 request.channels.map(|channels| ("channels", channels)),
175 request
176 .include_count
177 .map(|include_count| ("include_count", if include_count { "1" } else { "0" })),
178 ];
179 let params = params.into_iter().filter_map(|x| x).collect::<Vec<_>>();
180 let url = crate::get_slack_url_for_method("usergroups.update");
181 client
182 .send(&url, ¶ms[..])
183 .map_err(UpdateError::Client)
184 .and_then(|result| {
185 serde_json::from_str::<UpdateResponse>(&result)
186 .map_err(|e| UpdateError::MalformedResponse(result, e))
187 })
188 .and_then(|o| o.into())
189}