cloudreve_api/api/v4/
mod.rs

1//! API v4 implementation
2
3use crate::Error;
4use log::debug;
5use serde::Serialize;
6
7/// File management methods for v4 API
8pub mod file;
9/// Common data models for v4 API
10pub mod models;
11/// Session management methods for v4 API
12pub mod session;
13/// Share management methods for v4 API
14pub mod share;
15/// User management methods for v4 API
16pub mod user;
17/// Workflow management methods for v4 API
18pub mod workflow;
19
20/// API v4 client structure
21#[derive(Debug, Clone)]
22pub struct ApiV4Client {
23    /// Base URL for the Cloudreve instance
24    pub base_url: String,
25    /// HTTP client for making requests
26    pub http_client: reqwest::Client,
27    /// Authentication token
28    pub token: Option<String>,
29}
30
31impl ApiV4Client {
32    /// Creates a new API v4 client
33    pub fn new(base_url: &str) -> Self {
34        Self {
35            base_url: base_url.to_string(),
36            http_client: reqwest::Client::new(),
37            token: None,
38        }
39    }
40
41    /// Sets the authentication token
42    pub fn set_token(&mut self, token: String) {
43        self.token = Some(token);
44    }
45
46    /// Gets the full URL for an endpoint with /api/v4 prefix
47    fn get_url(&self, endpoint: &str) -> String {
48        format!(
49            "{}/api/v4/{}",
50            self.base_url.trim_end_matches('/'),
51            endpoint.trim_start_matches('/')
52        )
53    }
54
55    /// Makes a GET request to the API
56    pub async fn get<T>(&self, endpoint: &str) -> Result<T, Error>
57    where
58        T: serde::de::DeserializeOwned + std::fmt::Debug,
59    {
60        let url = self.get_url(endpoint);
61        let mut request = self.http_client.get(&url);
62
63        if let Some(token) = &self.token {
64            // request = request.header("Authorization", format!("Bearer {}", token));
65            request = request.bearer_auth(token);
66        }
67        debug!("GET URL: {}", url);
68
69        let response = request.send().await?;
70        let status = response.status();
71
72        // Get raw response text for better error reporting
73        let raw_text = response.text().await?;
74
75        match serde_json::from_str::<T>(&raw_text) {
76            Ok(json) => {
77                debug!("Response status: {}, JSON: {:?}", status, json);
78                Ok(json)
79            }
80            Err(e) => {
81                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
82                Err(Error::Json(e))
83            }
84        }
85    }
86
87    /// Makes a POST request to the API
88    pub async fn post<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
89    where
90        T: serde::de::DeserializeOwned + std::fmt::Debug,
91    {
92        let url = self.get_url(endpoint);
93        let mut request = self.http_client.post(&url).json(body);
94
95        if let Some(token) = &self.token {
96            // request = request.header("Authorization", format!("Bearer {}", token));
97            request = request.bearer_auth(token);
98        }
99
100        debug!("POST URL: {}", url);
101
102        let response = request.send().await?;
103        let status = response.status();
104        let json: T = response.json().await?;
105        debug!("Response status: {}, JSON: {:?}", status, json);
106        Ok(json)
107    }
108
109    /// Makes a PUT request to the API
110    pub async fn put<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
111    where
112        T: serde::de::DeserializeOwned + std::fmt::Debug,
113    {
114        let url = self.get_url(endpoint);
115        let mut request = self.http_client.put(&url).json(body);
116
117        if let Some(token) = &self.token {
118            // request = request.header("Authorization", format!("Bearer {}", token));
119            request = request.bearer_auth(token);
120        }
121        debug!("PUT URL: {}", url);
122
123        let response = request.send().await?;
124        let status = response.status();
125        let json: T = response.json().await?;
126
127        debug!("Response status: {}, JSON: {:?}", status, json);
128        Ok(json)
129    }
130
131    pub async fn patch<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
132    where
133        T: serde::de::DeserializeOwned + std::fmt::Debug,
134    {
135        let url = self.get_url(endpoint);
136        let mut request = self.http_client.patch(&url).json(body);
137
138        if let Some(token) = &self.token {
139            // request = request.header("Authorization", format!("Bearer {}", token));
140            request = request.bearer_auth(token);
141        }
142        debug!("PATCH URL: {}", url);
143
144        let response = request.send().await?;
145        let status = response.status();
146        let json: T = response.json().await?;
147
148        debug!("Response status: {}, JSON: {:?}", status, json);
149        Ok(json)
150    }
151
152    /// Makes a DELETE request to the API
153    pub async fn delete<T>(&self, endpoint: &str) -> Result<T, Error>
154    where
155        T: serde::de::DeserializeOwned + std::fmt::Debug,
156    {
157        let url = self.get_url(endpoint);
158        let mut request = self.http_client.delete(&url);
159
160        if let Some(token) = &self.token {
161            // request = request.header("Authorization", format!("Bearer {}", token));
162            request = request.bearer_auth(token);
163        }
164        debug!("DELETE URL: {}", url);
165
166        let response = request.send().await?;
167        let status = response.status();
168        let json: T = response.json().await?;
169
170        debug!("Response status: {}, JSON: {:?}", status, json);
171        Ok(json)
172    }
173}
cloudreve_api/api/v4/mod.rs

cloudreve_api/api/v4/
mod.rs
