jira_api_v2/apis/
screen_schemes_api.rs1use 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 CreateScreenSchemeError {
22 Status400(),
23 Status401(),
24 Status403(),
25 Status404(),
26 UnknownValue(serde_json::Value),
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize)]
31#[serde(untagged)]
32pub enum DeleteScreenSchemeError {
33 Status400(),
34 Status401(),
35 Status403(),
36 Status404(),
37 UnknownValue(serde_json::Value),
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum GetScreenSchemesError {
44 Status401(),
45 Status403(),
46 UnknownValue(serde_json::Value),
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(untagged)]
52pub enum UpdateScreenSchemeError {
53 Status400(),
54 Status401(),
55 Status403(),
56 Status404(),
57 UnknownValue(serde_json::Value),
58}
59
60
61pub async fn create_screen_scheme(configuration: &configuration::Configuration, screen_scheme_details: models::ScreenSchemeDetails) -> Result<models::ScreenSchemeId, Error<CreateScreenSchemeError>> {
63 let p_screen_scheme_details = screen_scheme_details;
65
66 let uri_str = format!("{}/rest/api/2/screenscheme", configuration.base_path);
67 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
68
69 if let Some(ref user_agent) = configuration.user_agent {
70 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
71 }
72 if let Some(ref token) = configuration.oauth_access_token {
73 req_builder = req_builder.bearer_auth(token.to_owned());
74 };
75 if let Some(ref auth_conf) = configuration.basic_auth {
76 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
77 };
78 req_builder = req_builder.json(&p_screen_scheme_details);
79
80 let req = req_builder.build()?;
81 let resp = configuration.client.execute(req).await?;
82
83 let status = resp.status();
84
85 if !status.is_client_error() && !status.is_server_error() {
86 let content = resp.text().await?;
87 serde_json::from_str(&content).map_err(Error::from)
88 } else {
89 let content = resp.text().await?;
90 let entity: Option<CreateScreenSchemeError> = serde_json::from_str(&content).ok();
91 Err(Error::ResponseError(ResponseContent { status, content, entity }))
92 }
93}
94
95pub async fn delete_screen_scheme(configuration: &configuration::Configuration, screen_scheme_id: &str) -> Result<(), Error<DeleteScreenSchemeError>> {
97 let p_screen_scheme_id = screen_scheme_id;
99
100 let uri_str = format!("{}/rest/api/2/screenscheme/{screenSchemeId}", configuration.base_path, screenSchemeId=crate::apis::urlencode(p_screen_scheme_id));
101 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
102
103 if let Some(ref user_agent) = configuration.user_agent {
104 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
105 }
106 if let Some(ref token) = configuration.oauth_access_token {
107 req_builder = req_builder.bearer_auth(token.to_owned());
108 };
109 if let Some(ref auth_conf) = configuration.basic_auth {
110 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
111 };
112
113 let req = req_builder.build()?;
114 let resp = configuration.client.execute(req).await?;
115
116 let status = resp.status();
117
118 if !status.is_client_error() && !status.is_server_error() {
119 Ok(())
120 } else {
121 let content = resp.text().await?;
122 let entity: Option<DeleteScreenSchemeError> = serde_json::from_str(&content).ok();
123 Err(Error::ResponseError(ResponseContent { status, content, entity }))
124 }
125}
126
127pub async fn get_screen_schemes(configuration: &configuration::Configuration, start_at: Option<i64>, max_results: Option<i32>, id: Option<Vec<i64>>) -> Result<models::PageBeanScreenScheme, Error<GetScreenSchemesError>> {
129 let p_start_at = start_at;
131 let p_max_results = max_results;
132 let p_id = id;
133
134 let uri_str = format!("{}/rest/api/2/screenscheme", configuration.base_path);
135 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
136
137 if let Some(ref param_value) = p_start_at {
138 req_builder = req_builder.query(&[("startAt", ¶m_value.to_string())]);
139 }
140 if let Some(ref param_value) = p_max_results {
141 req_builder = req_builder.query(&[("maxResults", ¶m_value.to_string())]);
142 }
143 if let Some(ref param_value) = p_id {
144 req_builder = match "multi" {
145 "multi" => req_builder.query(¶m_value.into_iter().map(|p| ("id".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
146 _ => req_builder.query(&[("id", ¶m_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
147 };
148 }
149 if let Some(ref user_agent) = configuration.user_agent {
150 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
151 }
152 if let Some(ref token) = configuration.oauth_access_token {
153 req_builder = req_builder.bearer_auth(token.to_owned());
154 };
155 if let Some(ref auth_conf) = configuration.basic_auth {
156 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
157 };
158
159 let req = req_builder.build()?;
160 let resp = configuration.client.execute(req).await?;
161
162 let status = resp.status();
163
164 if !status.is_client_error() && !status.is_server_error() {
165 let content = resp.text().await?;
166 serde_json::from_str(&content).map_err(Error::from)
167 } else {
168 let content = resp.text().await?;
169 let entity: Option<GetScreenSchemesError> = serde_json::from_str(&content).ok();
170 Err(Error::ResponseError(ResponseContent { status, content, entity }))
171 }
172}
173
174pub async fn update_screen_scheme(configuration: &configuration::Configuration, screen_scheme_id: &str, update_screen_scheme_details: models::UpdateScreenSchemeDetails) -> Result<serde_json::Value, Error<UpdateScreenSchemeError>> {
176 let p_screen_scheme_id = screen_scheme_id;
178 let p_update_screen_scheme_details = update_screen_scheme_details;
179
180 let uri_str = format!("{}/rest/api/2/screenscheme/{screenSchemeId}", configuration.base_path, screenSchemeId=crate::apis::urlencode(p_screen_scheme_id));
181 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
182
183 if let Some(ref user_agent) = configuration.user_agent {
184 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
185 }
186 if let Some(ref token) = configuration.oauth_access_token {
187 req_builder = req_builder.bearer_auth(token.to_owned());
188 };
189 if let Some(ref auth_conf) = configuration.basic_auth {
190 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
191 };
192 req_builder = req_builder.json(&p_update_screen_scheme_details);
193
194 let req = req_builder.build()?;
195 let resp = configuration.client.execute(req).await?;
196
197 let status = resp.status();
198
199 if !status.is_client_error() && !status.is_server_error() {
200 let content = resp.text().await?;
201 serde_json::from_str(&content).map_err(Error::from)
202 } else {
203 let content = resp.text().await?;
204 let entity: Option<UpdateScreenSchemeError> = serde_json::from_str(&content).ok();
205 Err(Error::ResponseError(ResponseContent { status, content, entity }))
206 }
207}
208