cloudreve_api/api/v4/
session.rs

1//! Session and authentication management for Cloudreve API v4
2
3use crate::api::v4::models::*;
4use crate::api::v4::ApiV4Client;
5use crate::Error;
6
7impl ApiV4Client {
8    pub async fn ping(&self) -> Result<String, Error> {
9        let response: crate::ApiResponse<String> = self.get("/site/ping").await?;
10        Ok(response.msg)
11    }
12
13    pub async fn get_site_config(&self, section: &str) -> Result<SiteConfig, Error> {
14        let endpoint = format!("/site/config/{}", section);
15        let response: crate::ApiResponse<SiteConfig> = self.get(&endpoint).await?;
16        match response.data {
17            Some(config) => Ok(config),
18            None => Err(crate::Error::Api {
19                code: response.code,
20                message: response.msg,
21            }),
22        }
23    }
24
25    pub async fn report_site_abuse(&self, request: &AbuseReportRequest<'_>) -> Result<(), Error> {
26        let response: crate::ApiResponse<()> = self.post("/site/abuse", request).await?;
27        if response.code == 0 {
28            Ok(())
29        } else {
30            Err(crate::Error::Api {
31                code: response.code,
32                message: response.msg,
33            })
34        }
35    }
36
37    pub async fn get_captcha(&self) -> Result<CaptchaResponse, Error> {
38        self.get("/site/captcha").await
39    }
40
41    pub async fn prepare_login(&self, email: &str) -> Result<LoginPreparation, Error> {
42        let endpoint = format!("/session/prepare?email={}", email);
43        let response: crate::ApiResponse<LoginPreparation> = self.get(&endpoint).await?;
44        match response.data {
45            Some(preparation) => Ok(preparation),
46            None => Err(crate::Error::Api {
47                code: response.code,
48                message: response.msg,
49            }),
50        }
51    }
52
53    pub async fn prepare_openid_signin(
54        &self,
55        request: &OpenIdPrepareRequest<'_>,
56    ) -> Result<String, Error> {
57        let response: crate::ApiResponse<String> = self.put("/session/openid", request).await?;
58        match response.data {
59            Some(url) => Ok(url),
60            None => Err(crate::Error::Api {
61                code: response.code,
62                message: response.msg,
63            }),
64        }
65    }
66
67    pub async fn finish_openid_signin(
68        &self,
69        request: &OpenIdFinishRequest<'_>,
70    ) -> Result<LoginResponse, Error> {
71        let response: crate::ApiResponse<LoginResponse> =
72            self.post("/session/openid", request).await?;
73        match response.data {
74            Some(login_response) => Ok(login_response),
75            None => Err(crate::Error::Api {
76                code: response.code,
77                message: response.msg,
78            }),
79        }
80    }
81
82    pub async fn unlink_openid(&self, provider_id: i32) -> Result<(), Error> {
83        let endpoint = format!("/session/openid/{}", provider_id);
84        let response: crate::ApiResponse<()> = self.delete(&endpoint).await?;
85        if response.code == 0 {
86            Ok(())
87        } else {
88            Err(crate::Error::Api {
89                code: response.code,
90                message: response.msg,
91            })
92        }
93    }
94
95    pub async fn prepare_passkey_signin(&self) -> Result<PasskeySignInPreparation, Error> {
96        let response: crate::ApiResponse<PasskeySignInPreparation> =
97            self.put("/session/authn", &()).await?;
98        match response.data {
99            Some(preparation) => Ok(preparation),
100            None => Err(crate::Error::Api {
101                code: response.code,
102                message: response.msg,
103            }),
104        }
105    }
106
107    pub async fn finish_passkey_signin(
108        &self,
109        request: &PasskeySignInRequest<'_>,
110    ) -> Result<LoginResponse, Error> {
111        let response: crate::ApiResponse<LoginResponse> =
112            self.post("/session/authn", request).await?;
113        match response.data {
114            Some(login_response) => Ok(login_response),
115            None => Err(crate::Error::Api {
116                code: response.code,
117                message: response.msg,
118            }),
119        }
120    }
121
122    pub async fn login(&self, request: &LoginRequest<'_>) -> Result<LoginData, Error> {
123        let response: ApiResponse<LoginData> = self.post("/session/token", request).await?;
124        match response.data {
125            Some(data) => Ok(data),
126            None => Err(crate::Error::Api {
127                code: response.code,
128                message: response.msg,
129            }),
130        }
131    }
132
133    pub async fn finish_2fa_login(
134        &self,
135        request: &TwoFactorLoginRequest<'_>,
136    ) -> Result<Token, Error> {
137        let response: ApiResponse<Token> = self.post("/session/token/2fa", request).await?;
138        match response.data {
139            Some(token) => Ok(token),
140            None => Err(crate::Error::Api {
141                code: response.code,
142                message: response.msg,
143            }),
144        }
145    }
146
147    pub async fn refresh_token(&self, request: &RefreshTokenRequest<'_>) -> Result<Token, Error> {
148        let response: crate::ApiResponse<Token> =
149            self.post("/session/token/refresh", request).await?;
150        match response.data {
151            Some(token) => Ok(token),
152            None => Err(crate::Error::Api {
153                code: response.code,
154                message: response.msg,
155            }),
156        }
157    }
158
159    pub async fn logout(&self) -> Result<(), Error> {
160        let _: crate::ApiResponse<()> = self.delete("/session/token").await?;
161        Ok(())
162    }
163}
cloudreve_api/api/v4/session.rs

cloudreve_api/api/v4/
session.rs
