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
105        // Get raw response text for better error reporting
106        let raw_text = response.text().await?;
107
108        match serde_json::from_str::<T>(&raw_text) {
109            Ok(json) => {
110                debug!("Response status: {}, JSON: {:?}", status, json);
111                Ok(json)
112            }
113            Err(e) => {
114                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
115                Err(Error::Json(e))
116            }
117        }
118    }
119
120    /// Makes a PUT request to the API
121    pub async fn put<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
122    where
123        T: serde::de::DeserializeOwned + std::fmt::Debug,
124    {
125        let url = self.get_url(endpoint);
126        let mut request = self.http_client.put(&url).json(body);
127
128        if let Some(token) = &self.token {
129            // request = request.header("Authorization", format!("Bearer {}", token));
130            request = request.bearer_auth(token);
131        }
132        debug!("PUT URL: {}", url);
133
134        let response = request.send().await?;
135        let status = response.status();
136
137        // Get raw response text for better error reporting
138        let raw_text = response.text().await?;
139
140        match serde_json::from_str::<T>(&raw_text) {
141            Ok(json) => {
142                debug!("Response status: {}, JSON: {:?}", status, json);
143                Ok(json)
144            }
145            Err(e) => {
146                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
147                Err(Error::Json(e))
148            }
149        }
150    }
151
152    pub async fn patch<T>(&self, endpoint: &str, body: &impl Serialize) -> Result<T, Error>
153    where
154        T: serde::de::DeserializeOwned + std::fmt::Debug,
155    {
156        let url = self.get_url(endpoint);
157        let mut request = self.http_client.patch(&url).json(body);
158
159        if let Some(token) = &self.token {
160            // request = request.header("Authorization", format!("Bearer {}", token));
161            request = request.bearer_auth(token);
162        }
163        debug!("PATCH URL: {}", url);
164
165        let response = request.send().await?;
166        let status = response.status();
167
168        // Get raw response text for better error reporting
169        let raw_text = response.text().await?;
170
171        match serde_json::from_str::<T>(&raw_text) {
172            Ok(json) => {
173                debug!("Response status: {}, JSON: {:?}", status, json);
174                Ok(json)
175            }
176            Err(e) => {
177                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
178                Err(Error::Json(e))
179            }
180        }
181    }
182
183    /// Makes a DELETE request to the API
184    pub async fn delete<T>(&self, endpoint: &str) -> Result<T, Error>
185    where
186        T: serde::de::DeserializeOwned + std::fmt::Debug,
187    {
188        let url = self.get_url(endpoint);
189        let mut request = self.http_client.delete(&url);
190
191        if let Some(token) = &self.token {
192            // request = request.header("Authorization", format!("Bearer {}", token));
193            request = request.bearer_auth(token);
194        }
195        debug!("DELETE URL: {}", url);
196
197        let response = request.send().await?;
198        let status = response.status();
199
200        // Get raw response text for better error reporting
201        let raw_text = response.text().await?;
202
203        match serde_json::from_str::<T>(&raw_text) {
204            Ok(json) => {
205                debug!("Response status: {}, JSON: {:?}", status, json);
206                Ok(json)
207            }
208            Err(e) => {
209                debug!("JSON parse error: {}, raw response: {}", e, raw_text);
210                Err(Error::Json(e))
211            }
212        }
213    }
214}
cloudreve_api/api/v4/mod.rs

cloudreve_api/api/v4/
mod.rs
