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_download_tag_filename(
28 &self,
29 repo: String,
30 tag: String,
31 filename: String,
32 share: Option<bool>,
33 ) -> Result<Value> {
34 let path = format!("/{}/-/releases/download/{}/{}", repo, tag, filename);
35 let mut url = Url::parse(&format!("{}{}", self.base_url, path))?;
36
37 if let Some(value) = share {
38 url.query_pairs_mut().append_pair("share", &value.to_string());
39 }
40
41 let request = self.client.request(
42 reqwest::Method::GET,
43 url
44 );
45
46
47
48
49 let response = request.send().await?;
50
51 if response.status().is_success() {
52 let json: Value = response.json().await?;
53 Ok(json)
54 } else {
55 Err(ApiError::HttpError(response.status().as_u16()))
56 }
57 }
58
59 pub async fn post_repo_upload_imgs(
61 &self,
62 repo: String,
63 request_data: serde_json::Value,
64 ) -> Result<Value> {
65 let path = format!("/{}/-/upload/imgs", repo);
66 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
67
68
69
70 let mut request = self.client.request(
71 reqwest::Method::POST,
72 url
73 );
74
75
76
77 request = request.json(&request_data);
78
79 let response = request.send().await?;
80
81 if response.status().is_success() {
82 let json: Value = response.json().await?;
83 Ok(json)
84 } else {
85 Err(ApiError::HttpError(response.status().as_u16()))
86 }
87 }
88
89 pub async fn get_repo_releases_latest_download_file_name(
91 &self,
92 repo: String,
93 file_name: String,
94 ) -> Result<Value> {
95 let path = format!("/{}/-/releases/latest/download/{}", repo, file_name);
96 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
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_group_upload_logos(
119 &self,
120 group: String,
121 request_data: serde_json::Value,
122 ) -> Result<Value> {
123 let path = format!("/{}/-/upload/logos", group);
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 post_repo_upload_files(
149 &self,
150 repo: String,
151 request_data: serde_json::Value,
152 ) -> Result<Value> {
153 let path = format!("/{}/-/upload/files", repo);
154 let url = Url::parse(&format!("{}{}", self.base_url, path))?;
155
156
157
158 let mut request = self.client.request(
159 reqwest::Method::POST,
160 url
161 );
162
163
164
165 request = request.json(&request_data);
166
167 let response = request.send().await?;
168
169 if response.status().is_success() {
170 let json: Value = response.json().await?;
171 Ok(json)
172 } else {
173 Err(ApiError::HttpError(response.status().as_u16()))
174 }
175 }
176
177 pub async fn get_repo_commit_assets_download_commit_id_filename(
179 &self,
180 repo: String,
181 commit_id: String,
182 filename: String,
183 share: Option<bool>,
184 ) -> Result<Value> {
185 let path = format!("/{}/-/commit-assets/download/{}/{}", repo, commit_id, filename);
186 let mut url = Url::parse(&format!("{}{}", self.base_url, path))?;
187
188 if let Some(value) = share {
189 url.query_pairs_mut().append_pair("share", &value.to_string());
190 }
191
192 let request = self.client.request(
193 reqwest::Method::GET,
194 url
195 );
196
197
198
199
200 let response = request.send().await?;
201
202 if response.status().is_success() {
203 let json: Value = response.json().await?;
204 Ok(json)
205 } else {
206 Err(ApiError::HttpError(response.status().as_u16()))
207 }
208 }
209
210 pub async fn post_repo_upload_releases_tag_name(
212 &self,
213 repo: String,
214 tag_name: String,
215 request_data: serde_json::Value,
216 ) -> Result<Value> {
217 let path = format!("/{}/-/upload/releases/{}", repo, tag_name);
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}