rain_sdk/api/users.rs
1//! Users API
2//!
3//! This module provides functionality to manage users.
4
5use crate::client::RainClient;
6use crate::error::Result;
7use crate::models::charges::*;
8use crate::models::users::*;
9use uuid::Uuid;
10
11impl RainClient {
12 /// Get all users
13 ///
14 /// # Arguments
15 ///
16 /// * `params` - Query parameters for filtering users
17 ///
18 /// # Returns
19 ///
20 /// Returns a [`Vec<User>`] containing the list of users.
21 ///
22 /// # Examples
23 ///
24 /// ```no_run
25 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
26 /// use rain_sdk::models::users::ListUsersParams;
27 /// use uuid::Uuid;
28 ///
29 /// # #[cfg(feature = "async")]
30 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
31 /// let config = Config::new(Environment::Dev);
32 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
33 /// let client = RainClient::new(config, auth)?;
34 ///
35 /// let params = ListUsersParams {
36 /// company_id: None,
37 /// cursor: None,
38 /// limit: Some(20),
39 /// };
40 /// let users = client.list_users(¶ms).await?;
41 /// # Ok(())
42 /// # }
43 /// ```
44 #[cfg(feature = "async")]
45 pub async fn list_users(&self, params: &ListUsersParams) -> Result<Vec<User>> {
46 let mut path = "/issuing/users".to_string();
47 let mut query_parts = Vec::new();
48
49 if let Some(ref company_id) = params.company_id {
50 query_parts.push(format!("companyId={company_id}"));
51 }
52 if let Some(ref cursor) = params.cursor {
53 query_parts.push(format!("cursor={cursor}"));
54 }
55 if let Some(limit) = params.limit {
56 query_parts.push(format!("limit={limit}"));
57 }
58
59 if !query_parts.is_empty() {
60 path.push('?');
61 path.push_str(&query_parts.join("&"));
62 }
63
64 self.get(&path).await
65 }
66
67 /// Create an authorized user
68 ///
69 /// # Arguments
70 ///
71 /// * `request` - The user creation request
72 ///
73 /// # Returns
74 ///
75 /// Returns a [`User`] containing the created user information.
76 ///
77 /// # Examples
78 ///
79 /// ```no_run
80 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
81 /// use rain_sdk::models::users::CreateUserRequest;
82 ///
83 /// # #[cfg(feature = "async")]
84 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
85 /// let config = Config::new(Environment::Dev);
86 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
87 /// let client = RainClient::new(config, auth)?;
88 ///
89 /// let request = CreateUserRequest {
90 /// first_name: "John".to_string(),
91 /// last_name: "Doe".to_string(),
92 /// email: "john@example.com".to_string(),
93 /// wallet_address: None,
94 /// solana_address: None,
95 /// address: None,
96 /// phone_country_code: None,
97 /// phone_number: None,
98 /// };
99 /// let user = client.create_user(&request).await?;
100 /// # Ok(())
101 /// # }
102 /// ```
103 #[cfg(feature = "async")]
104 pub async fn create_user(&self, request: &CreateUserRequest) -> Result<User> {
105 let path = "/issuing/users";
106 self.post(path, request).await
107 }
108
109 /// Get a user by its ID
110 ///
111 /// # Arguments
112 ///
113 /// * `user_id` - The unique identifier of the user
114 ///
115 /// # Returns
116 ///
117 /// Returns a [`User`] containing the user information.
118 ///
119 /// # Examples
120 ///
121 /// ```no_run
122 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
123 /// use uuid::Uuid;
124 ///
125 /// # #[cfg(feature = "async")]
126 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
127 /// let config = Config::new(Environment::Dev);
128 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
129 /// let client = RainClient::new(config, auth)?;
130 ///
131 /// let user_id = Uuid::new_v4();
132 /// let user = client.get_user(&user_id).await?;
133 /// # Ok(())
134 /// # }
135 /// ```
136 #[cfg(feature = "async")]
137 pub async fn get_user(&self, user_id: &Uuid) -> Result<User> {
138 let path = format!("/issuing/users/{user_id}");
139 self.get(&path).await
140 }
141
142 /// Delete a user
143 ///
144 /// # Arguments
145 ///
146 /// * `user_id` - The unique identifier of the user
147 ///
148 /// # Returns
149 ///
150 /// Returns success (204 No Content).
151 ///
152 /// # Examples
153 ///
154 /// ```no_run
155 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
156 /// use uuid::Uuid;
157 ///
158 /// # #[cfg(feature = "async")]
159 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
160 /// let config = Config::new(Environment::Dev);
161 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
162 /// let client = RainClient::new(config, auth)?;
163 ///
164 /// let user_id = Uuid::new_v4();
165 /// client.delete_user(&user_id).await?;
166 /// # Ok(())
167 /// # }
168 /// ```
169 #[cfg(feature = "async")]
170 pub async fn delete_user(&self, user_id: &Uuid) -> Result<()> {
171 let path = format!("/issuing/users/{user_id}");
172 self.delete(&path).await
173 }
174
175 /// Update a user
176 ///
177 /// # Arguments
178 ///
179 /// * `user_id` - The unique identifier of the user
180 /// * `request` - The update request
181 ///
182 /// # Returns
183 ///
184 /// Returns a [`User`] containing the updated user information.
185 ///
186 /// # Examples
187 ///
188 /// ```no_run
189 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
190 /// use rain_sdk::models::users::UpdateUserRequest;
191 /// use uuid::Uuid;
192 ///
193 /// # #[cfg(feature = "async")]
194 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
195 /// let config = Config::new(Environment::Dev);
196 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
197 /// let client = RainClient::new(config, auth)?;
198 ///
199 /// let user_id = Uuid::new_v4();
200 /// let request = UpdateUserRequest {
201 /// first_name: Some("Jane".to_string()),
202 /// last_name: None,
203 /// email: None,
204 /// is_active: None,
205 /// is_terms_of_service_accepted: None,
206 /// address: None,
207 /// phone_country_code: None,
208 /// phone_number: None,
209 /// wallet_address: None,
210 /// solana_address: None,
211 /// tron_address: None,
212 /// stellar_address: None,
213 /// };
214 /// let user = client.update_user(&user_id, &request).await?;
215 /// # Ok(())
216 /// # }
217 /// ```
218 #[cfg(feature = "async")]
219 pub async fn update_user(&self, user_id: &Uuid, request: &UpdateUserRequest) -> Result<User> {
220 let path = format!("/issuing/users/{user_id}");
221 self.patch(&path, request).await
222 }
223
224 /// Charge a user a custom fee
225 ///
226 /// # Arguments
227 ///
228 /// * `user_id` - The unique identifier of the user
229 /// * `request` - The charge request
230 ///
231 /// # Returns
232 ///
233 /// Returns a [`Charge`] containing the created charge information.
234 ///
235 /// # Examples
236 ///
237 /// ```no_run
238 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
239 /// use rain_sdk::models::charges::CreateChargeRequest;
240 /// use uuid::Uuid;
241 ///
242 /// # #[cfg(feature = "async")]
243 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
244 /// let config = Config::new(Environment::Dev);
245 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
246 /// let client = RainClient::new(config, auth)?;
247 ///
248 /// let user_id = Uuid::new_v4();
249 /// let request = CreateChargeRequest {
250 /// amount: 500, // $5.00 in cents
251 /// description: "Custom fee".to_string(),
252 /// };
253 /// let charge = client.charge_user(&user_id, &request).await?;
254 /// # Ok(())
255 /// # }
256 /// ```
257 #[cfg(feature = "async")]
258 pub async fn charge_user(
259 &self,
260 user_id: &Uuid,
261 request: &CreateChargeRequest,
262 ) -> Result<Charge> {
263 let path = format!("/issuing/users/{user_id}/charges");
264 self.post(&path, request).await
265 }
266
267 // ============================================================================
268 // Blocking Methods
269 // ============================================================================
270
271 /// Get all users (blocking)
272 #[cfg(feature = "sync")]
273 pub fn list_users_blocking(&self, params: &ListUsersParams) -> Result<Vec<User>> {
274 let mut path = "/issuing/users".to_string();
275 let mut query_parts = Vec::new();
276
277 if let Some(ref company_id) = params.company_id {
278 query_parts.push(format!("companyId={company_id}"));
279 }
280 if let Some(ref cursor) = params.cursor {
281 query_parts.push(format!("cursor={cursor}"));
282 }
283 if let Some(limit) = params.limit {
284 query_parts.push(format!("limit={limit}"));
285 }
286
287 if !query_parts.is_empty() {
288 path.push('?');
289 path.push_str(&query_parts.join("&"));
290 }
291
292 self.get_blocking(&path)
293 }
294
295 /// Create an authorized user (blocking)
296 #[cfg(feature = "sync")]
297 pub fn create_user_blocking(&self, request: &CreateUserRequest) -> Result<User> {
298 let path = "/issuing/users";
299 self.post_blocking(path, request)
300 }
301
302 /// Get a user by its ID (blocking)
303 #[cfg(feature = "sync")]
304 pub fn get_user_blocking(&self, user_id: &Uuid) -> Result<User> {
305 let path = format!("/issuing/users/{user_id}");
306 self.get_blocking(&path)
307 }
308
309 /// Delete a user (blocking)
310 #[cfg(feature = "sync")]
311 pub fn delete_user_blocking(&self, user_id: &Uuid) -> Result<()> {
312 let path = format!("/issuing/users/{user_id}");
313 self.delete_blocking(&path)
314 }
315
316 /// Update a user (blocking)
317 #[cfg(feature = "sync")]
318 pub fn update_user_blocking(
319 &self,
320 user_id: &Uuid,
321 request: &UpdateUserRequest,
322 ) -> Result<User> {
323 let path = format!("/issuing/users/{user_id}");
324 self.patch_blocking(&path, request)
325 }
326
327 /// Charge a user a custom fee (blocking)
328 #[cfg(feature = "sync")]
329 pub fn charge_user_blocking(
330 &self,
331 user_id: &Uuid,
332 request: &CreateChargeRequest,
333 ) -> Result<Charge> {
334 let path = format!("/issuing/users/{user_id}/charges");
335 self.post_blocking(&path, request)
336 }
337}