cloudreve_api/api/v4/
user.rs

1//! User-related API endpoints for Cloudreve v4 API
2
3use crate::api::v4::models::*;
4use crate::api::v4::ApiV4Client;
5use crate::Error;
6
7impl ApiV4Client {
8    pub async fn register(&self, request: &RegisterRequest<'_>) -> Result<User, Error> {
9        let response: ApiResponse<User> = self.post("/user/register", request).await?;
10        Ok(response.data.unwrap())
11    }
12
13    pub async fn get_current_user(&self) -> Result<User, Error> {
14        let response: ApiResponse<User> = self.get("/user").await?;
15        Ok(response.data.unwrap())
16    }
17
18    pub async fn get_user_capacity(&self) -> Result<Quota, Error> {
19        let response: ApiResponse<Quota> = self.get("/user/capacity").await?;
20        Ok(response.data.unwrap())
21    }
22
23    pub async fn search_users(&self, request: &SearchUserRequest<'_>) -> Result<Vec<User>, Error> {
24        let endpoint = format!("/user/search?q={}", request.query);
25        let mut query_params = Vec::new();
26        if let Some(page) = request.page {
27            query_params.push(format!("page={}", page));
28        }
29        if let Some(page_size) = request.page_size {
30            query_params.push(format!("page_size={}", page_size));
31        }
32
33        let full_endpoint = if !query_params.is_empty() {
34            format!("{}&{}", endpoint, query_params.join("&"))
35        } else {
36            endpoint
37        };
38
39        let response: ApiResponse<Vec<User>> = self.get(&full_endpoint).await?;
40        Ok(response.data.unwrap())
41    }
42
43    pub async fn get_credit_changes(
44        &self,
45        page: Option<u32>,
46        page_size: Option<u32>,
47    ) -> Result<Vec<CreditChangeRecord>, Error> {
48        let mut endpoint = "/user/creditChanges".to_string();
49        let mut query_params = Vec::new();
50        if let Some(p) = page {
51            query_params.push(format!("page={}", p));
52        }
53        if let Some(ps) = page_size {
54            query_params.push(format!("page_size={}", ps));
55        }
56
57        if !query_params.is_empty() {
58            endpoint = format!("{}?{}", endpoint, query_params.join("&"));
59        }
60
61        let response: ApiResponse<Vec<CreditChangeRecord>> = self.get(&endpoint).await?;
62        Ok(response.data.unwrap())
63    }
64
65    pub async fn get_payment_records(
66        &self,
67        page: Option<u32>,
68        page_size: Option<u32>,
69    ) -> Result<Vec<PaymentRecord>, Error> {
70        let mut endpoint = "/user/payments".to_string();
71        let mut query_params = Vec::new();
72        if let Some(p) = page {
73            query_params.push(format!("page={}", p));
74        }
75        if let Some(ps) = page_size {
76            query_params.push(format!("page_size={}", ps));
77        }
78
79        if !query_params.is_empty() {
80            endpoint = format!("{}?{}", endpoint, query_params.join("&"));
81        }
82
83        let response: ApiResponse<Vec<PaymentRecord>> = self.get(&endpoint).await?;
84        Ok(response.data.unwrap())
85    }
86
87    pub async fn update_user_setting(
88        &self,
89        setting: &UpdateUserSettingRequest<'_>,
90    ) -> Result<(), Error> {
91        let response: ApiResponse<()> = self.patch("/user/setting", setting).await?;
92        if response.code == 0 {
93            Ok(())
94        } else {
95            Err(Error::Api {
96                code: response.code,
97                message: response.msg,
98            })
99        }
100    }
101
102    pub async fn get_user_setting(&self) -> Result<UserSettings, Error> {
103        let response: ApiResponse<UserSettings> = self.get("/user/setting").await?;
104        Ok(response.data.unwrap())
105    }
106
107    pub async fn enable_two_factor(&self) -> Result<TwoFactorSetup, Error> {
108        let response: ApiResponse<TwoFactorSetup> = self.post("/user/2fa/enable", &()).await?;
109        Ok(response.data.unwrap())
110    }
111
112    pub async fn verify_two_factor(&self, request: &TwoFactorVerify) -> Result<(), Error> {
113        let response: ApiResponse<()> = self.post("/user/2fa/verify", request).await?;
114        if response.code == 0 {
115            Ok(())
116        } else {
117            Err(Error::Api {
118                code: response.code,
119                message: response.msg,
120            })
121        }
122    }
123
124    pub async fn disable_two_factor(&self) -> Result<(), Error> {
125        let response: ApiResponse<()> = self.delete("/user/2fa/disable").await?;
126        if response.code == 0 {
127            Ok(())
128        } else {
129            Err(Error::Api {
130                code: response.code,
131                message: response.msg,
132            })
133        }
134    }
135
136    pub async fn get_user_avatar(&self, user_id: &str) -> Result<String, Error> {
137        let endpoint = format!("/user/avatar/{}", user_id);
138        let response: ApiResponse<String> = self.get(&endpoint).await?;
139        Ok(response.data.unwrap_or_default())
140    }
141
142    pub async fn get_user_info(&self, user_id: &str) -> Result<User, Error> {
143        let endpoint = format!("/user/info/{}", user_id);
144        let response: ApiResponse<User> = self.get(&endpoint).await?;
145        Ok(response.data.unwrap())
146    }
147
148    pub async fn get_user_shares(
149        &self,
150        user_id: &str,
151        page: Option<u32>,
152        page_size: Option<u32>,
153    ) -> Result<Vec<ShareLink>, Error> {
154        let mut endpoint = format!("/user/shares/{}", user_id);
155        let mut query_params = Vec::new();
156        if let Some(p) = page {
157            query_params.push(format!("page={}", p));
158        }
159        if let Some(ps) = page_size {
160            query_params.push(format!("page_size={}", ps));
161        }
162
163        if !query_params.is_empty() {
164            endpoint = format!("{}?{}", endpoint, query_params.join("&"));
165        }
166
167        let response: ApiResponse<Vec<ShareLink>> = self.get(&endpoint).await?;
168        Ok(response.data.unwrap())
169    }
170
171    pub async fn update_profile(&self, request: &UpdateProfileRequest<'_>) -> Result<User, Error> {
172        let response: ApiResponse<User> = self.put("/user/profile", request).await?;
173        Ok(response.data.unwrap())
174    }
175
176    pub async fn change_password(
177        &self,
178        old_password: &str,
179        new_password: &str,
180    ) -> Result<(), Error> {
181        let request = ChangePasswordRequest {
182            old_password,
183            new_password,
184        };
185        let _: ApiResponse<()> = self.post("/user/password", &request).await?;
186        Ok(())
187    }
188
189    pub async fn get_quota(&self) -> Result<Quota, Error> {
190        let response: ApiResponse<Quota> = self.get("/user/quota").await?;
191        Ok(response.data.unwrap())
192    }
193
194    pub async fn get_settings(&self) -> Result<UserSettings, Error> {
195        let response: ApiResponse<UserSettings> = self.get("/user/settings").await?;
196        Ok(response.data.unwrap())
197    }
198
199    pub async fn update_settings(&self, settings: &UserSettings) -> Result<UserSettings, Error> {
200        let response: ApiResponse<UserSettings> = self.put("/user/settings", settings).await?;
201        Ok(response.data.unwrap())
202    }
203
204    pub async fn get_storage_policies(&self) -> Result<Vec<StoragePolicy>, Error> {
205        let response: ApiResponse<Vec<StoragePolicy>> = self.get("/user/setting/policies").await?;
206
207        // Check for API error response
208        if response.code != 0 {
209            return Err(Error::Api {
210                code: response.code,
211                message: response.msg,
212            });
213        }
214
215        Ok(response.data.unwrap_or_default())
216    }
217}
cloudreve_api/api/v4/user.rs

cloudreve_api/api/v4/
user.rs
