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 CreateKafkaTriggerError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum DeleteKafkaTriggerError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum ExistsKafkaTriggerError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum GetKafkaTriggerError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum ListKafkaTriggersError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum ResetKafkaOffsetsError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum SetKafkaTriggerModeError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum TestKafkaConnectionError {
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum UpdateKafkaTriggerError {
78 UnknownValue(serde_json::Value),
79}
80
81
82pub async fn create_kafka_trigger(configuration: &configuration::Configuration, workspace: &str, new_kafka_trigger: models::NewKafkaTrigger) -> Result<String, Error<CreateKafkaTriggerError>> {
83 let local_var_configuration = configuration;
84
85 let local_var_client = &local_var_configuration.client;
86
87 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/create", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
88 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, 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.bearer_access_token {
94 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
95 };
96 local_var_req_builder = local_var_req_builder.json(&new_kafka_trigger);
97
98 let local_var_req = local_var_req_builder.build()?;
99 let local_var_resp = local_var_client.execute(local_var_req).await?;
100
101 let local_var_status = local_var_resp.status();
102 let local_var_content = local_var_resp.text().await?;
103
104 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
105 crate::from_str_patched(&local_var_content).map_err(Error::from)
106 } else {
107 let local_var_entity: Option<CreateKafkaTriggerError> = crate::from_str_patched(&local_var_content).ok();
108 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
109 Err(Error::ResponseError(local_var_error))
110 }
111}
112
113pub async fn delete_kafka_trigger(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<String, Error<DeleteKafkaTriggerError>> {
114 let local_var_configuration = configuration;
115
116 let local_var_client = &local_var_configuration.client;
117
118 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/delete/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
119 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
120
121 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
122 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
123 }
124 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
125 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
126 };
127
128 let local_var_req = local_var_req_builder.build()?;
129 let local_var_resp = local_var_client.execute(local_var_req).await?;
130
131 let local_var_status = local_var_resp.status();
132 let local_var_content = local_var_resp.text().await?;
133
134 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
135 crate::from_str_patched(&local_var_content).map_err(Error::from)
136 } else {
137 let local_var_entity: Option<DeleteKafkaTriggerError> = crate::from_str_patched(&local_var_content).ok();
138 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
139 Err(Error::ResponseError(local_var_error))
140 }
141}
142
143pub async fn exists_kafka_trigger(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<bool, Error<ExistsKafkaTriggerError>> {
144 let local_var_configuration = configuration;
145
146 let local_var_client = &local_var_configuration.client;
147
148 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/exists/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
149 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
150
151 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
152 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
153 }
154 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
155 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
156 };
157
158 let local_var_req = local_var_req_builder.build()?;
159 let local_var_resp = local_var_client.execute(local_var_req).await?;
160
161 let local_var_status = local_var_resp.status();
162 let local_var_content = local_var_resp.text().await?;
163
164 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
165 crate::from_str_patched(&local_var_content).map_err(Error::from)
166 } else {
167 let local_var_entity: Option<ExistsKafkaTriggerError> = crate::from_str_patched(&local_var_content).ok();
168 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
169 Err(Error::ResponseError(local_var_error))
170 }
171}
172
173pub async fn get_kafka_trigger(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<models::KafkaTrigger, Error<GetKafkaTriggerError>> {
174 let local_var_configuration = configuration;
175
176 let local_var_client = &local_var_configuration.client;
177
178 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/get/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
179 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
180
181 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
182 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
183 }
184 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
185 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
186 };
187
188 let local_var_req = local_var_req_builder.build()?;
189 let local_var_resp = local_var_client.execute(local_var_req).await?;
190
191 let local_var_status = local_var_resp.status();
192 let local_var_content = local_var_resp.text().await?;
193
194 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
195 crate::from_str_patched(&local_var_content).map_err(Error::from)
196 } else {
197 let local_var_entity: Option<GetKafkaTriggerError> = crate::from_str_patched(&local_var_content).ok();
198 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
199 Err(Error::ResponseError(local_var_error))
200 }
201}
202
203pub async fn list_kafka_triggers(configuration: &configuration::Configuration, workspace: &str, page: Option<i32>, per_page: Option<i32>, path: Option<&str>, is_flow: Option<bool>, path_start: Option<&str>) -> Result<Vec<models::KafkaTrigger>, Error<ListKafkaTriggersError>> {
204 let local_var_configuration = configuration;
205
206 let local_var_client = &local_var_configuration.client;
207
208 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
209 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
210
211 if let Some(ref local_var_str) = page {
212 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
213 }
214 if let Some(ref local_var_str) = per_page {
215 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
216 }
217 if let Some(ref local_var_str) = path {
218 local_var_req_builder = local_var_req_builder.query(&[("path", &local_var_str.to_string())]);
219 }
220 if let Some(ref local_var_str) = is_flow {
221 local_var_req_builder = local_var_req_builder.query(&[("is_flow", &local_var_str.to_string())]);
222 }
223 if let Some(ref local_var_str) = path_start {
224 local_var_req_builder = local_var_req_builder.query(&[("path_start", &local_var_str.to_string())]);
225 }
226 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
227 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
228 }
229 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
230 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
231 };
232
233 let local_var_req = local_var_req_builder.build()?;
234 let local_var_resp = local_var_client.execute(local_var_req).await?;
235
236 let local_var_status = local_var_resp.status();
237 let local_var_content = local_var_resp.text().await?;
238
239 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
240 crate::from_str_patched(&local_var_content).map_err(Error::from)
241 } else {
242 let local_var_entity: Option<ListKafkaTriggersError> = crate::from_str_patched(&local_var_content).ok();
243 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
244 Err(Error::ResponseError(local_var_error))
245 }
246}
247
248pub async fn reset_kafka_offsets(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<(), Error<ResetKafkaOffsetsError>> {
249 let local_var_configuration = configuration;
250
251 let local_var_client = &local_var_configuration.client;
252
253 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/reset_offsets/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
254 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
255
256 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
257 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
258 }
259 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
260 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
261 };
262
263 let local_var_req = local_var_req_builder.build()?;
264 let local_var_resp = local_var_client.execute(local_var_req).await?;
265
266 let local_var_status = local_var_resp.status();
267 let local_var_content = local_var_resp.text().await?;
268
269 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
270 Ok(())
271 } else {
272 let local_var_entity: Option<ResetKafkaOffsetsError> = crate::from_str_patched(&local_var_content).ok();
273 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
274 Err(Error::ResponseError(local_var_error))
275 }
276}
277
278pub async fn set_kafka_trigger_mode(configuration: &configuration::Configuration, workspace: &str, path: &str, set_http_trigger_mode_request: models::SetHttpTriggerModeRequest) -> Result<String, Error<SetKafkaTriggerModeError>> {
279 let local_var_configuration = configuration;
280
281 let local_var_client = &local_var_configuration.client;
282
283 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/setmode/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
284 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
285
286 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
287 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
288 }
289 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
290 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
291 };
292 local_var_req_builder = local_var_req_builder.json(&set_http_trigger_mode_request);
293
294 let local_var_req = local_var_req_builder.build()?;
295 let local_var_resp = local_var_client.execute(local_var_req).await?;
296
297 let local_var_status = local_var_resp.status();
298 let local_var_content = local_var_resp.text().await?;
299
300 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
301 crate::from_str_patched(&local_var_content).map_err(Error::from)
302 } else {
303 let local_var_entity: Option<SetKafkaTriggerModeError> = crate::from_str_patched(&local_var_content).ok();
304 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
305 Err(Error::ResponseError(local_var_error))
306 }
307}
308
309pub async fn test_kafka_connection(configuration: &configuration::Configuration, workspace: &str, test_kafka_connection_request: models::TestKafkaConnectionRequest) -> Result<String, Error<TestKafkaConnectionError>> {
310 let local_var_configuration = configuration;
311
312 let local_var_client = &local_var_configuration.client;
313
314 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/test", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
315 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
316
317 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
318 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
319 }
320 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
321 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
322 };
323 local_var_req_builder = local_var_req_builder.json(&test_kafka_connection_request);
324
325 let local_var_req = local_var_req_builder.build()?;
326 let local_var_resp = local_var_client.execute(local_var_req).await?;
327
328 let local_var_status = local_var_resp.status();
329 let local_var_content = local_var_resp.text().await?;
330
331 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
332 crate::from_str_patched(&local_var_content).map_err(Error::from)
333 } else {
334 let local_var_entity: Option<TestKafkaConnectionError> = crate::from_str_patched(&local_var_content).ok();
335 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
336 Err(Error::ResponseError(local_var_error))
337 }
338}
339
340pub async fn update_kafka_trigger(configuration: &configuration::Configuration, workspace: &str, path: &str, edit_kafka_trigger: models::EditKafkaTrigger) -> Result<String, Error<UpdateKafkaTriggerError>> {
341 let local_var_configuration = configuration;
342
343 let local_var_client = &local_var_configuration.client;
344
345 let local_var_uri_str = format!("{}/w/{workspace}/kafka_triggers/update/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
346 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
347
348 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
349 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
350 }
351 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
352 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
353 };
354 local_var_req_builder = local_var_req_builder.json(&edit_kafka_trigger);
355
356 let local_var_req = local_var_req_builder.build()?;
357 let local_var_resp = local_var_client.execute(local_var_req).await?;
358
359 let local_var_status = local_var_resp.status();
360 let local_var_content = local_var_resp.text().await?;
361
362 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
363 crate::from_str_patched(&local_var_content).map_err(Error::from)
364 } else {
365 let local_var_entity: Option<UpdateKafkaTriggerError> = crate::from_str_patched(&local_var_content).ok();
366 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
367 Err(Error::ResponseError(local_var_error))
368 }
369}
370