1use crate::client::GeweHttpClient;
2use gewe_core::{
3 DownloadCdnRequest, DownloadCdnResponse, DownloadEmojiRequest, DownloadEmojiResponse,
4 DownloadFileRequest, DownloadFileResponse, DownloadImageRequest, DownloadImageResponse,
5 DownloadVideoRequest, DownloadVideoResponse, DownloadVoiceRequest, DownloadVoiceResponse,
6 GeweError,
7};
8use tracing::instrument;
9
10impl GeweHttpClient {
11 #[instrument(skip(self))]
12 pub async fn download_image(
13 &self,
14 app_id: &str,
15 xml: &str,
16 image_type: i32,
17 ) -> Result<DownloadImageResponse, GeweError> {
18 let body = DownloadImageRequest {
19 app_id,
20 xml,
21 image_type,
22 };
23 let env = self
24 .post_api::<_, DownloadImageResponse>("gewe/v2/api/message/downloadImage", &body)
25 .await?;
26 env.data.ok_or(GeweError::MissingData)
27 }
28
29 #[instrument(skip(self))]
30 pub async fn download_video(
31 &self,
32 app_id: &str,
33 xml: &str,
34 ) -> Result<DownloadVideoResponse, GeweError> {
35 let body = DownloadVideoRequest { app_id, xml };
36 let env = self
37 .post_api::<_, DownloadVideoResponse>("gewe/v2/api/message/downloadVideo", &body)
38 .await?;
39 env.data.ok_or(GeweError::MissingData)
40 }
41
42 #[instrument(skip(self))]
43 pub async fn download_file(
44 &self,
45 app_id: &str,
46 xml: &str,
47 ) -> Result<DownloadFileResponse, GeweError> {
48 let body = DownloadFileRequest { app_id, xml };
49 let env = self
50 .post_api::<_, DownloadFileResponse>("gewe/v2/api/message/downloadFile", &body)
51 .await?;
52 env.data.ok_or(GeweError::MissingData)
53 }
54
55 #[instrument(skip(self))]
56 pub async fn download_voice(
57 &self,
58 app_id: &str,
59 xml: &str,
60 msg_id: i64,
61 ) -> Result<DownloadVoiceResponse, GeweError> {
62 let body = DownloadVoiceRequest {
63 app_id,
64 xml,
65 msg_id,
66 };
67 let env = self
68 .post_api::<_, DownloadVoiceResponse>("gewe/v2/api/message/downloadVoice", &body)
69 .await?;
70 env.data.ok_or(GeweError::MissingData)
71 }
72
73 #[instrument(skip(self))]
74 pub async fn download_emoji(
75 &self,
76 app_id: &str,
77 emoji_md5: &str,
78 ) -> Result<DownloadEmojiResponse, GeweError> {
79 let body = DownloadEmojiRequest { app_id, emoji_md5 };
80 let env = self
81 .post_api::<_, DownloadEmojiResponse>("gewe/v2/api/message/downloadEmojiMd5", &body)
82 .await?;
83 env.data.ok_or(GeweError::MissingData)
84 }
85
86 #[instrument(skip(self))]
87 pub async fn download_cdn(
88 &self,
89 app_id: &str,
90 aes_key: &str,
91 file_id: &str,
92 file_type: &str,
93 total_size: &str,
94 suffix: &str,
95 ) -> Result<DownloadCdnResponse, GeweError> {
96 let body = DownloadCdnRequest {
97 app_id,
98 aes_key,
99 file_id,
100 r#type: file_type,
101 total_size,
102 suffix,
103 };
104 let env = self
105 .post_api::<_, DownloadCdnResponse>("gewe/v2/api/message/downloadCdn", &body)
106 .await?;
107 env.data.ok_or(GeweError::MissingData)
108 }
109}
110
111#[cfg(test)]
112mod tests {
113 use super::*;
114
115 #[test]
116 fn test_download_image_request_serialization() {
117 let req = DownloadImageRequest {
118 app_id: "test_app",
119 xml: "<xml>image data</xml>",
120 image_type: 1,
121 };
122 let json = serde_json::to_string(&req).expect("Failed to serialize");
123 assert!(json.contains("appId"));
124 assert!(json.contains("<xml>image data</xml>"));
125 assert!(json.contains("\"type\":"));
126 }
127
128 #[test]
129 fn test_download_video_request_serialization() {
130 let req = DownloadVideoRequest {
131 app_id: "test_app",
132 xml: "<xml>video data</xml>",
133 };
134 let json = serde_json::to_string(&req).expect("Failed to serialize");
135 assert!(json.contains("appId"));
136 assert!(json.contains("<xml>video data</xml>"));
137 }
138
139 #[test]
140 fn test_download_file_request_serialization() {
141 let req = DownloadFileRequest {
142 app_id: "test_app",
143 xml: "<xml>file data</xml>",
144 };
145 let json = serde_json::to_string(&req).expect("Failed to serialize");
146 assert!(json.contains("appId"));
147 assert!(json.contains("<xml>file data</xml>"));
148 }
149
150 #[test]
151 fn test_download_voice_request_serialization() {
152 let req = DownloadVoiceRequest {
153 app_id: "test_app",
154 xml: "<xml>voice data</xml>",
155 msg_id: 123456789,
156 };
157 let json = serde_json::to_string(&req).expect("Failed to serialize");
158 assert!(json.contains("appId"));
159 assert!(json.contains("msgId"));
160 assert!(json.contains("123456789"));
161 }
162
163 #[test]
164 fn test_download_emoji_request_serialization() {
165 let req = DownloadEmojiRequest {
166 app_id: "test_app",
167 emoji_md5: "abc123def456",
168 };
169 let json = serde_json::to_string(&req).expect("Failed to serialize");
170 assert!(json.contains("appId"));
171 assert!(json.contains("emojiMd5"));
172 assert!(json.contains("abc123def456"));
173 }
174
175 #[test]
176 fn test_download_cdn_request_serialization() {
177 let req = DownloadCdnRequest {
178 app_id: "test_app",
179 aes_key: "aes_key_value",
180 file_id: "file_id_123",
181 r#type: "image",
182 total_size: "102400",
183 suffix: "jpg",
184 };
185 let json = serde_json::to_string(&req).expect("Failed to serialize");
186 assert!(json.contains("appId"));
187 assert!(json.contains("aesKey"));
188 assert!(json.contains("fileId"));
189 assert!(json.contains("type"));
190 assert!(json.contains("totalSize"));
191 assert!(json.contains("suffix"));
192 }
193}