1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum WebhooksCreateWebhookError {
22 Status400(Vec<crate::models::ValidationProblemDetailsInner>),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum WebhooksDeleteWebhookError {
30 Status404(),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum WebhooksGetWebhookError {
38 Status404(),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum WebhooksGetWebhookDeliveriesError {
46 Status404(),
47 UnknownValue(serde_json::Value),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(untagged)]
53pub enum WebhooksGetWebhookDeliveryError {
54 Status404(),
55 UnknownValue(serde_json::Value),
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum WebhooksGetWebhookDeliveryRequestsError {
62 Status404(),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum WebhooksGetWebhooksError {
70 Status404(),
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum WebhooksRedeliverWebhookDeliveryError {
78 Status404(),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum WebhooksUpdateWebhookError {
86 Status400(Vec<crate::models::ValidationProblemDetailsInner>),
87 UnknownValue(serde_json::Value),
88}
89
90
91pub async fn webhooks_create_webhook(configuration: &configuration::Configuration, store_id: &str, webhook_data_create: crate::models::WebhookDataCreate) -> Result<crate::models::WebhookDataCreate, Error<WebhooksCreateWebhookError>> {
93 let local_var_configuration = configuration;
94
95 let local_var_client = &local_var_configuration.client;
96
97 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id));
98 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
99
100 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
101 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
102 }
103 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
104 let local_var_key = local_var_apikey.key.clone();
105 let local_var_value = match local_var_apikey.prefix {
106 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
107 None => local_var_key,
108 };
109 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
110 };
111 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
112 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
113 };
114 local_var_req_builder = local_var_req_builder.json(&webhook_data_create);
115
116 let local_var_req = local_var_req_builder.build()?;
117 let local_var_resp = local_var_client.execute(local_var_req).await?;
118
119 let local_var_status = local_var_resp.status();
120 let local_var_content = local_var_resp.text().await?;
121
122 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
123 serde_json::from_str(&local_var_content).map_err(Error::from)
124 } else {
125 let local_var_entity: Option<WebhooksCreateWebhookError> = serde_json::from_str(&local_var_content).ok();
126 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
127 Err(Error::ResponseError(local_var_error))
128 }
129}
130
131pub async fn webhooks_delete_webhook(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str) -> Result<(), Error<WebhooksDeleteWebhookError>> {
133 let local_var_configuration = configuration;
134
135 let local_var_client = &local_var_configuration.client;
136
137 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id));
138 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
139
140 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
141 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
142 }
143 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
144 let local_var_key = local_var_apikey.key.clone();
145 let local_var_value = match local_var_apikey.prefix {
146 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
147 None => local_var_key,
148 };
149 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
150 };
151 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
152 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
153 };
154
155 let local_var_req = local_var_req_builder.build()?;
156 let local_var_resp = local_var_client.execute(local_var_req).await?;
157
158 let local_var_status = local_var_resp.status();
159 let local_var_content = local_var_resp.text().await?;
160
161 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
162 Ok(())
163 } else {
164 let local_var_entity: Option<WebhooksDeleteWebhookError> = serde_json::from_str(&local_var_content).ok();
165 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
166 Err(Error::ResponseError(local_var_error))
167 }
168}
169
170pub async fn webhooks_get_webhook(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str) -> Result<crate::models::WebhookData, Error<WebhooksGetWebhookError>> {
172 let local_var_configuration = configuration;
173
174 let local_var_client = &local_var_configuration.client;
175
176 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id));
177 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
178
179 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
180 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
181 }
182 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
183 let local_var_key = local_var_apikey.key.clone();
184 let local_var_value = match local_var_apikey.prefix {
185 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
186 None => local_var_key,
187 };
188 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
189 };
190 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
191 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
192 };
193
194 let local_var_req = local_var_req_builder.build()?;
195 let local_var_resp = local_var_client.execute(local_var_req).await?;
196
197 let local_var_status = local_var_resp.status();
198 let local_var_content = local_var_resp.text().await?;
199
200 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
201 serde_json::from_str(&local_var_content).map_err(Error::from)
202 } else {
203 let local_var_entity: Option<WebhooksGetWebhookError> = serde_json::from_str(&local_var_content).ok();
204 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
205 Err(Error::ResponseError(local_var_error))
206 }
207}
208
209pub async fn webhooks_get_webhook_deliveries(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str, count: Option<&str>) -> Result<Vec<crate::models::WebhookDeliveryData>, Error<WebhooksGetWebhookDeliveriesError>> {
211 let local_var_configuration = configuration;
212
213 let local_var_client = &local_var_configuration.client;
214
215 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id));
216 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
217
218 if let Some(ref local_var_str) = count {
219 local_var_req_builder = local_var_req_builder.query(&[("count", &local_var_str.to_string())]);
220 }
221 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
222 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
223 }
224 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
225 let local_var_key = local_var_apikey.key.clone();
226 let local_var_value = match local_var_apikey.prefix {
227 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
228 None => local_var_key,
229 };
230 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
231 };
232 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
233 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
234 };
235
236 let local_var_req = local_var_req_builder.build()?;
237 let local_var_resp = local_var_client.execute(local_var_req).await?;
238
239 let local_var_status = local_var_resp.status();
240 let local_var_content = local_var_resp.text().await?;
241
242 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
243 serde_json::from_str(&local_var_content).map_err(Error::from)
244 } else {
245 let local_var_entity: Option<WebhooksGetWebhookDeliveriesError> = serde_json::from_str(&local_var_content).ok();
246 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
247 Err(Error::ResponseError(local_var_error))
248 }
249}
250
251pub async fn webhooks_get_webhook_delivery(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str, delivery_id: &str) -> Result<crate::models::WebhookDeliveryData, Error<WebhooksGetWebhookDeliveryError>> {
253 let local_var_configuration = configuration;
254
255 let local_var_client = &local_var_configuration.client;
256
257 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id), deliveryId=crate::apis::urlencode(delivery_id));
258 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
259
260 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
261 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
262 }
263 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
264 let local_var_key = local_var_apikey.key.clone();
265 let local_var_value = match local_var_apikey.prefix {
266 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
267 None => local_var_key,
268 };
269 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
270 };
271 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
272 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
273 };
274
275 let local_var_req = local_var_req_builder.build()?;
276 let local_var_resp = local_var_client.execute(local_var_req).await?;
277
278 let local_var_status = local_var_resp.status();
279 let local_var_content = local_var_resp.text().await?;
280
281 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
282 serde_json::from_str(&local_var_content).map_err(Error::from)
283 } else {
284 let local_var_entity: Option<WebhooksGetWebhookDeliveryError> = serde_json::from_str(&local_var_content).ok();
285 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
286 Err(Error::ResponseError(local_var_error))
287 }
288}
289
290pub async fn webhooks_get_webhook_delivery_requests(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str, delivery_id: &str) -> Result<::std::collections::HashMap<String, serde_json::Value>, Error<WebhooksGetWebhookDeliveryRequestsError>> {
292 let local_var_configuration = configuration;
293
294 let local_var_client = &local_var_configuration.client;
295
296 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/request", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id), deliveryId=crate::apis::urlencode(delivery_id));
297 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
298
299 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
300 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
301 }
302 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
303 let local_var_key = local_var_apikey.key.clone();
304 let local_var_value = match local_var_apikey.prefix {
305 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
306 None => local_var_key,
307 };
308 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
309 };
310 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
311 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
312 };
313
314 let local_var_req = local_var_req_builder.build()?;
315 let local_var_resp = local_var_client.execute(local_var_req).await?;
316
317 let local_var_status = local_var_resp.status();
318 let local_var_content = local_var_resp.text().await?;
319
320 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
321 serde_json::from_str(&local_var_content).map_err(Error::from)
322 } else {
323 let local_var_entity: Option<WebhooksGetWebhookDeliveryRequestsError> = serde_json::from_str(&local_var_content).ok();
324 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
325 Err(Error::ResponseError(local_var_error))
326 }
327}
328
329pub async fn webhooks_get_webhooks(configuration: &configuration::Configuration, store_id: &str) -> Result<Vec<crate::models::WebhookData>, Error<WebhooksGetWebhooksError>> {
331 let local_var_configuration = configuration;
332
333 let local_var_client = &local_var_configuration.client;
334
335 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id));
336 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
337
338 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
339 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
340 }
341 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
342 let local_var_key = local_var_apikey.key.clone();
343 let local_var_value = match local_var_apikey.prefix {
344 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
345 None => local_var_key,
346 };
347 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
348 };
349 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
350 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
351 };
352
353 let local_var_req = local_var_req_builder.build()?;
354 let local_var_resp = local_var_client.execute(local_var_req).await?;
355
356 let local_var_status = local_var_resp.status();
357 let local_var_content = local_var_resp.text().await?;
358
359 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
360 serde_json::from_str(&local_var_content).map_err(Error::from)
361 } else {
362 let local_var_entity: Option<WebhooksGetWebhooksError> = serde_json::from_str(&local_var_content).ok();
363 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
364 Err(Error::ResponseError(local_var_error))
365 }
366}
367
368pub async fn webhooks_redeliver_webhook_delivery(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str, delivery_id: &str) -> Result<String, Error<WebhooksRedeliverWebhookDeliveryError>> {
370 let local_var_configuration = configuration;
371
372 let local_var_client = &local_var_configuration.client;
373
374 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/redeliver", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id), deliveryId=crate::apis::urlencode(delivery_id));
375 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
376
377 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
378 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
379 }
380 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
381 let local_var_key = local_var_apikey.key.clone();
382 let local_var_value = match local_var_apikey.prefix {
383 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
384 None => local_var_key,
385 };
386 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
387 };
388 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
389 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
390 };
391
392 let local_var_req = local_var_req_builder.build()?;
393 let local_var_resp = local_var_client.execute(local_var_req).await?;
394
395 let local_var_status = local_var_resp.status();
396 let local_var_content = local_var_resp.text().await?;
397
398 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
399 serde_json::from_str(&local_var_content).map_err(Error::from)
400 } else {
401 let local_var_entity: Option<WebhooksRedeliverWebhookDeliveryError> = serde_json::from_str(&local_var_content).ok();
402 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
403 Err(Error::ResponseError(local_var_error))
404 }
405}
406
407pub async fn webhooks_update_webhook(configuration: &configuration::Configuration, store_id: &str, webhook_id: &str, webhook_data_update: crate::models::WebhookDataUpdate) -> Result<crate::models::WebhookData, Error<WebhooksUpdateWebhookError>> {
409 let local_var_configuration = configuration;
410
411 let local_var_client = &local_var_configuration.client;
412
413 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/webhooks/{webhookId}", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), webhookId=crate::apis::urlencode(webhook_id));
414 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
415
416 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
417 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
418 }
419 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
420 let local_var_key = local_var_apikey.key.clone();
421 let local_var_value = match local_var_apikey.prefix {
422 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
423 None => local_var_key,
424 };
425 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
426 };
427 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
428 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
429 };
430 local_var_req_builder = local_var_req_builder.json(&webhook_data_update);
431
432 let local_var_req = local_var_req_builder.build()?;
433 let local_var_resp = local_var_client.execute(local_var_req).await?;
434
435 let local_var_status = local_var_resp.status();
436 let local_var_content = local_var_resp.text().await?;
437
438 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
439 serde_json::from_str(&local_var_content).map_err(Error::from)
440 } else {
441 let local_var_entity: Option<WebhooksUpdateWebhookError> = serde_json::from_str(&local_var_content).ok();
442 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
443 Err(Error::ResponseError(local_var_error))
444 }
445}
446