1use reqwest;
12
13use super::Error;
14use crate::{apis::ResponseContent, clerk::Clerk};
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CreateSessionTokenFromTemplateError {
20 Status401(crate::models::ClerkErrors),
21 Status404(crate::models::ClerkErrors),
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum GetSessionError {
29 Status400(crate::models::ClerkErrors),
30 Status401(crate::models::ClerkErrors),
31 Status404(crate::models::ClerkErrors),
32 UnknownValue(serde_json::Value),
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
37#[serde(untagged)]
38pub enum GetSessionListError {
39 Status400(crate::models::ClerkErrors),
40 Status401(crate::models::ClerkErrors),
41 Status422(crate::models::ClerkErrors),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum RevokeSessionError {
49 Status400(crate::models::ClerkErrors),
50 Status401(crate::models::ClerkErrors),
51 Status404(crate::models::ClerkErrors),
52 UnknownValue(serde_json::Value),
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum VerifySessionError {
59 Status400(crate::models::ClerkErrors),
60 Status401(crate::models::ClerkErrors),
61 Status404(crate::models::ClerkErrors),
62 UnknownValue(serde_json::Value),
63}
64
65pub struct Session;
66
67impl Session {
68 pub async fn create_session_token_from_template(
70 clerk_client: &Clerk,
71 session_id: &str,
72 template_name: &str,
73 ) -> Result<crate::models::CreateSessionTokenFromTemplate200Response, Error<CreateSessionTokenFromTemplateError>> {
74 let local_var_configuration = &clerk_client.config;
75
76 let local_var_client = &local_var_configuration.client;
77
78 let local_var_uri_str = format!(
79 "{}/sessions/{session_id}/tokens/{template_name}",
80 local_var_configuration.base_path,
81 session_id = crate::apis::urlencode(session_id),
82 template_name = crate::apis::urlencode(template_name)
83 );
84 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
85
86 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
87 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
88 }
89
90 let local_var_req = local_var_req_builder.build()?;
91 let local_var_resp = local_var_client.execute(local_var_req).await?;
92
93 let local_var_status = local_var_resp.status();
94 let local_var_content = local_var_resp.text().await?;
95
96 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
97 serde_json::from_str(&local_var_content).map_err(Error::from)
98 } else {
99 let local_var_entity: Option<CreateSessionTokenFromTemplateError> = serde_json::from_str(&local_var_content).ok();
100 let local_var_error = ResponseContent {
101 status: local_var_status,
102 content: local_var_content,
103 entity: local_var_entity,
104 };
105 Err(Error::ResponseError(local_var_error))
106 }
107 }
108
109 pub async fn get_session(clerk_client: &Clerk, session_id: &str) -> Result<crate::models::Session, Error<GetSessionError>> {
111 let local_var_configuration = &clerk_client.config;
112
113 let local_var_client = &local_var_configuration.client;
114
115 let local_var_uri_str = format!(
116 "{}/sessions/{session_id}",
117 local_var_configuration.base_path,
118 session_id = crate::apis::urlencode(session_id)
119 );
120 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
121
122 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
123 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
124 }
125
126 let local_var_req = local_var_req_builder.build()?;
127 let local_var_resp = local_var_client.execute(local_var_req).await?;
128
129 let local_var_status = local_var_resp.status();
130 let local_var_content = local_var_resp.text().await?;
131
132 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
133 serde_json::from_str(&local_var_content).map_err(Error::from)
134 } else {
135 let local_var_entity: Option<GetSessionError> = serde_json::from_str(&local_var_content).ok();
136 let local_var_error = ResponseContent {
137 status: local_var_status,
138 content: local_var_content,
139 entity: local_var_entity,
140 };
141 Err(Error::ResponseError(local_var_error))
142 }
143 }
144
145 pub async fn get_session_list(
147 clerk_client: &Clerk,
148 client_id: Option<&str>,
149 user_id: Option<&str>,
150 status: Option<&str>,
151 limit: Option<u64>,
152 offset: Option<u64>,
153 ) -> Result<Vec<crate::models::Session>, Error<GetSessionListError>> {
154 let local_var_configuration = &clerk_client.config;
155
156 let local_var_client = &local_var_configuration.client;
157
158 let local_var_uri_str = format!("{}/sessions", local_var_configuration.base_path);
159 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
160
161 if let Some(ref local_var_str) = client_id {
162 local_var_req_builder = local_var_req_builder.query(&[("client_id", &local_var_str.to_string())]);
163 }
164 if let Some(ref local_var_str) = user_id {
165 local_var_req_builder = local_var_req_builder.query(&[("user_id", &local_var_str.to_string())]);
166 }
167 if let Some(ref local_var_str) = status {
168 local_var_req_builder = local_var_req_builder.query(&[("status", &local_var_str.to_string())]);
169 }
170 if let Some(ref local_var_str) = limit {
171 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
172 }
173 if let Some(ref local_var_str) = offset {
174 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
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<GetSessionListError> = 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 revoke_session(clerk_client: &Clerk, session_id: &str) -> Result<crate::models::Session, Error<RevokeSessionError>> {
201 let local_var_configuration = &clerk_client.config;
202
203 let local_var_client = &local_var_configuration.client;
204
205 let local_var_uri_str = format!(
206 "{}/sessions/{session_id}/revoke",
207 local_var_configuration.base_path,
208 session_id = crate::apis::urlencode(session_id)
209 );
210 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, 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 = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
214 }
215
216 let local_var_req = local_var_req_builder.build()?;
217 let local_var_resp = local_var_client.execute(local_var_req).await?;
218
219 let local_var_status = local_var_resp.status();
220 let local_var_content = local_var_resp.text().await?;
221
222 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
223 serde_json::from_str(&local_var_content).map_err(Error::from)
224 } else {
225 let local_var_entity: Option<RevokeSessionError> = serde_json::from_str(&local_var_content).ok();
226 let local_var_error = ResponseContent {
227 status: local_var_status,
228 content: local_var_content,
229 entity: local_var_entity,
230 };
231 Err(Error::ResponseError(local_var_error))
232 }
233 }
234
235 pub async fn verify_session(
237 clerk_client: &Clerk,
238 session_id: &str,
239 verify_session_request: Option<crate::models::VerifySessionRequest>,
240 ) -> Result<crate::models::Session, Error<VerifySessionError>> {
241 let local_var_configuration = &clerk_client.config;
242
243 let local_var_client = &local_var_configuration.client;
244
245 let local_var_uri_str = format!(
246 "{}/sessions/{session_id}/verify",
247 local_var_configuration.base_path,
248 session_id = crate::apis::urlencode(session_id)
249 );
250 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
251
252 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
253 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
254 }
255
256 local_var_req_builder = local_var_req_builder.json(&verify_session_request);
257
258 let local_var_req = local_var_req_builder.build()?;
259 let local_var_resp = local_var_client.execute(local_var_req).await?;
260
261 let local_var_status = local_var_resp.status();
262 let local_var_content = local_var_resp.text().await?;
263
264 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
265 serde_json::from_str(&local_var_content).map_err(Error::from)
266 } else {
267 let local_var_entity: Option<VerifySessionError> = serde_json::from_str(&local_var_content).ok();
268 let local_var_error = ResponseContent {
269 status: local_var_status,
270 content: local_var_content,
271 entity: local_var_entity,
272 };
273 Err(Error::ResponseError(local_var_error))
274 }
275 }
276}