cloudreve_api/api/v4/
user.rs

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

cloudreve_api/api/v4/
user.rs
