1use crate::models::{
2 Account, ApiResponse, Node, Page, PageList, PageViews,
3};
4use reqwest::{blocking::Client, Url};
5use serde_json::json;
6use std::error::Error;
7use crate::models::CreatePageRequest;
8
9
10pub struct TelegraphClient {
11 client: Client,
12}
13
14impl TelegraphClient {
15 pub fn new() -> Self {
16 Self {
17 client: Client::new(),
18 }
19 }
20
21 pub fn create_account(
22 &self,
23 short_name: &str,
24 author_name: Option<&str>,
25 author_url: Option<&str>,
26 ) -> Result<Account, Box<dyn Error>> {
27 let mut url = Url::parse("https://api.telegra.ph/createAccount")?;
28 url.query_pairs_mut().append_pair("short_name", short_name);
29 if let Some(name) = author_name {
30 url.query_pairs_mut().append_pair("author_name", name);
31 }
32 if let Some(url_str) = author_url {
33 url.query_pairs_mut().append_pair("author_url", url_str);
34 }
35
36 let resp = self.client.get(url).send()?;
37 let api_resp: ApiResponse<Account> = resp.json()?;
38
39 if api_resp.ok {
40 Ok(api_resp.result.expect("Missing result"))
41 } else {
42 Err(api_resp
43 .error
44 .unwrap_or_else(|| "Unknown error".to_string())
45 .into())
46 }
47 }
48
49 pub fn create_page(
50 &self,
51 access_token: &str,
52 title: &str,
53 author_name: Option<&str>,
54 author_url: Option<&str>,
55 content: &[Node],
56 return_content: Option<bool>,
57 ) -> Result<Page, Box<dyn Error>> {
58 let req = CreatePageRequest {
59 access_token: Some(access_token),
60 title,
61 author_name,
62 author_url,
63 content,
64 return_content,
65 };
66
67 let resp = self
68 .client
69 .post("https://api.telegra.ph/createPage")
70 .json(&req)
71 .send()?;
72
73 let api_resp: ApiResponse<Page> = resp.json()?;
74
75 if api_resp.ok {
76 Ok(api_resp.result.expect("Missing result"))
77 } else {
78 Err(api_resp
79 .error
80 .unwrap_or_else(|| "Unknown error".to_string())
81 .into())
82 }
83 }
84
85 pub fn edit_account_info(
86 &self,
87 access_token: &str,
88 short_name: Option<&str>,
89 author_name: Option<&str>,
90 author_url: Option<&str>,
91 ) -> Result<Account, Box<dyn Error>> {
92 let mut url = Url::parse("https://api.telegra.ph/editAccountInfo")?;
93 url.query_pairs_mut()
94 .append_pair("access_token", access_token);
95
96 if let Some(name) = short_name {
97 url.query_pairs_mut().append_pair("short_name", name);
98 }
99 if let Some(author) = author_name {
100 url.query_pairs_mut().append_pair("author_name", author);
101 }
102 if let Some(url_str) = author_url {
103 url.query_pairs_mut().append_pair("author_url", url_str);
104 }
105
106 let resp = self.client.get(url).send()?;
107 let api_resp: ApiResponse<Account> = resp.json()?;
108
109 if api_resp.ok {
110 Ok(api_resp.result.expect("Missing result"))
111 } else {
112 Err(api_resp
113 .error
114 .unwrap_or_else(|| "Unknown error".to_string())
115 .into())
116 }
117 }
118
119 pub fn edit_page(
120 &self,
121 access_token: &str,
122 path: &str,
123 title: &str,
124 author_name: Option<&str>,
125 author_url: Option<&str>,
126 content: &[Node],
127 return_content: Option<bool>,
128 ) -> Result<Page, Box<dyn Error>> {
129 let mut url = Url::parse(&format!("https://api.telegra.ph/editPage/{}", path))?;
130 url.query_pairs_mut()
131 .append_pair("access_token", access_token);
132
133 let mut json_body = json!({
134 "title": title,
135 "content": content,
136 });
137 if let Some(name) = author_name {
138 json_body["author_name"] = json!(name);
139 }
140 if let Some(url_str) = author_url {
141 json_body["author_url"] = json!(url_str);
142 }
143 if let Some(ret) = return_content {
144 json_body["return_content"] = json!(ret);
145 }
146
147 let resp = self.client.post(url).json(&json_body).send()?;
148 let api_resp: ApiResponse<Page> = resp.json()?;
149
150 if api_resp.ok {
151 Ok(api_resp.result.expect("Missing result"))
152 } else {
153 Err(api_resp
154 .error
155 .unwrap_or_else(|| "Unknown error".to_string())
156 .into())
157 }
158 }
159
160 pub fn get_account_info(
161 &self,
162 access_token: &str,
163 fields: Option<&[&str]>,
164 ) -> Result<Account, Box<dyn Error>> {
165 let mut url = Url::parse("https://api.telegra.ph/getAccountInfo")?;
166 url.query_pairs_mut()
167 .append_pair("access_token", access_token);
168
169 if let Some(fields_list) = fields {
170 let fields_json = serde_json::to_string(fields_list)?;
171 url.query_pairs_mut().append_pair("fields", &fields_json);
172 }
173
174 let resp = self.client.get(url).send()?;
175 let api_resp: ApiResponse<Account> = resp.json()?;
176
177 if api_resp.ok {
178 Ok(api_resp.result.expect("Missing result"))
179 } else {
180 Err(api_resp
181 .error
182 .unwrap_or_else(|| "Unknown error".to_string())
183 .into())
184 }
185 }
186
187 pub fn get_page(
188 &self,
189 path: &str,
190 return_content: Option<bool>,
191 ) -> Result<Page, Box<dyn Error>> {
192 let mut url = Url::parse(&format!("https://api.telegra.ph/getPage/{}", path))?;
193 if let Some(ret) = return_content {
194 url.query_pairs_mut()
195 .append_pair("return_content", if ret { "true" } else { "false" });
196 }
197
198 let resp = self.client.get(url).send()?;
199 let api_resp: ApiResponse<Page> = resp.json()?;
200
201 if api_resp.ok {
202 Ok(api_resp.result.expect("Missing result"))
203 } else {
204 Err(api_resp
205 .error
206 .unwrap_or_else(|| "Unknown error".to_string())
207 .into())
208 }
209 }
210
211 pub fn get_page_list(
212 &self,
213 access_token: &str,
214 offset: Option<u32>,
215 limit: Option<u32>,
216 ) -> Result<PageList, Box<dyn Error>> {
217 let mut url = Url::parse("https://api.telegra.ph/getPageList")?;
218 url.query_pairs_mut()
219 .append_pair("access_token", access_token);
220 if let Some(o) = offset {
221 url.query_pairs_mut().append_pair("offset", &o.to_string());
222 }
223 if let Some(l) = limit {
224 url.query_pairs_mut().append_pair("limit", &l.to_string());
225 }
226
227 let resp = self.client.get(url).send()?;
228 let api_resp: ApiResponse<PageList> = resp.json()?;
229
230 if api_resp.ok {
231 Ok(api_resp.result.expect("Missing result"))
232 } else {
233 Err(api_resp
234 .error
235 .unwrap_or_else(|| "Unknown error".to_string())
236 .into())
237 }
238 }
239
240 pub fn get_views(
241 &self,
242 path: &str,
243 year: Option<u32>,
244 month: Option<u8>,
245 day: Option<u8>,
246 hour: Option<u8>,
247 ) -> Result<PageViews, Box<dyn Error>> {
248 let mut url = Url::parse(&format!("https://api.telegra.ph/getViews/{}", path))?;
249
250 if let Some(y) = year {
251 url.query_pairs_mut().append_pair("year", &y.to_string());
252 }
253 if let Some(m) = month {
254 url.query_pairs_mut().append_pair("month", &m.to_string());
255 }
256 if let Some(d) = day {
257 url.query_pairs_mut().append_pair("day", &d.to_string());
258 }
259 if let Some(h) = hour {
260 url.query_pairs_mut().append_pair("hour", &h.to_string());
261 }
262
263 let resp = self.client.get(url).send()?;
264 let api_resp: ApiResponse<PageViews> = resp.json()?;
265
266 if api_resp.ok {
267 Ok(api_resp.result.expect("Missing result"))
268 } else {
269 Err(api_resp
270 .error
271 .unwrap_or_else(|| "Unknown error".to_string())
272 .into())
273 }
274 }
275
276 pub fn revoke_access_token(&self, access_token: &str) -> Result<Account, Box<dyn Error>> {
277 let mut url = Url::parse("https://api.telegra.ph/revokeAccessToken")?;
278 url.query_pairs_mut()
279 .append_pair("access_token", access_token);
280
281 let resp = self.client.get(url).send()?;
282 let api_resp: ApiResponse<Account> = resp.json()?;
283
284 if api_resp.ok {
285 Ok(api_resp.result.expect("Missing result"))
286 } else {
287 Err(api_resp
288 .error
289 .unwrap_or_else(|| "Unknown error".to_string())
290 .into())
291 }
292 }
293}