circle_user_controlled_wallets/models/
user.rs1use serde::{Deserialize, Serialize};
7
8use super::common::PageParams;
9
10#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
14#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
15pub enum PinStatus {
16 Enabled,
18 Unset,
20 Locked,
22}
23
24#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
26#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
27pub enum EndUserStatus {
28 Enabled,
30 Disabled,
32}
33
34#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
36#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
37pub enum SecurityQuestionStatus {
38 Enabled,
40 Unset,
42 Locked,
44}
45
46#[derive(Debug, Clone, Default, Deserialize, Serialize)]
50#[serde(rename_all = "camelCase")]
51pub struct PinSecurityDetails {
52 pub failed_attempts: Option<i32>,
54 pub locked_date: Option<String>,
56 pub locked_expiry_date: Option<String>,
58 pub last_lock_override_date: Option<String>,
60}
61
62#[derive(Debug, Clone, Default, Deserialize, Serialize)]
64#[serde(rename_all = "camelCase")]
65pub struct EndUser {
66 pub id: Option<String>,
68 pub create_date: Option<String>,
70 pub pin_status: Option<PinStatus>,
72 pub status: Option<EndUserStatus>,
74 pub security_question_status: Option<SecurityQuestionStatus>,
76 pub pin_details: Option<serde_json::Value>,
78 pub security_question_details: Option<serde_json::Value>,
80}
81
82#[derive(Debug, Clone, Deserialize, Serialize)]
86#[serde(rename_all = "camelCase")]
87pub struct UsersData {
88 pub users: Vec<EndUser>,
90}
91
92#[derive(Debug, Clone, Deserialize, Serialize)]
94#[serde(rename_all = "camelCase")]
95pub struct Users {
96 pub data: UsersData,
98}
99
100#[derive(Debug, Clone, Deserialize, Serialize)]
104#[serde(rename_all = "camelCase")]
105pub struct UserResponse {
106 pub data: EndUser,
108}
109
110#[derive(Debug, Clone, Deserialize, Serialize)]
112#[serde(rename_all = "camelCase")]
113pub struct GetUserByIdData {
114 pub user: EndUser,
116}
117
118#[derive(Debug, Clone, Deserialize, Serialize)]
120#[serde(rename_all = "camelCase")]
121pub struct GetUserByIdResponse {
122 pub data: GetUserByIdData,
124}
125
126#[derive(Debug, Clone, Deserialize, Serialize)]
128#[serde(rename_all = "camelCase")]
129pub struct UserTokenData {
130 pub user_token: String,
132 pub encryption_key: Option<String>,
134}
135
136#[derive(Debug, Clone, Deserialize, Serialize)]
138#[serde(rename_all = "camelCase")]
139pub struct UserTokenResponse {
140 pub data: UserTokenData,
142}
143
144#[derive(Debug, Clone, Deserialize, Serialize)]
148#[serde(rename_all = "camelCase")]
149pub struct CreateUserRequest {
150 pub user_id: String,
152}
153
154#[derive(Debug, Clone, Deserialize, Serialize)]
156#[serde(rename_all = "camelCase")]
157pub struct GetUserTokenRequest {
158 pub user_id: String,
160}
161
162#[derive(Debug, Clone, Default, Deserialize, Serialize)]
164#[serde(rename_all = "camelCase")]
165pub struct ListUsersParams {
166 pub pin_status: Option<PinStatus>,
168 #[serde(flatten)]
170 pub page: PageParams,
171}
172
173#[cfg(test)]
176mod tests {
177 use super::*;
178
179 #[test]
180 fn pin_status_screaming_snake_case() -> Result<(), Box<dyn std::error::Error>> {
181 assert_eq!(serde_json::to_string(&PinStatus::Locked)?, "\"LOCKED\"");
182 assert_eq!(serde_json::to_string(&PinStatus::Unset)?, "\"UNSET\"");
183 Ok(())
184 }
185
186 #[test]
187 fn end_user_round_trip() -> Result<(), Box<dyn std::error::Error>> {
188 let user = EndUser {
189 id: Some("user-123".to_string()),
190 create_date: Some("2024-01-01T00:00:00Z".to_string()),
191 pin_status: Some(PinStatus::Enabled),
192 status: Some(EndUserStatus::Enabled),
193 security_question_status: Some(SecurityQuestionStatus::Unset),
194 pin_details: None,
195 security_question_details: None,
196 };
197 let json = serde_json::to_string(&user)?;
198 let decoded: EndUser = serde_json::from_str(&json)?;
199 assert_eq!(decoded.id, user.id);
200 assert_eq!(decoded.pin_status, Some(PinStatus::Enabled));
201 Ok(())
202 }
203
204 #[test]
205 fn create_user_request_serializes() -> Result<(), Box<dyn std::error::Error>> {
206 let req = CreateUserRequest { user_id: "user-abc".to_string() };
207 let json = serde_json::to_string(&req)?;
208 assert!(json.contains("userId"), "expected camelCase userId in {json}");
209 Ok(())
210 }
211}