1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum CreateProjectRoleError {
22 Status400(),
23 Status401(),
24 Status403(),
25 Status409(),
26 UnknownValue(serde_json::Value),
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize)]
31#[serde(untagged)]
32pub enum DeleteProjectRoleError {
33 Status400(),
34 Status401(),
35 Status403(),
36 Status404(),
37 Status409(),
38 UnknownValue(serde_json::Value),
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43#[serde(untagged)]
44pub enum FullyUpdateProjectRoleError {
45 Status400(),
46 Status401(),
47 Status403(),
48 Status404(),
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum GetAllProjectRolesError {
56 Status401(),
57 Status403(),
58 UnknownValue(serde_json::Value),
59}
60
61#[derive(Debug, Clone, Serialize, Deserialize)]
63#[serde(untagged)]
64pub enum GetProjectRoleError {
65 Status400(),
66 Status401(),
67 Status404(),
68 UnknownValue(serde_json::Value),
69}
70
71#[derive(Debug, Clone, Serialize, Deserialize)]
73#[serde(untagged)]
74pub enum GetProjectRoleByIdError {
75 Status401(),
76 Status403(),
77 Status404(),
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum GetProjectRoleDetailsError {
85 Status401(),
86 Status404(),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum GetProjectRolesError {
94 Status401(),
95 Status404(),
96 UnknownValue(serde_json::Value),
97}
98
99#[derive(Debug, Clone, Serialize, Deserialize)]
101#[serde(untagged)]
102pub enum PartialUpdateProjectRoleError {
103 Status400(),
104 Status401(),
105 Status403(),
106 Status404(),
107 UnknownValue(serde_json::Value),
108}
109
110
111pub async fn create_project_role(configuration: &configuration::Configuration, create_update_role_request_bean: models::CreateUpdateRoleRequestBean) -> Result<models::ProjectRole, Error<CreateProjectRoleError>> {
113 let p_create_update_role_request_bean = create_update_role_request_bean;
115
116 let uri_str = format!("{}/rest/api/2/role", configuration.base_path);
117 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
118
119 if let Some(ref user_agent) = configuration.user_agent {
120 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
121 }
122 if let Some(ref token) = configuration.oauth_access_token {
123 req_builder = req_builder.bearer_auth(token.to_owned());
124 };
125 if let Some(ref auth_conf) = configuration.basic_auth {
126 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
127 };
128 req_builder = req_builder.json(&p_create_update_role_request_bean);
129
130 let req = req_builder.build()?;
131 let resp = configuration.client.execute(req).await?;
132
133 let status = resp.status();
134
135 if !status.is_client_error() && !status.is_server_error() {
136 let content = resp.text().await?;
137 serde_json::from_str(&content).map_err(Error::from)
138 } else {
139 let content = resp.text().await?;
140 let entity: Option<CreateProjectRoleError> = serde_json::from_str(&content).ok();
141 Err(Error::ResponseError(ResponseContent { status, content, entity }))
142 }
143}
144
145pub async fn delete_project_role(configuration: &configuration::Configuration, id: i64, swap: Option<i64>) -> Result<(), Error<DeleteProjectRoleError>> {
147 let p_id = id;
149 let p_swap = swap;
150
151 let uri_str = format!("{}/rest/api/2/role/{id}", configuration.base_path, id=p_id);
152 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
153
154 if let Some(ref param_value) = p_swap {
155 req_builder = req_builder.query(&[("swap", ¶m_value.to_string())]);
156 }
157 if let Some(ref user_agent) = configuration.user_agent {
158 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
159 }
160 if let Some(ref token) = configuration.oauth_access_token {
161 req_builder = req_builder.bearer_auth(token.to_owned());
162 };
163 if let Some(ref auth_conf) = configuration.basic_auth {
164 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
165 };
166
167 let req = req_builder.build()?;
168 let resp = configuration.client.execute(req).await?;
169
170 let status = resp.status();
171
172 if !status.is_client_error() && !status.is_server_error() {
173 Ok(())
174 } else {
175 let content = resp.text().await?;
176 let entity: Option<DeleteProjectRoleError> = serde_json::from_str(&content).ok();
177 Err(Error::ResponseError(ResponseContent { status, content, entity }))
178 }
179}
180
181pub async fn fully_update_project_role(configuration: &configuration::Configuration, id: i64, create_update_role_request_bean: models::CreateUpdateRoleRequestBean) -> Result<models::ProjectRole, Error<FullyUpdateProjectRoleError>> {
183 let p_id = id;
185 let p_create_update_role_request_bean = create_update_role_request_bean;
186
187 let uri_str = format!("{}/rest/api/2/role/{id}", configuration.base_path, id=p_id);
188 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
189
190 if let Some(ref user_agent) = configuration.user_agent {
191 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
192 }
193 if let Some(ref token) = configuration.oauth_access_token {
194 req_builder = req_builder.bearer_auth(token.to_owned());
195 };
196 if let Some(ref auth_conf) = configuration.basic_auth {
197 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
198 };
199 req_builder = req_builder.json(&p_create_update_role_request_bean);
200
201 let req = req_builder.build()?;
202 let resp = configuration.client.execute(req).await?;
203
204 let status = resp.status();
205
206 if !status.is_client_error() && !status.is_server_error() {
207 let content = resp.text().await?;
208 serde_json::from_str(&content).map_err(Error::from)
209 } else {
210 let content = resp.text().await?;
211 let entity: Option<FullyUpdateProjectRoleError> = serde_json::from_str(&content).ok();
212 Err(Error::ResponseError(ResponseContent { status, content, entity }))
213 }
214}
215
216pub async fn get_all_project_roles(configuration: &configuration::Configuration, ) -> Result<Vec<models::ProjectRole>, Error<GetAllProjectRolesError>> {
218
219 let uri_str = format!("{}/rest/api/2/role", configuration.base_path);
220 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
221
222 if let Some(ref user_agent) = configuration.user_agent {
223 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
224 }
225 if let Some(ref token) = configuration.oauth_access_token {
226 req_builder = req_builder.bearer_auth(token.to_owned());
227 };
228 if let Some(ref auth_conf) = configuration.basic_auth {
229 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
230 };
231
232 let req = req_builder.build()?;
233 let resp = configuration.client.execute(req).await?;
234
235 let status = resp.status();
236
237 if !status.is_client_error() && !status.is_server_error() {
238 let content = resp.text().await?;
239 serde_json::from_str(&content).map_err(Error::from)
240 } else {
241 let content = resp.text().await?;
242 let entity: Option<GetAllProjectRolesError> = serde_json::from_str(&content).ok();
243 Err(Error::ResponseError(ResponseContent { status, content, entity }))
244 }
245}
246
247pub async fn get_project_role(configuration: &configuration::Configuration, project_id_or_key: &str, id: i64) -> Result<models::ProjectRole, Error<GetProjectRoleError>> {
249 let p_project_id_or_key = project_id_or_key;
251 let p_id = id;
252
253 let uri_str = format!("{}/rest/api/2/project/{projectIdOrKey}/role/{id}", configuration.base_path, projectIdOrKey=crate::apis::urlencode(p_project_id_or_key), id=p_id);
254 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
255
256 if let Some(ref user_agent) = configuration.user_agent {
257 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
258 }
259 if let Some(ref token) = configuration.oauth_access_token {
260 req_builder = req_builder.bearer_auth(token.to_owned());
261 };
262 if let Some(ref auth_conf) = configuration.basic_auth {
263 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
264 };
265
266 let req = req_builder.build()?;
267 let resp = configuration.client.execute(req).await?;
268
269 let status = resp.status();
270
271 if !status.is_client_error() && !status.is_server_error() {
272 let content = resp.text().await?;
273 serde_json::from_str(&content).map_err(Error::from)
274 } else {
275 let content = resp.text().await?;
276 let entity: Option<GetProjectRoleError> = serde_json::from_str(&content).ok();
277 Err(Error::ResponseError(ResponseContent { status, content, entity }))
278 }
279}
280
281pub async fn get_project_role_by_id(configuration: &configuration::Configuration, id: i64) -> Result<models::ProjectRole, Error<GetProjectRoleByIdError>> {
283 let p_id = id;
285
286 let uri_str = format!("{}/rest/api/2/role/{id}", configuration.base_path, id=p_id);
287 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
288
289 if let Some(ref user_agent) = configuration.user_agent {
290 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
291 }
292 if let Some(ref token) = configuration.oauth_access_token {
293 req_builder = req_builder.bearer_auth(token.to_owned());
294 };
295 if let Some(ref auth_conf) = configuration.basic_auth {
296 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
297 };
298
299 let req = req_builder.build()?;
300 let resp = configuration.client.execute(req).await?;
301
302 let status = resp.status();
303
304 if !status.is_client_error() && !status.is_server_error() {
305 let content = resp.text().await?;
306 serde_json::from_str(&content).map_err(Error::from)
307 } else {
308 let content = resp.text().await?;
309 let entity: Option<GetProjectRoleByIdError> = serde_json::from_str(&content).ok();
310 Err(Error::ResponseError(ResponseContent { status, content, entity }))
311 }
312}
313
314pub async fn get_project_role_details(configuration: &configuration::Configuration, project_id_or_key: &str, current_member: Option<bool>, exclude_connect_addons: Option<bool>) -> Result<Vec<models::ProjectRoleDetails>, Error<GetProjectRoleDetailsError>> {
316 let p_project_id_or_key = project_id_or_key;
318 let p_current_member = current_member;
319 let p_exclude_connect_addons = exclude_connect_addons;
320
321 let uri_str = format!("{}/rest/api/2/project/{projectIdOrKey}/roledetails", configuration.base_path, projectIdOrKey=crate::apis::urlencode(p_project_id_or_key));
322 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
323
324 if let Some(ref param_value) = p_current_member {
325 req_builder = req_builder.query(&[("currentMember", ¶m_value.to_string())]);
326 }
327 if let Some(ref param_value) = p_exclude_connect_addons {
328 req_builder = req_builder.query(&[("excludeConnectAddons", ¶m_value.to_string())]);
329 }
330 if let Some(ref user_agent) = configuration.user_agent {
331 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
332 }
333 if let Some(ref token) = configuration.oauth_access_token {
334 req_builder = req_builder.bearer_auth(token.to_owned());
335 };
336 if let Some(ref auth_conf) = configuration.basic_auth {
337 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
338 };
339
340 let req = req_builder.build()?;
341 let resp = configuration.client.execute(req).await?;
342
343 let status = resp.status();
344
345 if !status.is_client_error() && !status.is_server_error() {
346 let content = resp.text().await?;
347 serde_json::from_str(&content).map_err(Error::from)
348 } else {
349 let content = resp.text().await?;
350 let entity: Option<GetProjectRoleDetailsError> = serde_json::from_str(&content).ok();
351 Err(Error::ResponseError(ResponseContent { status, content, entity }))
352 }
353}
354
355pub async fn get_project_roles(configuration: &configuration::Configuration, project_id_or_key: &str) -> Result<std::collections::HashMap<String, String>, Error<GetProjectRolesError>> {
357 let p_project_id_or_key = project_id_or_key;
359
360 let uri_str = format!("{}/rest/api/2/project/{projectIdOrKey}/role", configuration.base_path, projectIdOrKey=crate::apis::urlencode(p_project_id_or_key));
361 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
362
363 if let Some(ref user_agent) = configuration.user_agent {
364 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
365 }
366 if let Some(ref token) = configuration.oauth_access_token {
367 req_builder = req_builder.bearer_auth(token.to_owned());
368 };
369 if let Some(ref auth_conf) = configuration.basic_auth {
370 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
371 };
372
373 let req = req_builder.build()?;
374 let resp = configuration.client.execute(req).await?;
375
376 let status = resp.status();
377
378 if !status.is_client_error() && !status.is_server_error() {
379 let content = resp.text().await?;
380 serde_json::from_str(&content).map_err(Error::from)
381 } else {
382 let content = resp.text().await?;
383 let entity: Option<GetProjectRolesError> = serde_json::from_str(&content).ok();
384 Err(Error::ResponseError(ResponseContent { status, content, entity }))
385 }
386}
387
388pub async fn partial_update_project_role(configuration: &configuration::Configuration, id: i64, create_update_role_request_bean: models::CreateUpdateRoleRequestBean) -> Result<models::ProjectRole, Error<PartialUpdateProjectRoleError>> {
390 let p_id = id;
392 let p_create_update_role_request_bean = create_update_role_request_bean;
393
394 let uri_str = format!("{}/rest/api/2/role/{id}", configuration.base_path, id=p_id);
395 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
396
397 if let Some(ref user_agent) = configuration.user_agent {
398 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
399 }
400 if let Some(ref token) = configuration.oauth_access_token {
401 req_builder = req_builder.bearer_auth(token.to_owned());
402 };
403 if let Some(ref auth_conf) = configuration.basic_auth {
404 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
405 };
406 req_builder = req_builder.json(&p_create_update_role_request_bean);
407
408 let req = req_builder.build()?;
409 let resp = configuration.client.execute(req).await?;
410
411 let status = resp.status();
412
413 if !status.is_client_error() && !status.is_server_error() {
414 let content = resp.text().await?;
415 serde_json::from_str(&content).map_err(Error::from)
416 } else {
417 let content = resp.text().await?;
418 let entity: Option<PartialUpdateProjectRoleError> = serde_json::from_str(&content).ok();
419 Err(Error::ResponseError(ResponseContent { status, content, entity }))
420 }
421}
422