1use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone)]
12pub struct UploadableFile {
13 pub data: Vec<u8>,
15 pub mime_type: String,
17}
18
19impl UploadableFile {
20 pub fn new(data: Vec<u8>, mime_type: impl Into<String>) -> Self {
36 Self {
37 data,
38 mime_type: mime_type.into(),
39 }
40 }
41
42 pub fn size(&self) -> usize {
44 self.data.len()
45 }
46}
47
48#[derive(Debug, Clone)]
50pub struct DownloadResult {
51 pub data: Vec<u8>,
53 pub mime_type: String,
55}
56
57impl DownloadResult {
58 pub fn new(data: Vec<u8>, mime_type: impl Into<String>) -> Self {
60 Self {
61 data,
62 mime_type: mime_type.into(),
63 }
64 }
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct UploadFileResult {
70 #[serde(rename = "uhrpUrl")]
72 pub uhrp_url: String,
73 pub published: bool,
75}
76
77impl UploadFileResult {
78 pub fn new(uhrp_url: impl Into<String>, published: bool) -> Self {
80 Self {
81 uhrp_url: uhrp_url.into(),
82 published,
83 }
84 }
85}
86
87#[derive(Debug, Clone, Serialize, Deserialize)]
89pub struct FindFileData {
90 #[serde(skip_serializing_if = "Option::is_none")]
92 pub name: Option<String>,
93 pub size: String,
95 #[serde(rename = "mimeType")]
97 pub mime_type: String,
98 #[serde(rename = "expiryTime")]
100 pub expiry_time: i64,
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
105pub struct UploadMetadata {
106 #[serde(rename = "uhrpUrl")]
108 pub uhrp_url: String,
109 #[serde(rename = "expiryTime")]
111 pub expiry_time: i64,
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize)]
116pub struct RenewFileResult {
117 pub status: String,
119 #[serde(rename = "prevExpiryTime")]
121 pub previous_expiry: i64,
122 #[serde(rename = "newExpiryTime")]
124 pub new_expiry: i64,
125 pub amount: i64,
127}
128
129impl RenewFileResult {
130 pub fn is_success(&self) -> bool {
132 self.status == "success"
133 }
134}
135
136#[cfg(feature = "http")]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139pub(crate) struct UploadInfo {
140 pub status: String,
142 #[serde(rename = "uploadURL")]
144 pub upload_url: String,
145 #[serde(rename = "requiredHeaders", default)]
147 pub required_headers: std::collections::HashMap<String, String>,
148 #[serde(skip_serializing_if = "Option::is_none")]
150 pub amount: Option<i64>,
151}
152
153#[allow(dead_code)]
155pub(crate) const STATUS_SUCCESS: &str = "success";
156#[allow(dead_code)]
157pub(crate) const STATUS_ERROR: &str = "error";
158
159#[cfg(test)]
160mod tests {
161 use super::*;
162
163 #[test]
164 fn test_uploadable_file_new() {
165 let file = UploadableFile::new(b"content".to_vec(), "text/plain");
166 assert_eq!(file.data, b"content");
167 assert_eq!(file.mime_type, "text/plain");
168 assert_eq!(file.size(), 7);
169 }
170
171 #[test]
172 fn test_download_result_new() {
173 let result = DownloadResult::new(vec![1, 2, 3], "application/octet-stream");
174 assert_eq!(result.data, vec![1, 2, 3]);
175 assert_eq!(result.mime_type, "application/octet-stream");
176 }
177
178 #[test]
179 fn test_upload_file_result_new() {
180 let result = UploadFileResult::new("uhrp://abc123", true);
181 assert_eq!(result.uhrp_url, "uhrp://abc123");
182 assert!(result.published);
183 }
184
185 #[test]
186 fn test_renew_file_result_is_success() {
187 let success = RenewFileResult {
188 status: "success".to_string(),
189 previous_expiry: 1000,
190 new_expiry: 2000,
191 amount: 100,
192 };
193 assert!(success.is_success());
194
195 let failure = RenewFileResult {
196 status: "error".to_string(),
197 previous_expiry: 1000,
198 new_expiry: 1000,
199 amount: 0,
200 };
201 assert!(!failure.is_success());
202 }
203}