1use async_trait::async_trait;
2use reqwest::header;
3
4use crate::{
5 client::{errors::DracoonClientError, Connected},
6 constants::{
7 DRACOON_API_PREFIX, NODES_BASE, ROOMS_BASE, ROOMS_CONFIG, ROOMS_ENCRYPT, ROOMS_GROUPS,
8 ROOMS_GUEST_USERS, ROOMS_POLICIES, ROOMS_USERS,
9 },
10 models::ListAllParams,
11 utils::FromResponse,
12};
13
14use self::models::{
15 ConfigRoomRequest, CreateRoomRequest, EncryptRoomRequest, RoomGroupList,
16 RoomGroupsAddBatchRequest, RoomGroupsDeleteBatchRequest, RoomPolicies, RoomPoliciesRequest,
17 RoomUserList, RoomUsersAddBatchRequest, RoomUsersDeleteBatchRequest, UpdateRoomRequest,
18};
19
20use super::{models::Node, NodesEndpoint, RoomGuestUserAddRequest, Rooms};
21
22pub mod models;
23
24#[async_trait]
25impl Rooms for NodesEndpoint<Connected> {
26 async fn create_room(
27 &self,
28 create_room_req: CreateRoomRequest,
29 ) -> Result<Node, DracoonClientError> {
30 let url_part = format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}");
31 let api_url = self.client().build_api_url(&url_part);
32
33 let response = self
34 .client()
35 .http
36 .post(api_url)
37 .header(
38 header::AUTHORIZATION,
39 self.client().get_auth_header().await?,
40 )
41 .header(header::CONTENT_TYPE, "application/json")
42 .json(&create_room_req)
43 .send()
44 .await?;
45
46 Node::from_response(response).await
47 }
48 async fn update_room(
49 &self,
50 room_id: u64,
51 update_room_req: UpdateRoomRequest,
52 ) -> Result<Node, DracoonClientError> {
53 let url_part = format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}");
54 let api_url = self.client().build_api_url(&url_part);
55
56 let response = self
57 .client()
58 .http
59 .put(api_url)
60 .header(
61 header::AUTHORIZATION,
62 self.client().get_auth_header().await?,
63 )
64 .header(header::CONTENT_TYPE, "application/json")
65 .json(&update_room_req)
66 .send()
67 .await?;
68
69 Node::from_response(response).await
70 }
71 async fn config_room(
72 &self,
73 room_id: u64,
74 config_room_req: ConfigRoomRequest,
75 ) -> Result<Node, DracoonClientError> {
76 let url_part =
77 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_CONFIG}");
78 let api_url = self.client().build_api_url(&url_part);
79
80 let response = self
81 .client()
82 .http
83 .put(api_url)
84 .header(
85 header::AUTHORIZATION,
86 self.client().get_auth_header().await?,
87 )
88 .header(header::CONTENT_TYPE, "application/json")
89 .json(&config_room_req)
90 .send()
91 .await?;
92
93 Node::from_response(response).await
94 }
95 async fn get_room_policies(&self, room_id: u64) -> Result<RoomPolicies, DracoonClientError> {
96 let url_part =
97 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_POLICIES}");
98 let api_url = self.client().build_api_url(&url_part);
99
100 let response = self
101 .client()
102 .http
103 .get(api_url)
104 .header(
105 header::AUTHORIZATION,
106 self.client().get_auth_header().await?,
107 )
108 .send()
109 .await?;
110
111 RoomPolicies::from_response(response).await
112 }
113 async fn update_room_policies(
114 &self,
115 room_id: u64,
116 policy_room_req: RoomPoliciesRequest,
117 ) -> Result<(), DracoonClientError> {
118 let url_part =
119 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_POLICIES}");
120 let api_url = self.client().build_api_url(&url_part);
121
122 let response = self
123 .client()
124 .http
125 .put(api_url)
126 .header(
127 header::AUTHORIZATION,
128 self.client().get_auth_header().await?,
129 )
130 .header(header::CONTENT_TYPE, "application/json")
131 .json(&policy_room_req)
132 .send()
133 .await?;
134
135 if response.status().is_client_error() || response.status().is_server_error() {
136 return Err(DracoonClientError::from_response(response).await?);
137 }
138
139 Ok(())
140 }
141 async fn encrypt_room(
142 &self,
143 room_id: u64,
144 encrypt_room_req: EncryptRoomRequest,
145 ) -> Result<Node, DracoonClientError> {
146 let url_part =
147 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_ENCRYPT}");
148 let api_url = self.client().build_api_url(&url_part);
149
150 let response = self
151 .client()
152 .http
153 .put(api_url)
154 .header(
155 header::AUTHORIZATION,
156 self.client().get_auth_header().await?,
157 )
158 .header(header::CONTENT_TYPE, "application/json")
159 .json(&encrypt_room_req)
160 .send()
161 .await?;
162
163 Node::from_response(response).await
164 }
165 async fn get_room_groups(
166 &self,
167 room_id: u64,
168 params: Option<ListAllParams>,
169 ) -> Result<RoomGroupList, DracoonClientError> {
170 let url_part =
171 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_GROUPS}");
172 let mut api_url = self.client().build_api_url(&url_part);
173
174 let params = params.unwrap_or_default();
175 let filters = params.filter_to_string();
176 let sorts = params.sort_to_string();
177
178 api_url
179 .query_pairs_mut()
180 .extend_pairs(params.limit.map(|limit| ("limit", limit.to_string())))
181 .extend_pairs(params.offset.map(|offset| ("offset", offset.to_string())))
182 .extend_pairs(params.filter.map(|_| ("filter", filters)))
183 .extend_pairs(params.sort.map(|_| ("sort", sorts)))
184 .finish();
185
186 let response = self
187 .client()
188 .http
189 .get(api_url)
190 .header(
191 header::AUTHORIZATION,
192 self.client().get_auth_header().await?,
193 )
194 .send()
195 .await?;
196
197 RoomGroupList::from_response(response).await
198 }
199 async fn update_room_groups(
200 &self,
201 room_id: u64,
202 room_groups_update_req: RoomGroupsAddBatchRequest,
203 ) -> Result<(), DracoonClientError> {
204 let url_part =
205 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_GROUPS}");
206 let api_url = self.client().build_api_url(&url_part);
207
208 let response = self
209 .client()
210 .http
211 .put(api_url)
212 .header(
213 header::AUTHORIZATION,
214 self.client().get_auth_header().await?,
215 )
216 .header(header::CONTENT_TYPE, "application/json")
217 .json(&room_groups_update_req)
218 .send()
219 .await?;
220
221 if response.status().is_client_error() || response.status().is_server_error() {
222 return Err(DracoonClientError::from_response(response).await?);
223 }
224
225 Ok(())
226 }
227 async fn delete_room_groups(
228 &self,
229 room_id: u64,
230 room_groups_del_req: RoomGroupsDeleteBatchRequest,
231 ) -> Result<(), DracoonClientError> {
232 let url_part =
233 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_GROUPS}");
234 let api_url = self.client().build_api_url(&url_part);
235
236 let response = self
237 .client()
238 .http
239 .delete(api_url)
240 .header(
241 header::AUTHORIZATION,
242 self.client().get_auth_header().await?,
243 )
244 .header(header::CONTENT_TYPE, "application/json")
245 .json(&room_groups_del_req)
246 .send()
247 .await?;
248
249 if response.status().is_client_error() || response.status().is_server_error() {
250 return Err(DracoonClientError::from_response(response).await?);
251 }
252
253 Ok(())
254 }
255 async fn get_room_users(
256 &self,
257 room_id: u64,
258 params: Option<ListAllParams>,
259 ) -> Result<RoomUserList, DracoonClientError> {
260 let url_part =
261 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_USERS}");
262 let mut api_url = self.client().build_api_url(&url_part);
263
264 let params = params.unwrap_or_default();
265
266 let filters = params.filter_to_string();
267 let sorts = params.sort_to_string();
268
269 api_url
270 .query_pairs_mut()
271 .extend_pairs(params.limit.map(|limit| ("limit", limit.to_string())))
272 .extend_pairs(params.offset.map(|offset| ("offset", offset.to_string())))
273 .extend_pairs(params.filter.map(|filter| ("filter", filters)))
274 .extend_pairs(params.sort.map(|sort| ("sort", sorts)))
275 .finish();
276
277 let response = self
278 .client()
279 .http
280 .get(api_url)
281 .header(
282 header::AUTHORIZATION,
283 self.client().get_auth_header().await?,
284 )
285 .send()
286 .await?;
287
288 RoomUserList::from_response(response).await
289 }
290 async fn update_room_users(
291 &self,
292 room_id: u64,
293 room_users_update_req: RoomUsersAddBatchRequest,
294 ) -> Result<(), DracoonClientError> {
295 let url_part =
296 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_USERS}");
297 let api_url = self.client().build_api_url(&url_part);
298
299 let response = self
300 .client()
301 .http
302 .put(api_url)
303 .header(
304 header::AUTHORIZATION,
305 self.client().get_auth_header().await?,
306 )
307 .header(header::CONTENT_TYPE, "application/json")
308 .json(&room_users_update_req)
309 .send()
310 .await?;
311
312 if response.status().is_client_error() || response.status().is_server_error() {
313 return Err(DracoonClientError::from_response(response).await?);
314 }
315
316 Ok(())
317 }
318 async fn delete_room_users(
319 &self,
320 room_id: u64,
321 room_users_del_req: RoomUsersDeleteBatchRequest,
322 ) -> Result<(), DracoonClientError> {
323 let url_part =
324 format!("/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_USERS}");
325 let api_url = self.client().build_api_url(&url_part);
326
327 let response = self
328 .client()
329 .http
330 .delete(api_url)
331 .header(
332 header::AUTHORIZATION,
333 self.client().get_auth_header().await?,
334 )
335 .header(header::CONTENT_TYPE, "application/json")
336 .json(&room_users_del_req)
337 .send()
338 .await?;
339
340 if response.status().is_client_error() || response.status().is_server_error() {
341 return Err(DracoonClientError::from_response(response).await?);
342 }
343
344 Ok(())
345 }
346
347 async fn invite_guest_users(
348 &self,
349 room_id: u64,
350 invite_req: RoomGuestUserAddRequest,
351 ) -> Result<(), DracoonClientError> {
352 let url_part = format!(
353 "/{DRACOON_API_PREFIX}/{NODES_BASE}/{ROOMS_BASE}/{room_id}/{ROOMS_GUEST_USERS}"
354 );
355 let api_url = self.client().build_api_url(&url_part);
356
357 let response = self
358 .client()
359 .http
360 .put(api_url)
361 .header(
362 header::AUTHORIZATION,
363 self.client().get_auth_header().await?,
364 )
365 .header(header::CONTENT_TYPE, "application/json")
366 .json(&invite_req)
367 .send()
368 .await?;
369
370 if response.status().is_client_error() || response.status().is_server_error() {
371 return Err(DracoonClientError::from_response(response).await?);
372 }
373
374 Ok(())
375 }
376}