hi_jira2/apis/
time_tracking_api.rs1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17#[derive(Clone, Debug, Default)]
19pub struct SelectTimeTrackingImplementationParams {
20 pub time_tracking_provider: crate::models::TimeTrackingProvider
21}
22
23#[derive(Clone, Debug, Default)]
25pub struct SetSharedTimeTrackingConfigurationParams {
26 pub time_tracking_configuration: crate::models::TimeTrackingConfiguration
27}
28
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum GetAvailableTimeTrackingImplementationsError {
34 Status401(),
35 Status403(),
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum GetSelectedTimeTrackingImplementationError {
43 Status401(),
44 Status403(),
45 UnknownValue(serde_json::Value),
46}
47
48#[derive(Debug, Clone, Serialize, Deserialize)]
50#[serde(untagged)]
51pub enum GetSharedTimeTrackingConfigurationError {
52 Status401(),
53 Status403(),
54 UnknownValue(serde_json::Value),
55}
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum SelectTimeTrackingImplementationError {
61 Status400(),
62 Status401(),
63 Status403(),
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum SetSharedTimeTrackingConfigurationError {
71 Status400(),
72 Status401(),
73 Status403(),
74 UnknownValue(serde_json::Value),
75}
76
77
78pub async fn get_available_time_tracking_implementations(configuration: &configuration::Configuration) -> Result<Vec<crate::models::TimeTrackingProvider>, Error<GetAvailableTimeTrackingImplementationsError>> {
80 let local_var_configuration = configuration;
81
82 let local_var_client = &local_var_configuration.client;
86
87 let local_var_uri_str = format!("{}/rest/api/2/configuration/timetracking/list", local_var_configuration.base_path);
88 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
89
90 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
91 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
92 }
93 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
94 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
95 };
96 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
97 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
98 };
99
100 let local_var_req = local_var_req_builder.build()?;
101 let local_var_resp = local_var_client.execute(local_var_req).await?;
102
103 let local_var_status = local_var_resp.status();
104 let local_var_content = local_var_resp.text().await?;
105
106 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
107 serde_json::from_str(&local_var_content).map_err(Error::from)
108 } else {
109 let local_var_entity: Option<GetAvailableTimeTrackingImplementationsError> = serde_json::from_str(&local_var_content).ok();
110 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
111 Err(Error::ResponseError(local_var_error))
112 }
113}
114
115pub async fn get_selected_time_tracking_implementation(configuration: &configuration::Configuration) -> Result<crate::models::TimeTrackingProvider, Error<GetSelectedTimeTrackingImplementationError>> {
117 let local_var_configuration = configuration;
118
119 let local_var_client = &local_var_configuration.client;
123
124 let local_var_uri_str = format!("{}/rest/api/2/configuration/timetracking", local_var_configuration.base_path);
125 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
126
127 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
128 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
129 }
130 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
131 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
132 };
133 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
134 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
135 };
136
137 let local_var_req = local_var_req_builder.build()?;
138 let local_var_resp = local_var_client.execute(local_var_req).await?;
139
140 let local_var_status = local_var_resp.status();
141 let local_var_content = local_var_resp.text().await?;
142
143 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
144 serde_json::from_str(&local_var_content).map_err(Error::from)
145 } else {
146 let local_var_entity: Option<GetSelectedTimeTrackingImplementationError> = serde_json::from_str(&local_var_content).ok();
147 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
148 Err(Error::ResponseError(local_var_error))
149 }
150}
151
152pub async fn get_shared_time_tracking_configuration(configuration: &configuration::Configuration) -> Result<crate::models::TimeTrackingConfiguration, Error<GetSharedTimeTrackingConfigurationError>> {
154 let local_var_configuration = configuration;
155
156 let local_var_client = &local_var_configuration.client;
160
161 let local_var_uri_str = format!("{}/rest/api/2/configuration/timetracking/options", local_var_configuration.base_path);
162 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
163
164 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
165 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
166 }
167 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
168 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
169 };
170 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
171 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
172 };
173
174 let local_var_req = local_var_req_builder.build()?;
175 let local_var_resp = local_var_client.execute(local_var_req).await?;
176
177 let local_var_status = local_var_resp.status();
178 let local_var_content = local_var_resp.text().await?;
179
180 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
181 serde_json::from_str(&local_var_content).map_err(Error::from)
182 } else {
183 let local_var_entity: Option<GetSharedTimeTrackingConfigurationError> = serde_json::from_str(&local_var_content).ok();
184 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
185 Err(Error::ResponseError(local_var_error))
186 }
187}
188
189pub async fn select_time_tracking_implementation(configuration: &configuration::Configuration, params: SelectTimeTrackingImplementationParams) -> Result<serde_json::Value, Error<SelectTimeTrackingImplementationError>> {
191 let local_var_configuration = configuration;
192
193 let time_tracking_provider = params.time_tracking_provider;
195
196
197 let local_var_client = &local_var_configuration.client;
198
199 let local_var_uri_str = format!("{}/rest/api/2/configuration/timetracking", local_var_configuration.base_path);
200 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
201
202 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
203 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
204 }
205 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
206 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
207 };
208 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
209 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
210 };
211 local_var_req_builder = local_var_req_builder.json(&time_tracking_provider);
212
213 let local_var_req = local_var_req_builder.build()?;
214 let local_var_resp = local_var_client.execute(local_var_req).await?;
215
216 let local_var_status = local_var_resp.status();
217 let local_var_content = local_var_resp.text().await?;
218
219 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
220 serde_json::from_str(&local_var_content).map_err(Error::from)
221 } else {
222 let local_var_entity: Option<SelectTimeTrackingImplementationError> = serde_json::from_str(&local_var_content).ok();
223 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
224 Err(Error::ResponseError(local_var_error))
225 }
226}
227
228pub async fn set_shared_time_tracking_configuration(configuration: &configuration::Configuration, params: SetSharedTimeTrackingConfigurationParams) -> Result<crate::models::TimeTrackingConfiguration, Error<SetSharedTimeTrackingConfigurationError>> {
230 let local_var_configuration = configuration;
231
232 let time_tracking_configuration = params.time_tracking_configuration;
234
235
236 let local_var_client = &local_var_configuration.client;
237
238 let local_var_uri_str = format!("{}/rest/api/2/configuration/timetracking/options", local_var_configuration.base_path);
239 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
240
241 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
242 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
243 }
244 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
245 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
246 };
247 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
248 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
249 };
250 local_var_req_builder = local_var_req_builder.json(&time_tracking_configuration);
251
252 let local_var_req = local_var_req_builder.build()?;
253 let local_var_resp = local_var_client.execute(local_var_req).await?;
254
255 let local_var_status = local_var_resp.status();
256 let local_var_content = local_var_resp.text().await?;
257
258 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
259 serde_json::from_str(&local_var_content).map_err(Error::from)
260 } else {
261 let local_var_entity: Option<SetSharedTimeTrackingConfigurationError> = serde_json::from_str(&local_var_content).ok();
262 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
263 Err(Error::ResponseError(local_var_error))
264 }
265}
266