1use std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21 apis::{ContentType, ResponseContent},
22 models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait OrganizationIntegrationConfigurationApi: Send + Sync {
29 async fn create<'a>(
31 &self,
32 organization_id: uuid::Uuid,
33 integration_id: uuid::Uuid,
34 organization_integration_configuration_request_model: Option<
35 models::OrganizationIntegrationConfigurationRequestModel,
36 >,
37 ) -> Result<models::OrganizationIntegrationConfigurationResponseModel, Error<CreateError>>;
38
39 async fn delete<'a>(
42 &self,
43 organization_id: uuid::Uuid,
44 integration_id: uuid::Uuid,
45 configuration_id: uuid::Uuid,
46 ) -> Result<(), Error<DeleteError>>;
47
48 async fn get<'a>(
50 &self,
51 organization_id: uuid::Uuid,
52 integration_id: uuid::Uuid,
53 ) -> Result<Vec<models::OrganizationIntegrationConfigurationResponseModel>, Error<GetError>>;
54
55 async fn update<'a>(
58 &self,
59 organization_id: uuid::Uuid,
60 integration_id: uuid::Uuid,
61 configuration_id: uuid::Uuid,
62 organization_integration_configuration_request_model: Option<
63 models::OrganizationIntegrationConfigurationRequestModel,
64 >,
65 ) -> Result<models::OrganizationIntegrationConfigurationResponseModel, Error<UpdateError>>;
66}
67
68pub struct OrganizationIntegrationConfigurationApiClient {
69 configuration: Arc<configuration::Configuration>,
70}
71
72impl OrganizationIntegrationConfigurationApiClient {
73 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
74 Self { configuration }
75 }
76}
77
78#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
79#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
80impl OrganizationIntegrationConfigurationApi for OrganizationIntegrationConfigurationApiClient {
81 async fn create<'a>(
82 &self,
83 organization_id: uuid::Uuid,
84 integration_id: uuid::Uuid,
85 organization_integration_configuration_request_model: Option<
86 models::OrganizationIntegrationConfigurationRequestModel,
87 >,
88 ) -> Result<models::OrganizationIntegrationConfigurationResponseModel, Error<CreateError>> {
89 let local_var_configuration = &self.configuration;
90
91 let local_var_client = &local_var_configuration.client;
92
93 let local_var_uri_str = format!(
94 "{}/organizations/{organizationId}/integrations/{integrationId}/configurations",
95 local_var_configuration.base_path,
96 organizationId = organization_id,
97 integrationId = integration_id
98 );
99 let mut local_var_req_builder =
100 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
101
102 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
103 local_var_req_builder = local_var_req_builder
104 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
105 }
106 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
107 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
108 };
109 local_var_req_builder =
110 local_var_req_builder.json(&organization_integration_configuration_request_model);
111
112 let local_var_req = local_var_req_builder.build()?;
113 let local_var_resp = local_var_client.execute(local_var_req).await?;
114
115 let local_var_status = local_var_resp.status();
116 let local_var_content_type = local_var_resp
117 .headers()
118 .get("content-type")
119 .and_then(|v| v.to_str().ok())
120 .unwrap_or("application/octet-stream");
121 let local_var_content_type = super::ContentType::from(local_var_content_type);
122 let local_var_content = local_var_resp.text().await?;
123
124 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
125 match local_var_content_type {
126 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
127 ContentType::Text => {
128 return Err(Error::from(serde_json::Error::custom(
129 "Received `text/plain` content type response that cannot be converted to `models::OrganizationIntegrationConfigurationResponseModel`",
130 )));
131 }
132 ContentType::Unsupported(local_var_unknown_type) => {
133 return Err(Error::from(serde_json::Error::custom(format!(
134 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationIntegrationConfigurationResponseModel`"
135 ))));
136 }
137 }
138 } else {
139 let local_var_entity: Option<CreateError> =
140 serde_json::from_str(&local_var_content).ok();
141 let local_var_error = ResponseContent {
142 status: local_var_status,
143 content: local_var_content,
144 entity: local_var_entity,
145 };
146 Err(Error::ResponseError(local_var_error))
147 }
148 }
149
150 async fn delete<'a>(
151 &self,
152 organization_id: uuid::Uuid,
153 integration_id: uuid::Uuid,
154 configuration_id: uuid::Uuid,
155 ) -> Result<(), Error<DeleteError>> {
156 let local_var_configuration = &self.configuration;
157
158 let local_var_client = &local_var_configuration.client;
159
160 let local_var_uri_str = format!(
161 "{}/organizations/{organizationId}/integrations/{integrationId}/configurations/{configurationId}",
162 local_var_configuration.base_path,
163 organizationId = organization_id,
164 integrationId = integration_id,
165 configurationId = configuration_id
166 );
167 let mut local_var_req_builder =
168 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
169
170 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
171 local_var_req_builder = local_var_req_builder
172 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
173 }
174 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
175 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
176 };
177
178 let local_var_req = local_var_req_builder.build()?;
179 let local_var_resp = local_var_client.execute(local_var_req).await?;
180
181 let local_var_status = local_var_resp.status();
182 let local_var_content = local_var_resp.text().await?;
183
184 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
185 Ok(())
186 } else {
187 let local_var_entity: Option<DeleteError> =
188 serde_json::from_str(&local_var_content).ok();
189 let local_var_error = ResponseContent {
190 status: local_var_status,
191 content: local_var_content,
192 entity: local_var_entity,
193 };
194 Err(Error::ResponseError(local_var_error))
195 }
196 }
197
198 async fn get<'a>(
199 &self,
200 organization_id: uuid::Uuid,
201 integration_id: uuid::Uuid,
202 ) -> Result<Vec<models::OrganizationIntegrationConfigurationResponseModel>, Error<GetError>>
203 {
204 let local_var_configuration = &self.configuration;
205
206 let local_var_client = &local_var_configuration.client;
207
208 let local_var_uri_str = format!(
209 "{}/organizations/{organizationId}/integrations/{integrationId}/configurations",
210 local_var_configuration.base_path,
211 organizationId = organization_id,
212 integrationId = integration_id
213 );
214 let mut local_var_req_builder =
215 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
216
217 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
218 local_var_req_builder = local_var_req_builder
219 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
220 }
221 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
222 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
223 };
224
225 let local_var_req = local_var_req_builder.build()?;
226 let local_var_resp = local_var_client.execute(local_var_req).await?;
227
228 let local_var_status = local_var_resp.status();
229 let local_var_content_type = local_var_resp
230 .headers()
231 .get("content-type")
232 .and_then(|v| v.to_str().ok())
233 .unwrap_or("application/octet-stream");
234 let local_var_content_type = super::ContentType::from(local_var_content_type);
235 let local_var_content = local_var_resp.text().await?;
236
237 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
238 match local_var_content_type {
239 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
240 ContentType::Text => {
241 return Err(Error::from(serde_json::Error::custom(
242 "Received `text/plain` content type response that cannot be converted to `Vec<models::OrganizationIntegrationConfigurationResponseModel>`",
243 )));
244 }
245 ContentType::Unsupported(local_var_unknown_type) => {
246 return Err(Error::from(serde_json::Error::custom(format!(
247 "Received `{local_var_unknown_type}` content type response that cannot be converted to `Vec<models::OrganizationIntegrationConfigurationResponseModel>`"
248 ))));
249 }
250 }
251 } else {
252 let local_var_entity: Option<GetError> = serde_json::from_str(&local_var_content).ok();
253 let local_var_error = ResponseContent {
254 status: local_var_status,
255 content: local_var_content,
256 entity: local_var_entity,
257 };
258 Err(Error::ResponseError(local_var_error))
259 }
260 }
261
262 async fn update<'a>(
263 &self,
264 organization_id: uuid::Uuid,
265 integration_id: uuid::Uuid,
266 configuration_id: uuid::Uuid,
267 organization_integration_configuration_request_model: Option<
268 models::OrganizationIntegrationConfigurationRequestModel,
269 >,
270 ) -> Result<models::OrganizationIntegrationConfigurationResponseModel, Error<UpdateError>> {
271 let local_var_configuration = &self.configuration;
272
273 let local_var_client = &local_var_configuration.client;
274
275 let local_var_uri_str = format!(
276 "{}/organizations/{organizationId}/integrations/{integrationId}/configurations/{configurationId}",
277 local_var_configuration.base_path,
278 organizationId = organization_id,
279 integrationId = integration_id,
280 configurationId = configuration_id
281 );
282 let mut local_var_req_builder =
283 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
284
285 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
286 local_var_req_builder = local_var_req_builder
287 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
288 }
289 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
290 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
291 };
292 local_var_req_builder =
293 local_var_req_builder.json(&organization_integration_configuration_request_model);
294
295 let local_var_req = local_var_req_builder.build()?;
296 let local_var_resp = local_var_client.execute(local_var_req).await?;
297
298 let local_var_status = local_var_resp.status();
299 let local_var_content_type = local_var_resp
300 .headers()
301 .get("content-type")
302 .and_then(|v| v.to_str().ok())
303 .unwrap_or("application/octet-stream");
304 let local_var_content_type = super::ContentType::from(local_var_content_type);
305 let local_var_content = local_var_resp.text().await?;
306
307 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
308 match local_var_content_type {
309 ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
310 ContentType::Text => {
311 return Err(Error::from(serde_json::Error::custom(
312 "Received `text/plain` content type response that cannot be converted to `models::OrganizationIntegrationConfigurationResponseModel`",
313 )));
314 }
315 ContentType::Unsupported(local_var_unknown_type) => {
316 return Err(Error::from(serde_json::Error::custom(format!(
317 "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationIntegrationConfigurationResponseModel`"
318 ))));
319 }
320 }
321 } else {
322 let local_var_entity: Option<UpdateError> =
323 serde_json::from_str(&local_var_content).ok();
324 let local_var_error = ResponseContent {
325 status: local_var_status,
326 content: local_var_content,
327 entity: local_var_entity,
328 };
329 Err(Error::ResponseError(local_var_error))
330 }
331 }
332}
333
334#[derive(Debug, Clone, Serialize, Deserialize)]
336#[serde(untagged)]
337pub enum CreateError {
338 UnknownValue(serde_json::Value),
339}
340#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum DeleteError {
344 UnknownValue(serde_json::Value),
345}
346#[derive(Debug, Clone, Serialize, Deserialize)]
348#[serde(untagged)]
349pub enum GetError {
350 UnknownValue(serde_json::Value),
351}
352#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum UpdateError {
356 UnknownValue(serde_json::Value),
357}