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 prepare_login(&self, email: &str) -> Result<LoginPreparation, Error> {
9        let endpoint = format!("/session/prepare?email={}", email);
10        let response: crate::ApiResponse<LoginPreparation> = self.get(&endpoint).await?;
11        match response.data {
12            Some(preparation) => Ok(preparation),
13            None => Err(crate::Error::Api {
14                code: response.code,
15                message: response.msg,
16            }),
17        }
18    }
19
20    pub async fn prepare_openid_signin(
21        &self,
22        request: &OpenIdPrepareRequest<'_>,
23    ) -> Result<String, Error> {
24        let response: crate::ApiResponse<String> = self.put("/session/openid", request).await?;
25        match response.data {
26            Some(url) => Ok(url),
27            None => Err(crate::Error::Api {
28                code: response.code,
29                message: response.msg,
30            }),
31        }
32    }
33
34    pub async fn finish_openid_signin(
35        &self,
36        request: &OpenIdFinishRequest<'_>,
37    ) -> Result<LoginResponse, Error> {
38        let response: crate::ApiResponse<LoginResponse> =
39            self.post("/session/openid", request).await?;
40        match response.data {
41            Some(login_response) => Ok(login_response),
42            None => Err(crate::Error::Api {
43                code: response.code,
44                message: response.msg,
45            }),
46        }
47    }
48
49    pub async fn unlink_openid(&self, provider_id: i32) -> Result<(), Error> {
50        let endpoint = format!("/session/openid/{}", provider_id);
51        let response: crate::ApiResponse<()> = self.delete(&endpoint).await?;
52        if response.code == 0 {
53            Ok(())
54        } else {
55            Err(crate::Error::Api {
56                code: response.code,
57                message: response.msg,
58            })
59        }
60    }
61
62    pub async fn prepare_passkey_signin(&self) -> Result<PasskeySignInPreparation, Error> {
63        let response: crate::ApiResponse<PasskeySignInPreparation> =
64            self.put("/session/authn", &()).await?;
65        match response.data {
66            Some(preparation) => Ok(preparation),
67            None => Err(crate::Error::Api {
68                code: response.code,
69                message: response.msg,
70            }),
71        }
72    }
73
74    pub async fn finish_passkey_signin(
75        &self,
76        request: &PasskeySignInRequest<'_>,
77    ) -> Result<LoginResponse, Error> {
78        let response: crate::ApiResponse<LoginResponse> =
79            self.post("/session/authn", request).await?;
80        match response.data {
81            Some(login_response) => Ok(login_response),
82            None => Err(crate::Error::Api {
83                code: response.code,
84                message: response.msg,
85            }),
86        }
87    }
88
89    pub async fn login(&self, request: &LoginRequest<'_>) -> Result<LoginData, Error> {
90        let response: ApiResponse<LoginData> = self.post("/session/token", request).await?;
91        match response.data {
92            Some(data) => Ok(data),
93            None => Err(crate::Error::Api {
94                code: response.code,
95                message: response.msg,
96            }),
97        }
98    }
99
100    pub async fn finish_2fa_login(
101        &self,
102        request: &TwoFactorLoginRequest<'_>,
103    ) -> Result<Token, Error> {
104        let response: ApiResponse<Token> = self.post("/session/token/2fa", request).await?;
105        match response.data {
106            Some(token) => Ok(token),
107            None => Err(crate::Error::Api {
108                code: response.code,
109                message: response.msg,
110            }),
111        }
112    }
113
114    pub async fn refresh_token(&self, request: &RefreshTokenRequest<'_>) -> Result<Token, Error> {
115        let response: crate::ApiResponse<Token> =
116            self.post("/session/token/refresh", request).await?;
117        match response.data {
118            Some(token) => Ok(token),
119            None => Err(crate::Error::Api {
120                code: response.code,
121                message: response.msg,
122            }),
123        }
124    }
125
126    pub async fn logout(&self) -> Result<(), Error> {
127        let _: crate::ApiResponse<()> = self.delete("/session/token").await?;
128        Ok(())
129    }
130}
cloudreve_api/api/v4/session.rs

cloudreve_api/api/v4/
session.rs
