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 AddActorUsersError {
22 Status400(),
23 Status401(),
24 Status404(),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum AddProjectRoleActorsToRoleError {
32 Status400(),
33 Status401(),
34 Status403(),
35 Status404(),
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum DeleteActorError {
43 Status400(),
44 Status404(),
45 UnknownValue(serde_json::Value),
46}
47
48#[derive(Debug, Clone, Serialize, Deserialize)]
50#[serde(untagged)]
51pub enum DeleteProjectRoleActorsFromRoleError {
52 Status400(),
53 Status401(),
54 Status403(),
55 Status404(),
56 UnknownValue(serde_json::Value),
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum GetProjectRoleActorsForRoleError {
63 Status400(),
64 Status401(),
65 Status403(),
66 Status404(),
67 UnknownValue(serde_json::Value),
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum SetActorsError {
74 Status400(),
75 Status401(),
76 Status404(),
77 UnknownValue(serde_json::Value),
78}
79
80
81pub async fn add_actor_users(configuration: &configuration::Configuration, project_id_or_key: &str, id: i64, actors_map: models::ActorsMap) -> Result<models::ProjectRole, Error<AddActorUsersError>> {
83 let p_project_id_or_key = project_id_or_key;
85 let p_id = id;
86 let p_actors_map = actors_map;
87
88 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);
89 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
90
91 if let Some(ref user_agent) = configuration.user_agent {
92 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
93 }
94 if let Some(ref token) = configuration.oauth_access_token {
95 req_builder = req_builder.bearer_auth(token.to_owned());
96 };
97 if let Some(ref auth_conf) = configuration.basic_auth {
98 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
99 };
100 req_builder = req_builder.json(&p_actors_map);
101
102 let req = req_builder.build()?;
103 let resp = configuration.client.execute(req).await?;
104
105 let status = resp.status();
106
107 if !status.is_client_error() && !status.is_server_error() {
108 let content = resp.text().await?;
109 serde_json::from_str(&content).map_err(Error::from)
110 } else {
111 let content = resp.text().await?;
112 let entity: Option<AddActorUsersError> = serde_json::from_str(&content).ok();
113 Err(Error::ResponseError(ResponseContent { status, content, entity }))
114 }
115}
116
117pub async fn add_project_role_actors_to_role(configuration: &configuration::Configuration, id: i64, actor_input_bean: models::ActorInputBean) -> Result<models::ProjectRole, Error<AddProjectRoleActorsToRoleError>> {
119 let p_id = id;
121 let p_actor_input_bean = actor_input_bean;
122
123 let uri_str = format!("{}/rest/api/2/role/{id}/actors", configuration.base_path, id=p_id);
124 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
125
126 if let Some(ref user_agent) = configuration.user_agent {
127 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
128 }
129 if let Some(ref token) = configuration.oauth_access_token {
130 req_builder = req_builder.bearer_auth(token.to_owned());
131 };
132 if let Some(ref auth_conf) = configuration.basic_auth {
133 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
134 };
135 req_builder = req_builder.json(&p_actor_input_bean);
136
137 let req = req_builder.build()?;
138 let resp = configuration.client.execute(req).await?;
139
140 let status = resp.status();
141
142 if !status.is_client_error() && !status.is_server_error() {
143 let content = resp.text().await?;
144 serde_json::from_str(&content).map_err(Error::from)
145 } else {
146 let content = resp.text().await?;
147 let entity: Option<AddProjectRoleActorsToRoleError> = serde_json::from_str(&content).ok();
148 Err(Error::ResponseError(ResponseContent { status, content, entity }))
149 }
150}
151
152pub async fn delete_actor(configuration: &configuration::Configuration, project_id_or_key: &str, id: i64, user: Option<&str>, group: Option<&str>) -> Result<(), Error<DeleteActorError>> {
154 let p_project_id_or_key = project_id_or_key;
156 let p_id = id;
157 let p_user = user;
158 let p_group = group;
159
160 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);
161 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
162
163 if let Some(ref param_value) = p_user {
164 req_builder = req_builder.query(&[("user", ¶m_value.to_string())]);
165 }
166 if let Some(ref param_value) = p_group {
167 req_builder = req_builder.query(&[("group", ¶m_value.to_string())]);
168 }
169 if let Some(ref user_agent) = configuration.user_agent {
170 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
171 }
172 if let Some(ref token) = configuration.oauth_access_token {
173 req_builder = req_builder.bearer_auth(token.to_owned());
174 };
175 if let Some(ref auth_conf) = configuration.basic_auth {
176 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
177 };
178
179 let req = req_builder.build()?;
180 let resp = configuration.client.execute(req).await?;
181
182 let status = resp.status();
183
184 if !status.is_client_error() && !status.is_server_error() {
185 Ok(())
186 } else {
187 let content = resp.text().await?;
188 let entity: Option<DeleteActorError> = serde_json::from_str(&content).ok();
189 Err(Error::ResponseError(ResponseContent { status, content, entity }))
190 }
191}
192
193pub async fn delete_project_role_actors_from_role(configuration: &configuration::Configuration, id: i64, user: Option<&str>, group: Option<&str>) -> Result<models::ProjectRole, Error<DeleteProjectRoleActorsFromRoleError>> {
195 let p_id = id;
197 let p_user = user;
198 let p_group = group;
199
200 let uri_str = format!("{}/rest/api/2/role/{id}/actors", configuration.base_path, id=p_id);
201 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
202
203 if let Some(ref param_value) = p_user {
204 req_builder = req_builder.query(&[("user", ¶m_value.to_string())]);
205 }
206 if let Some(ref param_value) = p_group {
207 req_builder = req_builder.query(&[("group", ¶m_value.to_string())]);
208 }
209 if let Some(ref user_agent) = configuration.user_agent {
210 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
211 }
212 if let Some(ref token) = configuration.oauth_access_token {
213 req_builder = req_builder.bearer_auth(token.to_owned());
214 };
215 if let Some(ref auth_conf) = configuration.basic_auth {
216 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
217 };
218
219 let req = req_builder.build()?;
220 let resp = configuration.client.execute(req).await?;
221
222 let status = resp.status();
223
224 if !status.is_client_error() && !status.is_server_error() {
225 let content = resp.text().await?;
226 serde_json::from_str(&content).map_err(Error::from)
227 } else {
228 let content = resp.text().await?;
229 let entity: Option<DeleteProjectRoleActorsFromRoleError> = serde_json::from_str(&content).ok();
230 Err(Error::ResponseError(ResponseContent { status, content, entity }))
231 }
232}
233
234pub async fn get_project_role_actors_for_role(configuration: &configuration::Configuration, id: i64) -> Result<models::ProjectRole, Error<GetProjectRoleActorsForRoleError>> {
236 let p_id = id;
238
239 let uri_str = format!("{}/rest/api/2/role/{id}/actors", configuration.base_path, id=p_id);
240 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
241
242 if let Some(ref user_agent) = configuration.user_agent {
243 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
244 }
245 if let Some(ref token) = configuration.oauth_access_token {
246 req_builder = req_builder.bearer_auth(token.to_owned());
247 };
248 if let Some(ref auth_conf) = configuration.basic_auth {
249 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
250 };
251
252 let req = req_builder.build()?;
253 let resp = configuration.client.execute(req).await?;
254
255 let status = resp.status();
256
257 if !status.is_client_error() && !status.is_server_error() {
258 let content = resp.text().await?;
259 serde_json::from_str(&content).map_err(Error::from)
260 } else {
261 let content = resp.text().await?;
262 let entity: Option<GetProjectRoleActorsForRoleError> = serde_json::from_str(&content).ok();
263 Err(Error::ResponseError(ResponseContent { status, content, entity }))
264 }
265}
266
267pub async fn set_actors(configuration: &configuration::Configuration, project_id_or_key: &str, id: i64, project_role_actors_update_bean: models::ProjectRoleActorsUpdateBean) -> Result<models::ProjectRole, Error<SetActorsError>> {
269 let p_project_id_or_key = project_id_or_key;
271 let p_id = id;
272 let p_project_role_actors_update_bean = project_role_actors_update_bean;
273
274 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);
275 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
276
277 if let Some(ref user_agent) = configuration.user_agent {
278 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
279 }
280 if let Some(ref token) = configuration.oauth_access_token {
281 req_builder = req_builder.bearer_auth(token.to_owned());
282 };
283 if let Some(ref auth_conf) = configuration.basic_auth {
284 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
285 };
286 req_builder = req_builder.json(&p_project_role_actors_update_bean);
287
288 let req = req_builder.build()?;
289 let resp = configuration.client.execute(req).await?;
290
291 let status = resp.status();
292
293 if !status.is_client_error() && !status.is_server_error() {
294 let content = resp.text().await?;
295 serde_json::from_str(&content).map_err(Error::from)
296 } else {
297 let content = resp.text().await?;
298 let entity: Option<SetActorsError> = serde_json::from_str(&content).ok();
299 Err(Error::ResponseError(ResponseContent { status, content, entity }))
300 }
301}
302