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 AddFieldToDefaultScreenError {
22 Status401(),
23 Status403(),
24 Status404(),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum CreateScreenError {
32 Status400(),
33 Status401(),
34 Status403(),
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum DeleteScreenError {
42 Status400(),
43 Status401(),
44 Status403(),
45 Status404(),
46 UnknownValue(serde_json::Value),
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(untagged)]
52pub enum GetAvailableScreenFieldsError {
53 Status401(),
54 Status403(),
55 Status404(),
56 UnknownValue(serde_json::Value),
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum GetScreensError {
63 Status401(),
64 Status403(),
65 UnknownValue(serde_json::Value),
66}
67
68#[derive(Debug, Clone, Serialize, Deserialize)]
70#[serde(untagged)]
71pub enum GetScreensForFieldError {
72 Status401(),
73 Status403(),
74 UnknownValue(serde_json::Value),
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize)]
79#[serde(untagged)]
80pub enum UpdateScreenError {
81 Status400(),
82 Status401(),
83 Status403(),
84 Status404(),
85 UnknownValue(serde_json::Value),
86}
87
88
89pub async fn add_field_to_default_screen(configuration: &configuration::Configuration, field_id: &str) -> Result<serde_json::Value, Error<AddFieldToDefaultScreenError>> {
91 let p_field_id = field_id;
93
94 let uri_str = format!("{}/rest/api/2/screens/addToDefault/{fieldId}", configuration.base_path, fieldId=crate::apis::urlencode(p_field_id));
95 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
96
97 if let Some(ref user_agent) = configuration.user_agent {
98 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
99 }
100 if let Some(ref token) = configuration.oauth_access_token {
101 req_builder = req_builder.bearer_auth(token.to_owned());
102 };
103 if let Some(ref auth_conf) = configuration.basic_auth {
104 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
105 };
106
107 let req = req_builder.build()?;
108 let resp = configuration.client.execute(req).await?;
109
110 let status = resp.status();
111
112 if !status.is_client_error() && !status.is_server_error() {
113 let content = resp.text().await?;
114 serde_json::from_str(&content).map_err(Error::from)
115 } else {
116 let content = resp.text().await?;
117 let entity: Option<AddFieldToDefaultScreenError> = serde_json::from_str(&content).ok();
118 Err(Error::ResponseError(ResponseContent { status, content, entity }))
119 }
120}
121
122pub async fn create_screen(configuration: &configuration::Configuration, screen_details: models::ScreenDetails) -> Result<models::Screen, Error<CreateScreenError>> {
124 let p_screen_details = screen_details;
126
127 let uri_str = format!("{}/rest/api/2/screens", configuration.base_path);
128 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
129
130 if let Some(ref user_agent) = configuration.user_agent {
131 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
132 }
133 if let Some(ref token) = configuration.oauth_access_token {
134 req_builder = req_builder.bearer_auth(token.to_owned());
135 };
136 if let Some(ref auth_conf) = configuration.basic_auth {
137 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
138 };
139 req_builder = req_builder.json(&p_screen_details);
140
141 let req = req_builder.build()?;
142 let resp = configuration.client.execute(req).await?;
143
144 let status = resp.status();
145
146 if !status.is_client_error() && !status.is_server_error() {
147 let content = resp.text().await?;
148 serde_json::from_str(&content).map_err(Error::from)
149 } else {
150 let content = resp.text().await?;
151 let entity: Option<CreateScreenError> = serde_json::from_str(&content).ok();
152 Err(Error::ResponseError(ResponseContent { status, content, entity }))
153 }
154}
155
156pub async fn delete_screen(configuration: &configuration::Configuration, screen_id: i64) -> Result<(), Error<DeleteScreenError>> {
158 let p_screen_id = screen_id;
160
161 let uri_str = format!("{}/rest/api/2/screens/{screenId}", configuration.base_path, screenId=p_screen_id);
162 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
163
164 if let Some(ref user_agent) = configuration.user_agent {
165 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
166 }
167 if let Some(ref token) = configuration.oauth_access_token {
168 req_builder = req_builder.bearer_auth(token.to_owned());
169 };
170 if let Some(ref auth_conf) = configuration.basic_auth {
171 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
172 };
173
174 let req = req_builder.build()?;
175 let resp = configuration.client.execute(req).await?;
176
177 let status = resp.status();
178
179 if !status.is_client_error() && !status.is_server_error() {
180 Ok(())
181 } else {
182 let content = resp.text().await?;
183 let entity: Option<DeleteScreenError> = serde_json::from_str(&content).ok();
184 Err(Error::ResponseError(ResponseContent { status, content, entity }))
185 }
186}
187
188pub async fn get_available_screen_fields(configuration: &configuration::Configuration, screen_id: i64) -> Result<Vec<models::ScreenableField>, Error<GetAvailableScreenFieldsError>> {
190 let p_screen_id = screen_id;
192
193 let uri_str = format!("{}/rest/api/2/screens/{screenId}/availableFields", configuration.base_path, screenId=p_screen_id);
194 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
195
196 if let Some(ref user_agent) = configuration.user_agent {
197 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
198 }
199 if let Some(ref token) = configuration.oauth_access_token {
200 req_builder = req_builder.bearer_auth(token.to_owned());
201 };
202 if let Some(ref auth_conf) = configuration.basic_auth {
203 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
204 };
205
206 let req = req_builder.build()?;
207 let resp = configuration.client.execute(req).await?;
208
209 let status = resp.status();
210
211 if !status.is_client_error() && !status.is_server_error() {
212 let content = resp.text().await?;
213 serde_json::from_str(&content).map_err(Error::from)
214 } else {
215 let content = resp.text().await?;
216 let entity: Option<GetAvailableScreenFieldsError> = serde_json::from_str(&content).ok();
217 Err(Error::ResponseError(ResponseContent { status, content, entity }))
218 }
219}
220
221pub async fn get_screens(configuration: &configuration::Configuration, start_at: Option<i64>, max_results: Option<i32>, id: Option<Vec<i64>>) -> Result<models::PageBeanScreen, Error<GetScreensError>> {
223 let p_start_at = start_at;
225 let p_max_results = max_results;
226 let p_id = id;
227
228 let uri_str = format!("{}/rest/api/2/screens", configuration.base_path);
229 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
230
231 if let Some(ref param_value) = p_start_at {
232 req_builder = req_builder.query(&[("startAt", ¶m_value.to_string())]);
233 }
234 if let Some(ref param_value) = p_max_results {
235 req_builder = req_builder.query(&[("maxResults", ¶m_value.to_string())]);
236 }
237 if let Some(ref param_value) = p_id {
238 req_builder = match "multi" {
239 "multi" => req_builder.query(¶m_value.into_iter().map(|p| ("id".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
240 _ => req_builder.query(&[("id", ¶m_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
241 };
242 }
243 if let Some(ref user_agent) = configuration.user_agent {
244 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
245 }
246 if let Some(ref token) = configuration.oauth_access_token {
247 req_builder = req_builder.bearer_auth(token.to_owned());
248 };
249 if let Some(ref auth_conf) = configuration.basic_auth {
250 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
251 };
252
253 let req = req_builder.build()?;
254 let resp = configuration.client.execute(req).await?;
255
256 let status = resp.status();
257
258 if !status.is_client_error() && !status.is_server_error() {
259 let content = resp.text().await?;
260 serde_json::from_str(&content).map_err(Error::from)
261 } else {
262 let content = resp.text().await?;
263 let entity: Option<GetScreensError> = serde_json::from_str(&content).ok();
264 Err(Error::ResponseError(ResponseContent { status, content, entity }))
265 }
266}
267
268pub async fn get_screens_for_field(configuration: &configuration::Configuration, field_id: &str, start_at: Option<i64>, max_results: Option<i32>, expand: Option<&str>) -> Result<models::PageBeanScreenWithTab, Error<GetScreensForFieldError>> {
270 let p_field_id = field_id;
272 let p_start_at = start_at;
273 let p_max_results = max_results;
274 let p_expand = expand;
275
276 let uri_str = format!("{}/rest/api/2/field/{fieldId}/screens", configuration.base_path, fieldId=crate::apis::urlencode(p_field_id));
277 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
278
279 if let Some(ref param_value) = p_start_at {
280 req_builder = req_builder.query(&[("startAt", ¶m_value.to_string())]);
281 }
282 if let Some(ref param_value) = p_max_results {
283 req_builder = req_builder.query(&[("maxResults", ¶m_value.to_string())]);
284 }
285 if let Some(ref param_value) = p_expand {
286 req_builder = req_builder.query(&[("expand", ¶m_value.to_string())]);
287 }
288 if let Some(ref user_agent) = configuration.user_agent {
289 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
290 }
291 if let Some(ref token) = configuration.oauth_access_token {
292 req_builder = req_builder.bearer_auth(token.to_owned());
293 };
294 if let Some(ref auth_conf) = configuration.basic_auth {
295 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
296 };
297
298 let req = req_builder.build()?;
299 let resp = configuration.client.execute(req).await?;
300
301 let status = resp.status();
302
303 if !status.is_client_error() && !status.is_server_error() {
304 let content = resp.text().await?;
305 serde_json::from_str(&content).map_err(Error::from)
306 } else {
307 let content = resp.text().await?;
308 let entity: Option<GetScreensForFieldError> = serde_json::from_str(&content).ok();
309 Err(Error::ResponseError(ResponseContent { status, content, entity }))
310 }
311}
312
313pub async fn update_screen(configuration: &configuration::Configuration, screen_id: i64, update_screen_details: models::UpdateScreenDetails) -> Result<models::Screen, Error<UpdateScreenError>> {
315 let p_screen_id = screen_id;
317 let p_update_screen_details = update_screen_details;
318
319 let uri_str = format!("{}/rest/api/2/screens/{screenId}", configuration.base_path, screenId=p_screen_id);
320 let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
321
322 if let Some(ref user_agent) = configuration.user_agent {
323 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
324 }
325 if let Some(ref token) = configuration.oauth_access_token {
326 req_builder = req_builder.bearer_auth(token.to_owned());
327 };
328 if let Some(ref auth_conf) = configuration.basic_auth {
329 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
330 };
331 req_builder = req_builder.json(&p_update_screen_details);
332
333 let req = req_builder.build()?;
334 let resp = configuration.client.execute(req).await?;
335
336 let status = resp.status();
337
338 if !status.is_client_error() && !status.is_server_error() {
339 let content = resp.text().await?;
340 serde_json::from_str(&content).map_err(Error::from)
341 } else {
342 let content = resp.text().await?;
343 let entity: Option<UpdateScreenError> = serde_json::from_str(&content).ok();
344 Err(Error::ResponseError(ResponseContent { status, content, entity }))
345 }
346}
347