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 CreateIssueFieldOptionError {
22 Status400(),
23 Status403(),
24 Status404(),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum DeleteIssueFieldOptionError {
32 Status403(),
33 Status404(),
34 Status409(),
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum GetAllIssueFieldOptionsError {
42 Status400(),
43 Status403(),
44 UnknownValue(serde_json::Value),
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(untagged)]
50pub enum GetIssueFieldOptionError {
51 Status400(),
52 Status403(),
53 Status404(),
54 UnknownValue(serde_json::Value),
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum GetSelectableIssueFieldOptionsError {
61 Status401(),
62 Status404(),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum GetVisibleIssueFieldOptionsError {
70 Status401(),
71 Status404(),
72 UnknownValue(serde_json::Value),
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize)]
77#[serde(untagged)]
78pub enum ReplaceIssueFieldOptionError {
79 Status400(),
80 Status404(),
81 UnknownValue(serde_json::Value),
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize)]
86#[serde(untagged)]
87pub enum UpdateIssueFieldOptionError {
88 Status400(),
89 Status403(),
90 Status404(),
91 UnknownValue(serde_json::Value),
92}
93
94
95pub async fn create_issue_field_option(configuration: &configuration::Configuration, field_key: &str, issue_field_option_create_bean: models::IssueFieldOptionCreateBean) -> Result<models::IssueFieldOption, Error<CreateIssueFieldOptionError>> {
97 let p_field_key = field_key;
99 let p_issue_field_option_create_bean = issue_field_option_create_bean;
100
101 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key));
102 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
103
104 if let Some(ref user_agent) = configuration.user_agent {
105 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
106 }
107 if let Some(ref token) = configuration.oauth_access_token {
108 req_builder = req_builder.bearer_auth(token.to_owned());
109 };
110 if let Some(ref auth_conf) = configuration.basic_auth {
111 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
112 };
113 req_builder = req_builder.json(&p_issue_field_option_create_bean);
114
115 let req = req_builder.build()?;
116 let resp = configuration.client.execute(req).await?;
117
118 let status = resp.status();
119
120 if !status.is_client_error() && !status.is_server_error() {
121 let content = resp.text().await?;
122 serde_json::from_str(&content).map_err(Error::from)
123 } else {
124 let content = resp.text().await?;
125 let entity: Option<CreateIssueFieldOptionError> = serde_json::from_str(&content).ok();
126 Err(Error::ResponseError(ResponseContent { status, content, entity }))
127 }
128}
129
130pub async fn delete_issue_field_option(configuration: &configuration::Configuration, field_key: &str, option_id: i64) -> Result<serde_json::Value, Error<DeleteIssueFieldOptionError>> {
132 let p_field_key = field_key;
134 let p_option_id = option_id;
135
136 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option/{optionId}", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key), optionId=p_option_id);
137 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
138
139 if let Some(ref user_agent) = configuration.user_agent {
140 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
141 }
142 if let Some(ref token) = configuration.oauth_access_token {
143 req_builder = req_builder.bearer_auth(token.to_owned());
144 };
145 if let Some(ref auth_conf) = configuration.basic_auth {
146 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
147 };
148
149 let req = req_builder.build()?;
150 let resp = configuration.client.execute(req).await?;
151
152 let status = resp.status();
153
154 if !status.is_client_error() && !status.is_server_error() {
155 let content = resp.text().await?;
156 serde_json::from_str(&content).map_err(Error::from)
157 } else {
158 let content = resp.text().await?;
159 let entity: Option<DeleteIssueFieldOptionError> = serde_json::from_str(&content).ok();
160 Err(Error::ResponseError(ResponseContent { status, content, entity }))
161 }
162}
163
164pub async fn get_all_issue_field_options(configuration: &configuration::Configuration, field_key: &str, start_at: Option<i64>, max_results: Option<i32>) -> Result<models::PageBeanIssueFieldOption, Error<GetAllIssueFieldOptionsError>> {
166 let p_field_key = field_key;
168 let p_start_at = start_at;
169 let p_max_results = max_results;
170
171 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key));
172 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
173
174 if let Some(ref param_value) = p_start_at {
175 req_builder = req_builder.query(&[("startAt", ¶m_value.to_string())]);
176 }
177 if let Some(ref param_value) = p_max_results {
178 req_builder = req_builder.query(&[("maxResults", ¶m_value.to_string())]);
179 }
180 if let Some(ref user_agent) = configuration.user_agent {
181 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
182 }
183 if let Some(ref token) = configuration.oauth_access_token {
184 req_builder = req_builder.bearer_auth(token.to_owned());
185 };
186 if let Some(ref auth_conf) = configuration.basic_auth {
187 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
188 };
189
190 let req = req_builder.build()?;
191 let resp = configuration.client.execute(req).await?;
192
193 let status = resp.status();
194
195 if !status.is_client_error() && !status.is_server_error() {
196 let content = resp.text().await?;
197 serde_json::from_str(&content).map_err(Error::from)
198 } else {
199 let content = resp.text().await?;
200 let entity: Option<GetAllIssueFieldOptionsError> = serde_json::from_str(&content).ok();
201 Err(Error::ResponseError(ResponseContent { status, content, entity }))
202 }
203}
204
205pub async fn get_issue_field_option(configuration: &configuration::Configuration, field_key: &str, option_id: i64) -> Result<models::IssueFieldOption, Error<GetIssueFieldOptionError>> {
207 let p_field_key = field_key;
209 let p_option_id = option_id;
210
211 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option/{optionId}", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key), optionId=p_option_id);
212 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
213
214 if let Some(ref user_agent) = configuration.user_agent {
215 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
216 }
217 if let Some(ref token) = configuration.oauth_access_token {
218 req_builder = req_builder.bearer_auth(token.to_owned());
219 };
220 if let Some(ref auth_conf) = configuration.basic_auth {
221 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
222 };
223
224 let req = req_builder.build()?;
225 let resp = configuration.client.execute(req).await?;
226
227 let status = resp.status();
228
229 if !status.is_client_error() && !status.is_server_error() {
230 let content = resp.text().await?;
231 serde_json::from_str(&content).map_err(Error::from)
232 } else {
233 let content = resp.text().await?;
234 let entity: Option<GetIssueFieldOptionError> = serde_json::from_str(&content).ok();
235 Err(Error::ResponseError(ResponseContent { status, content, entity }))
236 }
237}
238
239pub async fn get_selectable_issue_field_options(configuration: &configuration::Configuration, field_key: &str, start_at: Option<i64>, max_results: Option<i32>, project_id: Option<i64>) -> Result<models::PageBeanIssueFieldOption, Error<GetSelectableIssueFieldOptionsError>> {
241 let p_field_key = field_key;
243 let p_start_at = start_at;
244 let p_max_results = max_results;
245 let p_project_id = project_id;
246
247 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option/suggestions/edit", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key));
248 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
249
250 if let Some(ref param_value) = p_start_at {
251 req_builder = req_builder.query(&[("startAt", ¶m_value.to_string())]);
252 }
253 if let Some(ref param_value) = p_max_results {
254 req_builder = req_builder.query(&[("maxResults", ¶m_value.to_string())]);
255 }
256 if let Some(ref param_value) = p_project_id {
257 req_builder = req_builder.query(&[("projectId", ¶m_value.to_string())]);
258 }
259 if let Some(ref user_agent) = configuration.user_agent {
260 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
261 }
262 if let Some(ref token) = configuration.oauth_access_token {
263 req_builder = req_builder.bearer_auth(token.to_owned());
264 };
265 if let Some(ref auth_conf) = configuration.basic_auth {
266 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
267 };
268
269 let req = req_builder.build()?;
270 let resp = configuration.client.execute(req).await?;
271
272 let status = resp.status();
273
274 if !status.is_client_error() && !status.is_server_error() {
275 let content = resp.text().await?;
276 serde_json::from_str(&content).map_err(Error::from)
277 } else {
278 let content = resp.text().await?;
279 let entity: Option<GetSelectableIssueFieldOptionsError> = serde_json::from_str(&content).ok();
280 Err(Error::ResponseError(ResponseContent { status, content, entity }))
281 }
282}
283
284pub async fn get_visible_issue_field_options(configuration: &configuration::Configuration, field_key: &str, start_at: Option<i64>, max_results: Option<i32>, project_id: Option<i64>) -> Result<models::PageBeanIssueFieldOption, Error<GetVisibleIssueFieldOptionsError>> {
286 let p_field_key = field_key;
288 let p_start_at = start_at;
289 let p_max_results = max_results;
290 let p_project_id = project_id;
291
292 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option/suggestions/search", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key));
293 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
294
295 if let Some(ref param_value) = p_start_at {
296 req_builder = req_builder.query(&[("startAt", ¶m_value.to_string())]);
297 }
298 if let Some(ref param_value) = p_max_results {
299 req_builder = req_builder.query(&[("maxResults", ¶m_value.to_string())]);
300 }
301 if let Some(ref param_value) = p_project_id {
302 req_builder = req_builder.query(&[("projectId", ¶m_value.to_string())]);
303 }
304 if let Some(ref user_agent) = configuration.user_agent {
305 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
306 }
307 if let Some(ref token) = configuration.oauth_access_token {
308 req_builder = req_builder.bearer_auth(token.to_owned());
309 };
310 if let Some(ref auth_conf) = configuration.basic_auth {
311 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
312 };
313
314 let req = req_builder.build()?;
315 let resp = configuration.client.execute(req).await?;
316
317 let status = resp.status();
318
319 if !status.is_client_error() && !status.is_server_error() {
320 let content = resp.text().await?;
321 serde_json::from_str(&content).map_err(Error::from)
322 } else {
323 let content = resp.text().await?;
324 let entity: Option<GetVisibleIssueFieldOptionsError> = serde_json::from_str(&content).ok();
325 Err(Error::ResponseError(ResponseContent { status, content, entity }))
326 }
327}
328
329pub async fn replace_issue_field_option(configuration: &configuration::Configuration, field_key: &str, option_id: i64, replace_with: Option<i64>, jql: Option<&str>) -> Result<(), Error<ReplaceIssueFieldOptionError>> {
331 let p_field_key = field_key;
333 let p_option_id = option_id;
334 let p_replace_with = replace_with;
335 let p_jql = jql;
336
337 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option/{optionId}/issue", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key), optionId=p_option_id);
338 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
339
340 if let Some(ref param_value) = p_replace_with {
341 req_builder = req_builder.query(&[("replaceWith", ¶m_value.to_string())]);
342 }
343 if let Some(ref param_value) = p_jql {
344 req_builder = req_builder.query(&[("jql", ¶m_value.to_string())]);
345 }
346 if let Some(ref user_agent) = configuration.user_agent {
347 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
348 }
349 if let Some(ref token) = configuration.oauth_access_token {
350 req_builder = req_builder.bearer_auth(token.to_owned());
351 };
352 if let Some(ref auth_conf) = configuration.basic_auth {
353 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
354 };
355
356 let req = req_builder.build()?;
357 let resp = configuration.client.execute(req).await?;
358
359 let status = resp.status();
360
361 if !status.is_client_error() && !status.is_server_error() {
362 Ok(())
363 } else {
364 let content = resp.text().await?;
365 let entity: Option<ReplaceIssueFieldOptionError> = serde_json::from_str(&content).ok();
366 Err(Error::ResponseError(ResponseContent { status, content, entity }))
367 }
368}
369
370pub async fn update_issue_field_option(configuration: &configuration::Configuration, field_key: &str, option_id: i64, issue_field_option: models::IssueFieldOption) -> Result<models::IssueFieldOption, Error<UpdateIssueFieldOptionError>> {
372 let p_field_key = field_key;
374 let p_option_id = option_id;
375 let p_issue_field_option = issue_field_option;
376
377 let uri_str = format!("{}/rest/api/2/field/{fieldKey}/option/{optionId}", configuration.base_path, fieldKey=crate::apis::urlencode(p_field_key), optionId=p_option_id);
378 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
379
380 if let Some(ref user_agent) = configuration.user_agent {
381 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
382 }
383 if let Some(ref token) = configuration.oauth_access_token {
384 req_builder = req_builder.bearer_auth(token.to_owned());
385 };
386 if let Some(ref auth_conf) = configuration.basic_auth {
387 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
388 };
389 req_builder = req_builder.json(&p_issue_field_option);
390
391 let req = req_builder.build()?;
392 let resp = configuration.client.execute(req).await?;
393
394 let status = resp.status();
395
396 if !status.is_client_error() && !status.is_server_error() {
397 let content = resp.text().await?;
398 serde_json::from_str(&content).map_err(Error::from)
399 } else {
400 let content = resp.text().await?;
401 let entity: Option<UpdateIssueFieldOptionError> = serde_json::from_str(&content).ok();
402 Err(Error::ResponseError(ResponseContent { status, content, entity }))
403 }
404}
405