1use reqwest;
12
13use super::Error;
14use crate::{apis::ResponseContent, clerk::Clerk};
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CreateOrganizationError {
20 Status400(crate::models::ClerkErrors),
21 Status403(crate::models::ClerkErrors),
22 Status422(crate::models::ClerkErrors),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum DeleteOrganizationError {
30 Status404(crate::models::ClerkErrors),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum GetOrganizationError {
38 Status403(crate::models::ClerkErrors),
39 Status404(crate::models::ClerkErrors),
40 UnknownValue(serde_json::Value),
41}
42
43#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(untagged)]
46pub enum ListOrganizationsError {
47 Status400(crate::models::ClerkErrors),
48 Status403(crate::models::ClerkErrors),
49 Status422(crate::models::ClerkErrors),
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum MergeOrganizationMetadataError {
57 Status400(crate::models::ClerkErrors),
58 Status401(crate::models::ClerkErrors),
59 Status404(crate::models::ClerkErrors),
60 Status422(crate::models::ClerkErrors),
61 UnknownValue(serde_json::Value),
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize)]
66#[serde(untagged)]
67pub enum UpdateOrganizationError {
68 Status404(crate::models::ClerkErrors),
69 Status422(crate::models::ClerkErrors),
70 UnknownValue(serde_json::Value),
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum UploadOrganizationLogoError {
77 Status400(crate::models::ClerkErrors),
78 Status403(crate::models::ClerkErrors),
79 Status404(crate::models::ClerkErrors),
80 Status413(crate::models::ClerkErrors),
81 UnknownValue(serde_json::Value),
82}
83
84pub struct Organization;
85
86impl Organization {
87 pub async fn create_organization(
89 clerk_client: &Clerk,
90 create_organization_request: Option<crate::models::CreateOrganizationRequest>,
91 ) -> Result<crate::models::Organization, Error<CreateOrganizationError>> {
92 let local_var_configuration = &clerk_client.config;
93
94 let local_var_client = &local_var_configuration.client;
95
96 let local_var_uri_str = format!("{}/organizations", local_var_configuration.base_path);
97 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
98
99 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
100 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
101 }
102
103 local_var_req_builder = local_var_req_builder.json(&create_organization_request);
104
105 let local_var_req = local_var_req_builder.build()?;
106 let local_var_resp = local_var_client.execute(local_var_req).await?;
107
108 let local_var_status = local_var_resp.status();
109 let local_var_content = local_var_resp.text().await?;
110
111 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
112 serde_json::from_str(&local_var_content).map_err(Error::from)
113 } else {
114 let local_var_entity: Option<CreateOrganizationError> = serde_json::from_str(&local_var_content).ok();
115 let local_var_error = ResponseContent {
116 status: local_var_status,
117 content: local_var_content,
118 entity: local_var_entity,
119 };
120 Err(Error::ResponseError(local_var_error))
121 }
122 }
123
124 pub async fn delete_organization(
126 clerk_client: &Clerk,
127 organization_id: &str,
128 ) -> Result<crate::models::DeletedObject, Error<DeleteOrganizationError>> {
129 let local_var_configuration = &clerk_client.config;
130
131 let local_var_client = &local_var_configuration.client;
132
133 let local_var_uri_str = format!(
134 "{}/organizations/{organization_id}",
135 local_var_configuration.base_path,
136 organization_id = crate::apis::urlencode(organization_id)
137 );
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
144 let local_var_req = local_var_req_builder.build()?;
145 let local_var_resp = local_var_client.execute(local_var_req).await?;
146
147 let local_var_status = local_var_resp.status();
148 let local_var_content = local_var_resp.text().await?;
149
150 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
151 serde_json::from_str(&local_var_content).map_err(Error::from)
152 } else {
153 let local_var_entity: Option<DeleteOrganizationError> = serde_json::from_str(&local_var_content).ok();
154 let local_var_error = ResponseContent {
155 status: local_var_status,
156 content: local_var_content,
157 entity: local_var_entity,
158 };
159 Err(Error::ResponseError(local_var_error))
160 }
161 }
162
163 pub async fn get_organization(clerk_client: &Clerk, organization_id: &str) -> Result<crate::models::Organization, Error<GetOrganizationError>> {
165 let local_var_configuration = &clerk_client.config;
166
167 let local_var_client = &local_var_configuration.client;
168
169 let local_var_uri_str = format!(
170 "{}/organizations/{organization_id}",
171 local_var_configuration.base_path,
172 organization_id = crate::apis::urlencode(organization_id)
173 );
174 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
175
176 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
177 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
178 }
179
180 let local_var_req = local_var_req_builder.build()?;
181 let local_var_resp = local_var_client.execute(local_var_req).await?;
182
183 let local_var_status = local_var_resp.status();
184 let local_var_content = local_var_resp.text().await?;
185
186 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
187 serde_json::from_str(&local_var_content).map_err(Error::from)
188 } else {
189 let local_var_entity: Option<GetOrganizationError> = serde_json::from_str(&local_var_content).ok();
190 let local_var_error = ResponseContent {
191 status: local_var_status,
192 content: local_var_content,
193 entity: local_var_entity,
194 };
195 Err(Error::ResponseError(local_var_error))
196 }
197 }
198
199 pub async fn list_organizations(
201 clerk_client: &Clerk,
202 limit: Option<u64>,
203 offset: Option<u64>,
204 include_members_count: Option<bool>,
205 query: Option<&str>,
206 ) -> Result<crate::models::Organizations, Error<ListOrganizationsError>> {
207 let local_var_configuration = &clerk_client.config;
208
209 let local_var_client = &local_var_configuration.client;
210
211 let local_var_uri_str = format!("{}/organizations", local_var_configuration.base_path);
212 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
213
214 if let Some(ref local_var_str) = limit {
215 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
216 }
217 if let Some(ref local_var_str) = offset {
218 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
219 }
220 if let Some(ref local_var_str) = include_members_count {
221 local_var_req_builder = local_var_req_builder.query(&[("include_members_count", &local_var_str.to_string())]);
222 }
223 if let Some(ref local_var_str) = query {
224 local_var_req_builder = local_var_req_builder.query(&[("query", &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
230 let local_var_req = local_var_req_builder.build()?;
231 let local_var_resp = local_var_client.execute(local_var_req).await?;
232
233 let local_var_status = local_var_resp.status();
234 let local_var_content = local_var_resp.text().await?;
235
236 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
237 serde_json::from_str(&local_var_content).map_err(Error::from)
238 } else {
239 let local_var_entity: Option<ListOrganizationsError> = serde_json::from_str(&local_var_content).ok();
240 let local_var_error = ResponseContent {
241 status: local_var_status,
242 content: local_var_content,
243 entity: local_var_entity,
244 };
245 Err(Error::ResponseError(local_var_error))
246 }
247 }
248
249 pub async fn merge_organization_metadata(
251 clerk_client: &Clerk,
252 organization_id: &str,
253 merge_organization_metadata_request: crate::models::MergeOrganizationMetadataRequest,
254 ) -> Result<crate::models::Organization, Error<MergeOrganizationMetadataError>> {
255 let local_var_configuration = &clerk_client.config;
256
257 let local_var_client = &local_var_configuration.client;
258
259 let local_var_uri_str = format!(
260 "{}/organizations/{organization_id}/metadata",
261 local_var_configuration.base_path,
262 organization_id = crate::apis::urlencode(organization_id)
263 );
264 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
265
266 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
267 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
268 }
269
270 local_var_req_builder = local_var_req_builder.json(&merge_organization_metadata_request);
271
272 let local_var_req = local_var_req_builder.build()?;
273 let local_var_resp = local_var_client.execute(local_var_req).await?;
274
275 let local_var_status = local_var_resp.status();
276 let local_var_content = local_var_resp.text().await?;
277
278 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
279 serde_json::from_str(&local_var_content).map_err(Error::from)
280 } else {
281 let local_var_entity: Option<MergeOrganizationMetadataError> = serde_json::from_str(&local_var_content).ok();
282 let local_var_error = ResponseContent {
283 status: local_var_status,
284 content: local_var_content,
285 entity: local_var_entity,
286 };
287 Err(Error::ResponseError(local_var_error))
288 }
289 }
290
291 pub async fn update_organization(
293 clerk_client: &Clerk,
294 organization_id: &str,
295 update_organization_request: crate::models::UpdateOrganizationRequest,
296 ) -> Result<crate::models::Organization, Error<UpdateOrganizationError>> {
297 let local_var_configuration = &clerk_client.config;
298
299 let local_var_client = &local_var_configuration.client;
300
301 let local_var_uri_str = format!(
302 "{}/organizations/{organization_id}",
303 local_var_configuration.base_path,
304 organization_id = crate::apis::urlencode(organization_id)
305 );
306 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
307
308 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
309 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
310 }
311
312 local_var_req_builder = local_var_req_builder.json(&update_organization_request);
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<UpdateOrganizationError> = 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 pub async fn upload_organization_logo(
335 clerk_client: &Clerk,
336 organization_id: &str,
337 uploader_user_id: Option<&str>,
338 ) -> Result<crate::models::OrganizationWithLogo, Error<UploadOrganizationLogoError>> {
339 let local_var_configuration = &clerk_client.config;
340
341 let local_var_client = &local_var_configuration.client;
342
343 let local_var_uri_str = format!(
344 "{}/organizations/{organization_id}/logo",
345 local_var_configuration.base_path,
346 organization_id = crate::apis::urlencode(organization_id)
347 );
348 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
349
350 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
351 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
352 }
353
354 let mut local_var_form = reqwest::multipart::Form::new();
355 if let Some(local_var_param_value) = uploader_user_id {
356 local_var_form = local_var_form.text("uploader_user_id", local_var_param_value.to_string());
357 }
358 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
360
361 let local_var_req = local_var_req_builder.build()?;
362 let local_var_resp = local_var_client.execute(local_var_req).await?;
363
364 let local_var_status = local_var_resp.status();
365 let local_var_content = local_var_resp.text().await?;
366
367 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
368 serde_json::from_str(&local_var_content).map_err(Error::from)
369 } else {
370 let local_var_entity: Option<UploadOrganizationLogoError> = serde_json::from_str(&local_var_content).ok();
371 let local_var_error = ResponseContent {
372 status: local_var_status,
373 content: local_var_content,
374 entity: local_var_entity,
375 };
376 Err(Error::ResponseError(local_var_error))
377 }
378 }
379}