Skip to main content

cloudreve_api/api/v4/
site.rs

1//! Site-related API endpoints for Cloudreve API v4
2
3use crate::Error;
4use crate::VERSION;
5use crate::api::VersionInfo;
6use crate::api::v4::ApiV4Client;
7use crate::api::v4::models::*;
8
9impl ApiV4Client {
10    /// Get API version information
11    pub async fn get_version(&self) -> Result<VersionInfo, Error> {
12        let server_version = self.ping().await.unwrap_or_else(|_| "unknown".to_string());
13        Ok(VersionInfo {
14            api_version: "v4".to_string(),
15            library_version: VERSION.to_string(),
16            server_version,
17        })
18    }
19
20    /// Ping the server and get server version
21    pub async fn ping(&self) -> Result<String, Error> {
22        let response: crate::ApiResponse<String> = self.get("/site/ping").await?;
23        match response.data {
24            Some(version) => Ok(version),
25            None => Err(crate::Error::Api {
26                code: response.code,
27                message: response.msg,
28            }),
29        }
30    }
31
32    pub async fn get_site_config(&self, section: SiteConfigSection) -> Result<SiteConfig, Error> {
33        let endpoint = format!("/site/config/{}", section);
34        let response: crate::ApiResponse<SiteConfig> = self.get(&endpoint).await?;
35        match response.data {
36            Some(config) => Ok(config),
37            None => Err(crate::Error::Api {
38                code: response.code,
39                message: response.msg,
40            }),
41        }
42    }
43
44    /// Get site config by section string (for backward compatibility)
45    pub async fn get_site_config_str(&self, section: &str) -> Result<SiteConfig, Error> {
46        let endpoint = format!("/site/config/{}", section);
47        let response: crate::ApiResponse<SiteConfig> = self.get(&endpoint).await?;
48        match response.data {
49            Some(config) => Ok(config),
50            None => Err(crate::Error::Api {
51                code: response.code,
52                message: response.msg,
53            }),
54        }
55    }
56
57    pub async fn report_site_abuse(&self, request: &AbuseReportRequest<'_>) -> Result<(), Error> {
58        let response: crate::ApiResponse<()> = self.post("/site/abuse", request).await?;
59        if response.code == 0 {
60            Ok(())
61        } else {
62            Err(crate::Error::Api {
63                code: response.code,
64                message: response.msg,
65            })
66        }
67    }
68
69    pub async fn get_captcha(&self) -> Result<CaptchaResponse, Error> {
70        let response: crate::ApiResponse<CaptchaResponse> = self.get("/site/captcha").await?;
71        match response.data {
72            Some(captcha) => Ok(captcha),
73            None => Err(crate::Error::Api {
74                code: response.code,
75                message: response.msg,
76            }),
77        }
78    }
79
80    /// Check if CAPTCHA is required for login
81    pub async fn check_captcha_requirement(&self) -> Result<bool, Error> {
82        let config = self.get_site_config(SiteConfigSection::Login).await?;
83        Ok(config.login_captcha.unwrap_or(false))
84    }
85}