1use async_trait::async_trait;
2use reqwest::header;
3
4use crate::{
5 client::Connected,
6 constants::{DRACOON_API_PREFIX, GROUPS_BASE, GROUPS_LAST_ADMIN_ROOMS, GROUPS_USERS},
7 models::ListAllParams,
8 utils::FromResponse,
9 DracoonClientError,
10};
11
12use super::models::*;
13use super::Groups;
14
15#[async_trait]
16impl Groups for GroupsEndpoint<Connected> {
17 async fn get_groups(
18 &self,
19 params: Option<ListAllParams>,
20 ) -> Result<GroupList, DracoonClientError> {
21 let params = params.unwrap_or_default();
22 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}");
23
24 let mut api_url = self.client().build_api_url(&url_part);
25
26 let filters = params.filter_to_string();
27 let sorts = params.sort_to_string();
28
29 api_url
30 .query_pairs_mut()
31 .extend_pairs(params.limit.map(|v| ("limit", v.to_string())))
32 .extend_pairs(params.offset.map(|v| ("offset", v.to_string())))
33 .extend_pairs(params.sort.map(|_| ("sort", sorts)))
34 .extend_pairs(params.filter.map(|_| ("filter", filters)))
35 .finish();
36
37 let response = self
38 .client()
39 .http
40 .get(api_url)
41 .header(
42 header::AUTHORIZATION,
43 self.client().get_auth_header().await?,
44 )
45 .send()
46 .await?;
47
48 GroupList::from_response(response).await
49 }
50
51 async fn create_group(&self, group: CreateGroupRequest) -> Result<Group, DracoonClientError> {
52 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}");
53
54 let api_url = self.client().build_api_url(&url_part);
55
56 let response = self
57 .client()
58 .http
59 .post(api_url)
60 .header(
61 header::AUTHORIZATION,
62 self.client().get_auth_header().await?,
63 )
64 .header(header::CONTENT_TYPE, "application/json")
65 .json(&group)
66 .send()
67 .await?;
68
69 Group::from_response(response).await
70 }
71
72 async fn get_group(&self, group_id: u64) -> Result<Group, DracoonClientError> {
73 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}");
74
75 let api_url = self.client().build_api_url(&url_part);
76
77 let response = self
78 .client()
79 .http
80 .get(api_url)
81 .header(
82 header::AUTHORIZATION,
83 self.client().get_auth_header().await?,
84 )
85 .send()
86 .await?;
87
88 Group::from_response(response).await
89 }
90
91 async fn update_group(
92 &self,
93 group_id: u64,
94 group: UpdateGroupRequest,
95 ) -> Result<Group, DracoonClientError> {
96 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}");
97
98 let api_url = self.client().build_api_url(&url_part);
99
100 let response = self
101 .client()
102 .http
103 .put(api_url)
104 .header(
105 header::AUTHORIZATION,
106 self.client().get_auth_header().await?,
107 )
108 .header(header::CONTENT_TYPE, "application/json")
109 .json(&group)
110 .send()
111 .await?;
112
113 Group::from_response(response).await
114 }
115
116 async fn delete_group(&self, group_id: u64) -> Result<(), DracoonClientError> {
117 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}");
118
119 let api_url = self.client().build_api_url(&url_part);
120
121 let response = self
122 .client()
123 .http
124 .delete(api_url)
125 .header(
126 header::AUTHORIZATION,
127 self.client().get_auth_header().await?,
128 )
129 .send()
130 .await?;
131
132 if response.status().is_server_error() || response.status().is_client_error() {
133 return Err(DracoonClientError::from_response(response).await?);
134 }
135
136 Ok(())
137 }
138
139 async fn get_group_users(
140 &self,
141 group_id: u64,
142 params: Option<ListAllParams>,
143 ) -> Result<GroupUserList, DracoonClientError> {
144 let params = params.unwrap_or_default();
145 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}/{GROUPS_USERS}");
146
147 let mut api_url = self.client().build_api_url(&url_part);
148
149 let filters = params.filter_to_string();
150 let sorts = params.sort_to_string();
151
152 api_url
153 .query_pairs_mut()
154 .extend_pairs(params.limit.map(|v| ("limit", v.to_string())))
155 .extend_pairs(params.offset.map(|v| ("offset", v.to_string())))
156 .extend_pairs(params.sort.map(|_| ("sort", sorts)))
157 .extend_pairs(params.filter.map(|_| ("filter", filters)))
158 .finish();
159
160 let response = self
161 .client()
162 .http
163 .get(api_url)
164 .header(
165 header::AUTHORIZATION,
166 self.client().get_auth_header().await?,
167 )
168 .send()
169 .await?;
170
171 GroupUserList::from_response(response).await
172 }
173
174 async fn add_group_users(
175 &self,
176 group_id: u64,
177 user_ids: ChangeGroupMembersRequest,
178 ) -> Result<Group, DracoonClientError> {
179 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}/{GROUPS_USERS}");
180
181 let api_url = self.client().build_api_url(&url_part);
182
183 let response = self
184 .client()
185 .http
186 .post(api_url)
187 .header(
188 header::AUTHORIZATION,
189 self.client().get_auth_header().await?,
190 )
191 .header(header::CONTENT_TYPE, "application/json")
192 .json(&user_ids)
193 .send()
194 .await?;
195
196 Group::from_response(response).await
197 }
198
199 async fn remove_group_users(
200 &self,
201 group_id: u64,
202 user_ids: ChangeGroupMembersRequest,
203 ) -> Result<Group, DracoonClientError> {
204 let url_part = format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}/{GROUPS_USERS}");
205
206 let api_url = self.client().build_api_url(&url_part);
207
208 let response = self
209 .client()
210 .http
211 .delete(api_url)
212 .header(
213 header::AUTHORIZATION,
214 self.client().get_auth_header().await?,
215 )
216 .header(header::CONTENT_TYPE, "application/json")
217 .json(&user_ids)
218 .send()
219 .await?;
220
221 Group::from_response(response).await
222 }
223
224 async fn get_group_last_admin_rooms(
225 &self,
226 group_id: u64,
227 ) -> Result<LastAdminGroupRoomList, DracoonClientError> {
228 let url_part =
229 format!("/{DRACOON_API_PREFIX}/{GROUPS_BASE}/{group_id}/{GROUPS_LAST_ADMIN_ROOMS}");
230
231 let api_url = self.client().build_api_url(&url_part);
232
233 let response = self
234 .client()
235 .http
236 .get(api_url)
237 .header(
238 header::AUTHORIZATION,
239 self.client().get_auth_header().await?,
240 )
241 .send()
242 .await?;
243
244 LastAdminGroupRoomList::from_response(response).await
245 }
246}