clerk_rs/apis/
clients_api.rs1use reqwest;
12
13use super::Error;
14use crate::{apis::ResponseContent, clerk::Clerk};
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum GetClientError {
20 Status400(crate::models::ClerkErrors),
21 Status401(crate::models::ClerkErrors),
22 Status404(crate::models::ClerkErrors),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum GetClientLastActiveSessionError {
30 Status400(crate::models::ClerkErrors),
31 Status401(crate::models::ClerkErrors),
32 Status404(crate::models::ClerkErrors),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum GetClientListError {
40 Status400(crate::models::ClerkErrors),
41 Status401(crate::models::ClerkErrors),
42 Status422(crate::models::ClerkErrors),
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum VerifyClientError {
50 Status400(crate::models::ClerkErrors),
51 Status401(crate::models::ClerkErrors),
52 Status404(crate::models::ClerkErrors),
53 UnknownValue(serde_json::Value),
54}
55
56pub struct ClientApis;
57
58impl ClientApis {
59 pub async fn get_client(clerk_client: &Clerk, client_id: &str) -> Result<crate::models::Client, Error<GetClientError>> {
61 let local_var_configuration = &clerk_client.config;
62
63 let local_var_client = &local_var_configuration.client;
64
65 let local_var_uri_str = format!(
66 "{}/clients/{client_id}",
67 local_var_configuration.base_path,
68 client_id = crate::apis::urlencode(client_id)
69 );
70 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
71
72 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
73 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
74 }
75
76 let local_var_req = local_var_req_builder.build()?;
77 let local_var_resp = local_var_client.execute(local_var_req).await?;
78
79 let local_var_status = local_var_resp.status();
80 let local_var_content = local_var_resp.text().await?;
81
82 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
83 serde_json::from_str(&local_var_content).map_err(Error::from)
84 } else {
85 let local_var_entity: Option<GetClientError> = serde_json::from_str(&local_var_content).ok();
86 let local_var_error = ResponseContent {
87 status: local_var_status,
88 content: local_var_content,
89 entity: local_var_entity,
90 };
91 Err(Error::ResponseError(local_var_error))
92 }
93 }
94
95 pub async fn get_client_last_active_session(
97 clerk_client: &Clerk,
98 client_id: &str,
99 ) -> Result<crate::models::Session, Error<GetClientLastActiveSessionError>> {
100 let local_var_configuration = &clerk_client.config;
101
102 let local_var_client = &local_var_configuration.client;
103
104 let local_var_uri_str = format!(
105 "{}/clients/{client_id}/last_active_session",
106 local_var_configuration.base_path,
107 client_id = crate::apis::urlencode(client_id)
108 );
109 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
110
111 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
112 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
113 }
114
115 let local_var_req = local_var_req_builder.build()?;
116 let local_var_resp = local_var_client.execute(local_var_req).await?;
117
118 let local_var_status = local_var_resp.status();
119 let local_var_content = local_var_resp.text().await?;
120
121 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
122 serde_json::from_str(&local_var_content).map_err(Error::from)
123 } else {
124 let local_var_entity: Option<GetClientLastActiveSessionError> = serde_json::from_str(&local_var_content).ok();
125 let local_var_error = ResponseContent {
126 status: local_var_status,
127 content: local_var_content,
128 entity: local_var_entity,
129 };
130 Err(Error::ResponseError(local_var_error))
131 }
132 }
133
134 pub async fn get_client_list(
136 clerk_client: &Clerk,
137 limit: Option<u64>,
138 offset: Option<u64>,
139 ) -> Result<Vec<crate::models::Client>, Error<GetClientListError>> {
140 let local_var_configuration = &clerk_client.config;
141
142 let local_var_client = &local_var_configuration.client;
143
144 let local_var_uri_str = format!("{}/clients", local_var_configuration.base_path);
145 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
146
147 if let Some(ref local_var_str) = limit {
148 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
149 }
150 if let Some(ref local_var_str) = offset {
151 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
152 }
153 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
154 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
155 }
156
157 let local_var_req = local_var_req_builder.build()?;
158 let local_var_resp = local_var_client.execute(local_var_req).await?;
159
160 let local_var_status = local_var_resp.status();
161 let local_var_content = local_var_resp.text().await?;
162
163 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
164 serde_json::from_str(&local_var_content).map_err(Error::from)
165 } else {
166 let local_var_entity: Option<GetClientListError> = serde_json::from_str(&local_var_content).ok();
167 let local_var_error = ResponseContent {
168 status: local_var_status,
169 content: local_var_content,
170 entity: local_var_entity,
171 };
172 Err(Error::ResponseError(local_var_error))
173 }
174 }
175
176 pub async fn verify_client(
178 clerk_client: &Clerk,
179 verify_client_request: Option<crate::models::VerifyClientRequest>,
180 ) -> Result<crate::models::Client, Error<VerifyClientError>> {
181 let local_var_configuration = &clerk_client.config;
182
183 let local_var_client = &local_var_configuration.client;
184
185 let local_var_uri_str = format!("{}/clients/verify", local_var_configuration.base_path);
186 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
187
188 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
189 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
190 }
191
192 local_var_req_builder = local_var_req_builder.json(&verify_client_request);
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<VerifyClientError> = serde_json::from_str(&local_var_content).ok();
204 let local_var_error = ResponseContent {
205 status: local_var_status,
206 content: local_var_content,
207 entity: local_var_entity,
208 };
209 Err(Error::ResponseError(local_var_error))
210 }
211 }
212}