1use crate::error::{ApiError, Result};
4use reqwest::Client;
5use serde_json::Value;
6use url::Url;
7
8pub struct AssetsClient {
10 base_url: String,
11 client: Client,
12}
13
14impl AssetsClient {
15 pub fn new(base_url: String, client: Client) -> Self {
17 Self { base_url, client }
18 }
19
20 pub fn with_auth(self, token: &str) -> Self {
22 self
24 }
25
26 pub async fn get_repo_releases_latest_download_file_name(
28 &self,
29 repo: String,
30 file_name: String,
31 ) -> Result<Value> {
32 let path = format!("/{}/-/releases/latest/download/{}", repo, file_name);
33 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
34
35
36 let request = self.client.request(
37 reqwest::Method::GET,
38 url
39 );
40
41
42
43
44 let response = request.send().await?;
45
46 if response.status().is_success() {
47 let json: Value = response.json().await?;
48 Ok(json)
49 } else {
50 Err(ApiError::HttpError(response.status().as_u16()))
51 }
52 }
53
54 pub async fn post_repo_upload_files(
56 &self,
57 repo: String,
58 request_data: serde_json::Value,
59 ) -> Result<Value> {
60 let path = format!("/{}/-/upload/files", repo);
61 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
62
63
64
65 let mut request = self.client.request(
66 reqwest::Method::POST,
67 url
68 );
69
70
71
72 request = request.json(&request_data);
73
74 let response = request.send().await?;
75
76 if response.status().is_success() {
77 let json: Value = response.json().await?;
78 Ok(json)
79 } else {
80 Err(ApiError::HttpError(response.status().as_u16()))
81 }
82 }
83
84 pub async fn get_repo_releases_download_tag_filename(
86 &self,
87 repo: String,
88 tag: String,
89 filename: String,
90 share: Option<bool>,
91 ) -> Result<Value> {
92 let path = format!("/{}/-/releases/download/{}/{}", repo, tag, filename);
93 let mut url = Url::parse(&format!("{}{}", self.base_url, path))?;
94
95 if let Some(value) = share {
96 url.query_pairs_mut().append_pair("share", &value.to_string());
97 }
98
99 let request = self.client.request(
100 reqwest::Method::GET,
101 url
102 );
103
104
105
106
107 let response = request.send().await?;
108
109 if response.status().is_success() {
110 let json: Value = response.json().await?;
111 Ok(json)
112 } else {
113 Err(ApiError::HttpError(response.status().as_u16()))
114 }
115 }
116
117 pub async fn post_repo_upload_imgs(
119 &self,
120 repo: String,
121 request_data: serde_json::Value,
122 ) -> Result<Value> {
123 let path = format!("/{}/-/upload/imgs", repo);
124 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
125
126
127
128 let mut request = self.client.request(
129 reqwest::Method::POST,
130 url
131 );
132
133
134
135 request = request.json(&request_data);
136
137 let response = request.send().await?;
138
139 if response.status().is_success() {
140 let json: Value = response.json().await?;
141 Ok(json)
142 } else {
143 Err(ApiError::HttpError(response.status().as_u16()))
144 }
145 }
146
147 pub async fn get_repo_commit_assets_download_commit_id_filename(
149 &self,
150 repo: String,
151 commit_id: String,
152 filename: String,
153 share: Option<bool>,
154 ) -> Result<Value> {
155 let path = format!("/{}/-/commit-assets/download/{}/{}", repo, commit_id, filename);
156 let mut url = Url::parse(&format!("{}{}", self.base_url, path))?;
157
158 if let Some(value) = share {
159 url.query_pairs_mut().append_pair("share", &value.to_string());
160 }
161
162 let request = self.client.request(
163 reqwest::Method::GET,
164 url
165 );
166
167
168
169
170 let response = request.send().await?;
171
172 if response.status().is_success() {
173 let json: Value = response.json().await?;
174 Ok(json)
175 } else {
176 Err(ApiError::HttpError(response.status().as_u16()))
177 }
178 }
179
180 pub async fn post_repo_upload_releases_tag_name(
182 &self,
183 repo: String,
184 tag_name: String,
185 request_data: serde_json::Value,
186 ) -> Result<Value> {
187 let path = format!("/{}/-/upload/releases/{}", repo, tag_name);
188 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
189
190
191
192 let mut request = self.client.request(
193 reqwest::Method::POST,
194 url
195 );
196
197
198
199 request = request.json(&request_data);
200
201 let response = request.send().await?;
202
203 if response.status().is_success() {
204 let json: Value = response.json().await?;
205 Ok(json)
206 } else {
207 Err(ApiError::HttpError(response.status().as_u16()))
208 }
209 }
210
211 pub async fn post_group_upload_logos(
213 &self,
214 group: String,
215 request_data: serde_json::Value,
216 ) -> Result<Value> {
217 let path = format!("/{}/-/upload/logos", group);
218 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
219
220
221
222 let mut request = self.client.request(
223 reqwest::Method::POST,
224 url
225 );
226
227
228
229 request = request.json(&request_data);
230
231 let response = request.send().await?;
232
233 if response.status().is_success() {
234 let json: Value = response.json().await?;
235 Ok(json)
236 } else {
237 Err(ApiError::HttpError(response.status().as_u16()))
238 }
239 }
240
241}