1use super::{configuration, Error};
12use crate::gen::apis::ResponseContent;
13use crate::gen::models;
14
15#[derive(Clone, Debug)]
17pub struct AddActorUsersParams {
18 pub project_id_or_key: String,
20 pub id: i64,
22 pub actors_map: models::ActorsMap,
24}
25
26#[derive(Clone, Debug)]
28pub struct AddProjectRoleActorsToRoleParams {
29 pub id: i64,
31 pub actor_input_bean: models::ActorInputBean,
32}
33
34#[derive(Clone, Debug)]
36pub struct DeleteActorParams {
37 pub project_id_or_key: String,
39 pub id: i64,
41 pub user: Option<String>,
43 pub group: Option<String>,
45}
46
47#[derive(Clone, Debug)]
49pub struct DeleteProjectRoleActorsFromRoleParams {
50 pub id: i64,
52 pub user: Option<String>,
54 pub group: Option<String>,
56}
57
58#[derive(Clone, Debug)]
60pub struct GetProjectRoleActorsForRoleParams {
61 pub id: i64,
63}
64
65#[derive(Clone, Debug)]
67pub struct SetActorsParams {
68 pub project_id_or_key: String,
70 pub id: i64,
72 pub project_role_actors_update_bean: models::ProjectRoleActorsUpdateBean,
74}
75
76#[derive(Debug, Clone, Serialize, Deserialize)]
78#[serde(untagged)]
79pub enum AddActorUsersError {
80 Status400(),
81 Status401(),
82 Status404(),
83 UnknownValue(serde_json::Value),
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum AddProjectRoleActorsToRoleError {
90 Status400(),
91 Status401(),
92 Status403(),
93 Status404(),
94 UnknownValue(serde_json::Value),
95}
96
97#[derive(Debug, Clone, Serialize, Deserialize)]
99#[serde(untagged)]
100pub enum DeleteActorError {
101 Status400(),
102 Status404(),
103 UnknownValue(serde_json::Value),
104}
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
108#[serde(untagged)]
109pub enum DeleteProjectRoleActorsFromRoleError {
110 Status400(),
111 Status401(),
112 Status403(),
113 Status404(),
114 UnknownValue(serde_json::Value),
115}
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(untagged)]
120pub enum GetProjectRoleActorsForRoleError {
121 Status400(),
122 Status401(),
123 Status403(),
124 Status404(),
125 UnknownValue(serde_json::Value),
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum SetActorsError {
132 Status400(),
133 Status401(),
134 Status404(),
135 UnknownValue(serde_json::Value),
136}
137
138pub async fn add_actor_users(
140 configuration: &configuration::Configuration,
141 params: AddActorUsersParams,
142) -> Result<models::ProjectRole, Error<AddActorUsersError>> {
143 let project_id_or_key = params.project_id_or_key;
145 let id = params.id;
146 let actors_map = params.actors_map;
147
148 let local_var_client = &configuration.client;
149
150 let local_var_uri_str = format!(
151 "{}/rest/api/3/project/{projectIdOrKey}/role/{id}",
152 configuration.base_path,
153 projectIdOrKey = crate::gen::apis::urlencode(project_id_or_key),
154 id = id
155 );
156 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
157
158 if let Some(ref local_var_user_agent) = configuration.user_agent {
159 local_var_req_builder =
160 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
161 }
162 if let Some(ref local_var_token) = configuration.oauth_access_token {
163 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
164 };
165 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
166 local_var_req_builder = local_var_req_builder.basic_auth(
167 local_var_auth_conf.0.to_owned(),
168 local_var_auth_conf.1.to_owned(),
169 );
170 };
171 local_var_req_builder = local_var_req_builder.json(&actors_map);
172
173 let local_var_req = local_var_req_builder.build()?;
174 let local_var_resp = local_var_client.execute(local_var_req).await?;
175
176 let local_var_status = local_var_resp.status();
177 let local_var_content = local_var_resp.text().await?;
178
179 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
180 serde_json::from_str(&local_var_content).map_err(Error::from)
181 } else {
182 let local_var_entity: Option<AddActorUsersError> =
183 serde_json::from_str(&local_var_content).ok();
184 let local_var_error = ResponseContent {
185 status: local_var_status,
186 content: local_var_content,
187 entity: local_var_entity,
188 };
189 Err(Error::ResponseError(local_var_error))
190 }
191}
192
193pub async fn add_project_role_actors_to_role(
195 configuration: &configuration::Configuration,
196 params: AddProjectRoleActorsToRoleParams,
197) -> Result<models::ProjectRole, Error<AddProjectRoleActorsToRoleError>> {
198 let id = params.id;
200 let actor_input_bean = params.actor_input_bean;
201
202 let local_var_client = &configuration.client;
203
204 let local_var_uri_str = format!(
205 "{}/rest/api/3/role/{id}/actors",
206 configuration.base_path,
207 id = id
208 );
209 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
210
211 if let Some(ref local_var_user_agent) = configuration.user_agent {
212 local_var_req_builder =
213 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
214 }
215 if let Some(ref local_var_token) = configuration.oauth_access_token {
216 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
217 };
218 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
219 local_var_req_builder = local_var_req_builder.basic_auth(
220 local_var_auth_conf.0.to_owned(),
221 local_var_auth_conf.1.to_owned(),
222 );
223 };
224 local_var_req_builder = local_var_req_builder.json(&actor_input_bean);
225
226 let local_var_req = local_var_req_builder.build()?;
227 let local_var_resp = local_var_client.execute(local_var_req).await?;
228
229 let local_var_status = local_var_resp.status();
230 let local_var_content = local_var_resp.text().await?;
231
232 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
233 serde_json::from_str(&local_var_content).map_err(Error::from)
234 } else {
235 let local_var_entity: Option<AddProjectRoleActorsToRoleError> =
236 serde_json::from_str(&local_var_content).ok();
237 let local_var_error = ResponseContent {
238 status: local_var_status,
239 content: local_var_content,
240 entity: local_var_entity,
241 };
242 Err(Error::ResponseError(local_var_error))
243 }
244}
245
246pub async fn delete_actor(
248 configuration: &configuration::Configuration,
249 params: DeleteActorParams,
250) -> Result<(), Error<DeleteActorError>> {
251 let project_id_or_key = params.project_id_or_key;
253 let id = params.id;
254 let user = params.user;
255 let group = params.group;
256
257 let local_var_client = &configuration.client;
258
259 let local_var_uri_str = format!(
260 "{}/rest/api/3/project/{projectIdOrKey}/role/{id}",
261 configuration.base_path,
262 projectIdOrKey = crate::gen::apis::urlencode(project_id_or_key),
263 id = id
264 );
265 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
266
267 if let Some(ref local_var_str) = user {
268 local_var_req_builder =
269 local_var_req_builder.query(&[("user", &local_var_str.to_string())]);
270 }
271 if let Some(ref local_var_str) = group {
272 local_var_req_builder =
273 local_var_req_builder.query(&[("group", &local_var_str.to_string())]);
274 }
275 if let Some(ref local_var_user_agent) = configuration.user_agent {
276 local_var_req_builder =
277 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
278 }
279 if let Some(ref local_var_token) = configuration.oauth_access_token {
280 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
281 };
282 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
283 local_var_req_builder = local_var_req_builder.basic_auth(
284 local_var_auth_conf.0.to_owned(),
285 local_var_auth_conf.1.to_owned(),
286 );
287 };
288
289 let local_var_req = local_var_req_builder.build()?;
290 let local_var_resp = local_var_client.execute(local_var_req).await?;
291
292 let local_var_status = local_var_resp.status();
293 let local_var_content = local_var_resp.text().await?;
294
295 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
296 Ok(())
297 } else {
298 let local_var_entity: Option<DeleteActorError> =
299 serde_json::from_str(&local_var_content).ok();
300 let local_var_error = ResponseContent {
301 status: local_var_status,
302 content: local_var_content,
303 entity: local_var_entity,
304 };
305 Err(Error::ResponseError(local_var_error))
306 }
307}
308
309pub async fn delete_project_role_actors_from_role(
311 configuration: &configuration::Configuration,
312 params: DeleteProjectRoleActorsFromRoleParams,
313) -> Result<models::ProjectRole, Error<DeleteProjectRoleActorsFromRoleError>> {
314 let id = params.id;
316 let user = params.user;
317 let group = params.group;
318
319 let local_var_client = &configuration.client;
320
321 let local_var_uri_str = format!(
322 "{}/rest/api/3/role/{id}/actors",
323 configuration.base_path,
324 id = id
325 );
326 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
327
328 if let Some(ref local_var_str) = user {
329 local_var_req_builder =
330 local_var_req_builder.query(&[("user", &local_var_str.to_string())]);
331 }
332 if let Some(ref local_var_str) = group {
333 local_var_req_builder =
334 local_var_req_builder.query(&[("group", &local_var_str.to_string())]);
335 }
336 if let Some(ref local_var_user_agent) = configuration.user_agent {
337 local_var_req_builder =
338 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
339 }
340 if let Some(ref local_var_token) = configuration.oauth_access_token {
341 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
342 };
343 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
344 local_var_req_builder = local_var_req_builder.basic_auth(
345 local_var_auth_conf.0.to_owned(),
346 local_var_auth_conf.1.to_owned(),
347 );
348 };
349
350 let local_var_req = local_var_req_builder.build()?;
351 let local_var_resp = local_var_client.execute(local_var_req).await?;
352
353 let local_var_status = local_var_resp.status();
354 let local_var_content = local_var_resp.text().await?;
355
356 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
357 serde_json::from_str(&local_var_content).map_err(Error::from)
358 } else {
359 let local_var_entity: Option<DeleteProjectRoleActorsFromRoleError> =
360 serde_json::from_str(&local_var_content).ok();
361 let local_var_error = ResponseContent {
362 status: local_var_status,
363 content: local_var_content,
364 entity: local_var_entity,
365 };
366 Err(Error::ResponseError(local_var_error))
367 }
368}
369
370pub async fn get_project_role_actors_for_role(
372 configuration: &configuration::Configuration,
373 params: GetProjectRoleActorsForRoleParams,
374) -> Result<models::ProjectRole, Error<GetProjectRoleActorsForRoleError>> {
375 let id = params.id;
377
378 let local_var_client = &configuration.client;
379
380 let local_var_uri_str = format!(
381 "{}/rest/api/3/role/{id}/actors",
382 configuration.base_path,
383 id = id
384 );
385 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
386
387 if let Some(ref local_var_user_agent) = configuration.user_agent {
388 local_var_req_builder =
389 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
390 }
391 if let Some(ref local_var_token) = configuration.oauth_access_token {
392 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
393 };
394 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
395 local_var_req_builder = local_var_req_builder.basic_auth(
396 local_var_auth_conf.0.to_owned(),
397 local_var_auth_conf.1.to_owned(),
398 );
399 };
400
401 let local_var_req = local_var_req_builder.build()?;
402 let local_var_resp = local_var_client.execute(local_var_req).await?;
403
404 let local_var_status = local_var_resp.status();
405 let local_var_content = local_var_resp.text().await?;
406
407 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
408 serde_json::from_str(&local_var_content).map_err(Error::from)
409 } else {
410 let local_var_entity: Option<GetProjectRoleActorsForRoleError> =
411 serde_json::from_str(&local_var_content).ok();
412 let local_var_error = ResponseContent {
413 status: local_var_status,
414 content: local_var_content,
415 entity: local_var_entity,
416 };
417 Err(Error::ResponseError(local_var_error))
418 }
419}
420
421pub async fn set_actors(
423 configuration: &configuration::Configuration,
424 params: SetActorsParams,
425) -> Result<models::ProjectRole, Error<SetActorsError>> {
426 let project_id_or_key = params.project_id_or_key;
428 let id = params.id;
429 let project_role_actors_update_bean = params.project_role_actors_update_bean;
430
431 let local_var_client = &configuration.client;
432
433 let local_var_uri_str = format!(
434 "{}/rest/api/3/project/{projectIdOrKey}/role/{id}",
435 configuration.base_path,
436 projectIdOrKey = crate::gen::apis::urlencode(project_id_or_key),
437 id = id
438 );
439 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
440
441 if let Some(ref local_var_user_agent) = configuration.user_agent {
442 local_var_req_builder =
443 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
444 }
445 if let Some(ref local_var_token) = configuration.oauth_access_token {
446 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
447 };
448 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
449 local_var_req_builder = local_var_req_builder.basic_auth(
450 local_var_auth_conf.0.to_owned(),
451 local_var_auth_conf.1.to_owned(),
452 );
453 };
454 local_var_req_builder = local_var_req_builder.json(&project_role_actors_update_bean);
455
456 let local_var_req = local_var_req_builder.build()?;
457 let local_var_resp = local_var_client.execute(local_var_req).await?;
458
459 let local_var_status = local_var_resp.status();
460 let local_var_content = local_var_resp.text().await?;
461
462 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
463 serde_json::from_str(&local_var_content).map_err(Error::from)
464 } else {
465 let local_var_entity: Option<SetActorsError> =
466 serde_json::from_str(&local_var_content).ok();
467 let local_var_error = ResponseContent {
468 status: local_var_status,
469 content: local_var_content,
470 entity: local_var_entity,
471 };
472 Err(Error::ResponseError(local_var_error))
473 }
474}