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/// URI handling utilities for v4 API
12pub mod uri;
13/// Session management methods for v4 API
14pub mod session;
15/// Share management methods for v4 API
16pub mod share;
17/// Site-related methods for v4 API
18pub mod site;
19/// WebDAV account management methods for v4 API
20pub mod dav;
21/// User management methods for v4 API
22pub mod user;
23/// Workflow management methods for v4 API
24pub mod workflow;
25
26/// API v4 client structure
27#[derive(Debug, Clone)]
28pub struct ApiV4Client {
29    /// Base URL for the Cloudreve instance
30    pub base_url: String,
31    /// HTTP client for making requests
32    pub http_client: reqwest::Client,
33    /// Authentication token
34    pub token: Option<String>,
35}
36
37impl ApiV4Client {
38    /// Creates a new API v4 client
39    pub fn new(base_url: &str) -> Self {
40        Self {
41            base_url: base_url.to_string(),
42            http_client: reqwest::Client::new(),
43            token: None,
44        }
45    }
46
47    /// Sets the authentication token
48    pub fn set_token(&mut self, token: String) {
49        self.token = Some(token);
50    }
51
52    /// Gets the full URL for an endpoint with /api/v4 prefix
53    fn get_url(&self, endpoint: &str) -> String {
54        format!(
55            "{}/api/v4/{}",
56            self.base_url.trim_end_matches('/'),
57            endpoint.trim_start_matches('/')
58        )
59    }
60
61    /// Makes a GET request to the API
62    pub async fn get<T>(&self, endpoint: &str) -> Result<T, Error>
63    where
64        T: serde::de::DeserializeOwned + std::fmt::Debug,
65    {
66        let url = self.get_url(endpoint);
67        let mut request = self.http_client.get(&url);
68
69        if let Some(token) = &self.token {
70            // request = request.header("Authorization", format!("Bearer {}", token));
71            request = request.bearer_auth(token);
72        }
73        debug!("GET URL: {}", url);
74
75        let response = request.send().await?;
76        let status = response.status();
77
78        // Get raw response text for better error reporting
79        let raw_text = response.text().await?;
80
81        match serde_json::from_str::<T>(&raw_text) {
82            Ok(json) => {
83                debug!("Response status: {}, JSON: {:?}", status, json);
84                Ok(json)
85            }
86            Err(e) => {
87                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
88                Err(Error::Json(e))
89            }
90        }
91    }
92
93    /// Makes a POST request to the API
94    pub async fn post<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
95    where
96        T: serde::de::DeserializeOwned + std::fmt::Debug,
97    {
98        let url = self.get_url(endpoint);
99        let mut request = self.http_client.post(&url).json(body);
100
101        if let Some(token) = &self.token {
102            // request = request.header("Authorization", format!("Bearer {}", token));
103            request = request.bearer_auth(token);
104        }
105
106        debug!("POST URL: {}", url);
107
108        let response = request.send().await?;
109        let status = response.status();
110
111        // Get raw response text for better error reporting
112        let raw_text = response.text().await?;
113
114        match serde_json::from_str::<T>(&raw_text) {
115            Ok(json) => {
116                debug!("Response status: {}, JSON: {:?}", status, json);
117                Ok(json)
118            }
119            Err(e) => {
120                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
121                Err(Error::Json(e))
122            }
123        }
124    }
125
126    /// Makes a PUT request to the API
127    pub async fn put<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
128    where
129        T: serde::de::DeserializeOwned + std::fmt::Debug,
130    {
131        let url = self.get_url(endpoint);
132        let mut request = self.http_client.put(&url).json(body);
133
134        if let Some(token) = &self.token {
135            // request = request.header("Authorization", format!("Bearer {}", token));
136            request = request.bearer_auth(token);
137        }
138        debug!("PUT URL: {}", url);
139
140        let response = request.send().await?;
141        let status = response.status();
142
143        // Get raw response text for better error reporting
144        let raw_text = response.text().await?;
145
146        match serde_json::from_str::<T>(&raw_text) {
147            Ok(json) => {
148                debug!("Response status: {}, JSON: {:?}", status, json);
149                Ok(json)
150            }
151            Err(e) => {
152                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
153                Err(Error::Json(e))
154            }
155        }
156    }
157
158    pub async fn patch<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
159    where
160        T: serde::de::DeserializeOwned + std::fmt::Debug,
161    {
162        let url = self.get_url(endpoint);
163        let mut request = self.http_client.patch(&url).json(body);
164
165        if let Some(token) = &self.token {
166            // request = request.header("Authorization", format!("Bearer {}", token));
167            request = request.bearer_auth(token);
168        }
169        debug!("PATCH URL: {}", url);
170
171        let response = request.send().await?;
172        let status = response.status();
173
174        // Get raw response text for better error reporting
175        let raw_text = response.text().await?;
176
177        match serde_json::from_str::<T>(&raw_text) {
178            Ok(json) => {
179                debug!("Response status: {}, JSON: {:?}", status, json);
180                Ok(json)
181            }
182            Err(e) => {
183                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
184                Err(Error::Json(e))
185            }
186        }
187    }
188
189    /// Makes a DELETE request to the API
190    pub async fn delete<T>(&self, endpoint: &str) -> Result<T, Error>
191    where
192        T: serde::de::DeserializeOwned + std::fmt::Debug,
193    {
194        let url = self.get_url(endpoint);
195        let mut request = self.http_client.delete(&url);
196
197        if let Some(token) = &self.token {
198            // request = request.header("Authorization", format!("Bearer {}", token));
199            request = request.bearer_auth(token);
200        }
201        debug!("DELETE URL: {}", url);
202
203        let response = request.send().await?;
204        let status = response.status();
205
206        // Get raw response text for better error reporting
207        let raw_text = response.text().await?;
208
209        match serde_json::from_str::<T>(&raw_text) {
210            Ok(json) => {
211                debug!("Response status: {}, JSON: {:?}", status, json);
212                Ok(json)
213            }
214            Err(e) => {
215                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
216                Err(Error::Json(e))
217            }
218        }
219    }
220}
cloudreve_api/api/v4/mod.rs

cloudreve_api/api/v4/
mod.rs
