jira_api_v2/apis/
jql_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 GetAutoCompleteError {
22 Status401(),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum GetFieldAutoCompleteForQueryStringError {
30 Status400(),
31 Status401(),
32 UnknownValue(serde_json::Value),
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
37#[serde(untagged)]
38pub enum MigrateQueriesError {
39 Status400(),
40 Status401(),
41 UnknownValue(serde_json::Value),
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum ParseJqlQueriesError {
48 Status400(models::ErrorCollection),
49 Status401(),
50 UnknownValue(serde_json::Value),
51}
52
53
54pub async fn get_auto_complete(configuration: &configuration::Configuration, ) -> Result<models::JqlReferenceData, Error<GetAutoCompleteError>> {
56
57 let uri_str = format!("{}/rest/api/2/jql/autocompletedata", configuration.base_path);
58 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
59
60 if let Some(ref user_agent) = configuration.user_agent {
61 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
62 }
63 if let Some(ref token) = configuration.oauth_access_token {
64 req_builder = req_builder.bearer_auth(token.to_owned());
65 };
66 if let Some(ref auth_conf) = configuration.basic_auth {
67 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
68 };
69
70 let req = req_builder.build()?;
71 let resp = configuration.client.execute(req).await?;
72
73 let status = resp.status();
74
75 if !status.is_client_error() && !status.is_server_error() {
76 let content = resp.text().await?;
77 serde_json::from_str(&content).map_err(Error::from)
78 } else {
79 let content = resp.text().await?;
80 let entity: Option<GetAutoCompleteError> = serde_json::from_str(&content).ok();
81 Err(Error::ResponseError(ResponseContent { status, content, entity }))
82 }
83}
84
85pub async fn get_field_auto_complete_for_query_string(configuration: &configuration::Configuration, field_name: Option<&str>, field_value: Option<&str>, predicate_name: Option<&str>, predicate_value: Option<&str>) -> Result<models::AutoCompleteSuggestions, Error<GetFieldAutoCompleteForQueryStringError>> {
87 let p_field_name = field_name;
89 let p_field_value = field_value;
90 let p_predicate_name = predicate_name;
91 let p_predicate_value = predicate_value;
92
93 let uri_str = format!("{}/rest/api/2/jql/autocompletedata/suggestions", configuration.base_path);
94 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
95
96 if let Some(ref param_value) = p_field_name {
97 req_builder = req_builder.query(&[("fieldName", ¶m_value.to_string())]);
98 }
99 if let Some(ref param_value) = p_field_value {
100 req_builder = req_builder.query(&[("fieldValue", ¶m_value.to_string())]);
101 }
102 if let Some(ref param_value) = p_predicate_name {
103 req_builder = req_builder.query(&[("predicateName", ¶m_value.to_string())]);
104 }
105 if let Some(ref param_value) = p_predicate_value {
106 req_builder = req_builder.query(&[("predicateValue", ¶m_value.to_string())]);
107 }
108 if let Some(ref user_agent) = configuration.user_agent {
109 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
110 }
111 if let Some(ref token) = configuration.oauth_access_token {
112 req_builder = req_builder.bearer_auth(token.to_owned());
113 };
114 if let Some(ref auth_conf) = configuration.basic_auth {
115 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
116 };
117
118 let req = req_builder.build()?;
119 let resp = configuration.client.execute(req).await?;
120
121 let status = resp.status();
122
123 if !status.is_client_error() && !status.is_server_error() {
124 let content = resp.text().await?;
125 serde_json::from_str(&content).map_err(Error::from)
126 } else {
127 let content = resp.text().await?;
128 let entity: Option<GetFieldAutoCompleteForQueryStringError> = serde_json::from_str(&content).ok();
129 Err(Error::ResponseError(ResponseContent { status, content, entity }))
130 }
131}
132
133pub async fn migrate_queries(configuration: &configuration::Configuration, jql_personal_data_migration_request: models::JqlPersonalDataMigrationRequest) -> Result<models::ConvertedJqlQueries, Error<MigrateQueriesError>> {
135 let p_jql_personal_data_migration_request = jql_personal_data_migration_request;
137
138 let uri_str = format!("{}/rest/api/2/jql/pdcleaner", configuration.base_path);
139 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
140
141 if let Some(ref user_agent) = configuration.user_agent {
142 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
143 }
144 if let Some(ref token) = configuration.oauth_access_token {
145 req_builder = req_builder.bearer_auth(token.to_owned());
146 };
147 if let Some(ref auth_conf) = configuration.basic_auth {
148 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
149 };
150 req_builder = req_builder.json(&p_jql_personal_data_migration_request);
151
152 let req = req_builder.build()?;
153 let resp = configuration.client.execute(req).await?;
154
155 let status = resp.status();
156
157 if !status.is_client_error() && !status.is_server_error() {
158 let content = resp.text().await?;
159 serde_json::from_str(&content).map_err(Error::from)
160 } else {
161 let content = resp.text().await?;
162 let entity: Option<MigrateQueriesError> = serde_json::from_str(&content).ok();
163 Err(Error::ResponseError(ResponseContent { status, content, entity }))
164 }
165}
166
167pub async fn parse_jql_queries(configuration: &configuration::Configuration, jql_queries_to_parse: models::JqlQueriesToParse, validation: Option<&str>) -> Result<models::ParsedJqlQueries, Error<ParseJqlQueriesError>> {
169 let p_jql_queries_to_parse = jql_queries_to_parse;
171 let p_validation = validation;
172
173 let uri_str = format!("{}/rest/api/2/jql/parse", configuration.base_path);
174 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
175
176 if let Some(ref param_value) = p_validation {
177 req_builder = req_builder.query(&[("validation", ¶m_value.to_string())]);
178 }
179 if let Some(ref user_agent) = configuration.user_agent {
180 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
181 }
182 if let Some(ref token) = configuration.oauth_access_token {
183 req_builder = req_builder.bearer_auth(token.to_owned());
184 };
185 if let Some(ref auth_conf) = configuration.basic_auth {
186 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
187 };
188 req_builder = req_builder.json(&p_jql_queries_to_parse);
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<ParseJqlQueriesError> = serde_json::from_str(&content).ok();
201 Err(Error::ResponseError(ResponseContent { status, content, entity }))
202 }
203}
204