1use reqwest;
12use serde::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum OrganizationsConnectionsEnabledGetError {
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum OrganizationsConnectionsOrganizationConnectionIdDeleteError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
35#[serde(untagged)]
36pub enum OrganizationsConnectionsOrganizationConnectionIdDeletePostError {
37 UnknownValue(serde_json::Value),
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum OrganizationsConnectionsOrganizationConnectionIdPutError {
44 UnknownValue(serde_json::Value),
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(untagged)]
50pub enum OrganizationsConnectionsOrganizationIdTypeGetError {
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum OrganizationsConnectionsPostError {
58 UnknownValue(serde_json::Value),
59}
60
61pub async fn organizations_connections_enabled_get(
62 configuration: &configuration::Configuration,
63) -> Result<bool, Error<OrganizationsConnectionsEnabledGetError>> {
64 let local_var_configuration = configuration;
65
66 let local_var_client = &local_var_configuration.client;
67
68 let local_var_uri_str = format!(
69 "{}/organizations/connections/enabled",
70 local_var_configuration.base_path
71 );
72 let mut local_var_req_builder =
73 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
74
75 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
76 local_var_req_builder =
77 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
78 }
79 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
80 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
81 };
82
83 let local_var_req = local_var_req_builder.build()?;
84 let local_var_resp = local_var_client.execute(local_var_req).await?;
85
86 let local_var_status = local_var_resp.status();
87 let local_var_content = local_var_resp.text().await?;
88
89 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
90 serde_json::from_str(&local_var_content).map_err(Error::from)
91 } else {
92 let local_var_entity: Option<OrganizationsConnectionsEnabledGetError> =
93 serde_json::from_str(&local_var_content).ok();
94 let local_var_error = ResponseContent {
95 status: local_var_status,
96 content: local_var_content,
97 entity: local_var_entity,
98 };
99 Err(Error::ResponseError(local_var_error))
100 }
101}
102
103pub async fn organizations_connections_organization_connection_id_delete(
104 configuration: &configuration::Configuration,
105 organization_connection_id: uuid::Uuid,
106) -> Result<(), Error<OrganizationsConnectionsOrganizationConnectionIdDeleteError>> {
107 let local_var_configuration = configuration;
108
109 let local_var_client = &local_var_configuration.client;
110
111 let local_var_uri_str = format!(
112 "{}/organizations/connections/{organizationConnectionId}",
113 local_var_configuration.base_path,
114 organizationConnectionId = crate::apis::urlencode(organization_connection_id.to_string())
115 );
116 let mut local_var_req_builder =
117 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
118
119 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
120 local_var_req_builder =
121 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
122 }
123 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
124 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
125 };
126
127 let local_var_req = local_var_req_builder.build()?;
128 let local_var_resp = local_var_client.execute(local_var_req).await?;
129
130 let local_var_status = local_var_resp.status();
131 let local_var_content = local_var_resp.text().await?;
132
133 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
134 Ok(())
135 } else {
136 let local_var_entity: Option<OrganizationsConnectionsOrganizationConnectionIdDeleteError> =
137 serde_json::from_str(&local_var_content).ok();
138 let local_var_error = ResponseContent {
139 status: local_var_status,
140 content: local_var_content,
141 entity: local_var_entity,
142 };
143 Err(Error::ResponseError(local_var_error))
144 }
145}
146
147pub async fn organizations_connections_organization_connection_id_delete_post(
148 configuration: &configuration::Configuration,
149 organization_connection_id: uuid::Uuid,
150) -> Result<(), Error<OrganizationsConnectionsOrganizationConnectionIdDeletePostError>> {
151 let local_var_configuration = configuration;
152
153 let local_var_client = &local_var_configuration.client;
154
155 let local_var_uri_str = format!(
156 "{}/organizations/connections/{organizationConnectionId}/delete",
157 local_var_configuration.base_path,
158 organizationConnectionId = crate::apis::urlencode(organization_connection_id.to_string())
159 );
160 let mut local_var_req_builder =
161 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
162
163 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
164 local_var_req_builder =
165 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
171 let local_var_req = local_var_req_builder.build()?;
172 let local_var_resp = local_var_client.execute(local_var_req).await?;
173
174 let local_var_status = local_var_resp.status();
175 let local_var_content = local_var_resp.text().await?;
176
177 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
178 Ok(())
179 } else {
180 let local_var_entity: Option<
181 OrganizationsConnectionsOrganizationConnectionIdDeletePostError,
182 > = serde_json::from_str(&local_var_content).ok();
183 let local_var_error = ResponseContent {
184 status: local_var_status,
185 content: local_var_content,
186 entity: local_var_entity,
187 };
188 Err(Error::ResponseError(local_var_error))
189 }
190}
191
192pub async fn organizations_connections_organization_connection_id_put(
193 configuration: &configuration::Configuration,
194 organization_connection_id: uuid::Uuid,
195 organization_connection_request_model: Option<models::OrganizationConnectionRequestModel>,
196) -> Result<
197 models::OrganizationConnectionResponseModel,
198 Error<OrganizationsConnectionsOrganizationConnectionIdPutError>,
199> {
200 let local_var_configuration = configuration;
201
202 let local_var_client = &local_var_configuration.client;
203
204 let local_var_uri_str = format!(
205 "{}/organizations/connections/{organizationConnectionId}",
206 local_var_configuration.base_path,
207 organizationConnectionId = crate::apis::urlencode(organization_connection_id.to_string())
208 );
209 let mut local_var_req_builder =
210 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
211
212 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
213 local_var_req_builder =
214 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
215 }
216 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
217 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
218 };
219 local_var_req_builder = local_var_req_builder.json(&organization_connection_request_model);
220
221 let local_var_req = local_var_req_builder.build()?;
222 let local_var_resp = local_var_client.execute(local_var_req).await?;
223
224 let local_var_status = local_var_resp.status();
225 let local_var_content = local_var_resp.text().await?;
226
227 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
228 serde_json::from_str(&local_var_content).map_err(Error::from)
229 } else {
230 let local_var_entity: Option<OrganizationsConnectionsOrganizationConnectionIdPutError> =
231 serde_json::from_str(&local_var_content).ok();
232 let local_var_error = ResponseContent {
233 status: local_var_status,
234 content: local_var_content,
235 entity: local_var_entity,
236 };
237 Err(Error::ResponseError(local_var_error))
238 }
239}
240
241pub async fn organizations_connections_organization_id_type_get(
242 configuration: &configuration::Configuration,
243 organization_id: uuid::Uuid,
244 r#type: models::OrganizationConnectionType,
245) -> Result<
246 models::OrganizationConnectionResponseModel,
247 Error<OrganizationsConnectionsOrganizationIdTypeGetError>,
248> {
249 let local_var_configuration = configuration;
250
251 let local_var_client = &local_var_configuration.client;
252
253 let local_var_uri_str = format!("{}/organizations/connections/{organizationId}/{type}", local_var_configuration.base_path, organizationId=crate::apis::urlencode(organization_id.to_string()), type=r#type.to_string());
254 let mut local_var_req_builder =
255 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
256
257 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
258 local_var_req_builder =
259 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
260 }
261 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
262 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
263 };
264
265 let local_var_req = local_var_req_builder.build()?;
266 let local_var_resp = local_var_client.execute(local_var_req).await?;
267
268 let local_var_status = local_var_resp.status();
269 let local_var_content = local_var_resp.text().await?;
270
271 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
272 serde_json::from_str(&local_var_content).map_err(Error::from)
273 } else {
274 let local_var_entity: Option<OrganizationsConnectionsOrganizationIdTypeGetError> =
275 serde_json::from_str(&local_var_content).ok();
276 let local_var_error = ResponseContent {
277 status: local_var_status,
278 content: local_var_content,
279 entity: local_var_entity,
280 };
281 Err(Error::ResponseError(local_var_error))
282 }
283}
284
285pub async fn organizations_connections_post(
286 configuration: &configuration::Configuration,
287 organization_connection_request_model: Option<models::OrganizationConnectionRequestModel>,
288) -> Result<models::OrganizationConnectionResponseModel, Error<OrganizationsConnectionsPostError>> {
289 let local_var_configuration = configuration;
290
291 let local_var_client = &local_var_configuration.client;
292
293 let local_var_uri_str = format!(
294 "{}/organizations/connections",
295 local_var_configuration.base_path
296 );
297 let mut local_var_req_builder =
298 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
299
300 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
301 local_var_req_builder =
302 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
303 }
304 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
305 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
306 };
307 local_var_req_builder = local_var_req_builder.json(&organization_connection_request_model);
308
309 let local_var_req = local_var_req_builder.build()?;
310 let local_var_resp = local_var_client.execute(local_var_req).await?;
311
312 let local_var_status = local_var_resp.status();
313 let local_var_content = local_var_resp.text().await?;
314
315 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
316 serde_json::from_str(&local_var_content).map_err(Error::from)
317 } else {
318 let local_var_entity: Option<OrganizationsConnectionsPostError> =
319 serde_json::from_str(&local_var_content).ok();
320 let local_var_error = ResponseContent {
321 status: local_var_status,
322 content: local_var_content,
323 entity: local_var_entity,
324 };
325 Err(Error::ResponseError(local_var_error))
326 }
327}