1use crate::config::Config;
4use crate::error::{MpError, Result};
5use crate::token::{fetch_access_token, AccessToken};
6use reqwest::Client;
7use serde::de::DeserializeOwned;
8use serde::Serialize;
9use serde_json::Value;
10use std::sync::Arc;
11use std::time::Duration;
12use tokio::sync::Mutex;
13
14#[derive(Clone)]
16pub struct MpClient {
17 config: Arc<Config>,
18 http: Client,
19 token: Arc<Mutex<Option<AccessToken>>>,
20}
21
22impl MpClient {
23 pub fn new(config: Config) -> Result<Self> {
25 let http = Client::builder()
26 .timeout(Duration::from_secs(30))
27 .user_agent("wechat-mp-rust-sdk/0.1")
28 .build()
29 .map_err(MpError::Http)?;
30
31 Ok(Self {
32 config: Arc::new(config),
33 http,
34 token: Arc::new(Mutex::new(None)),
35 })
36 }
37
38 pub fn config(&self) -> &Config {
40 &self.config
41 }
42
43 pub fn http(&self) -> &Client {
45 &self.http
46 }
47
48 pub async fn access_token(&self) -> Result<String> {
50 {
51 let guard = self.token.lock().await;
52 if let Some(t) = guard.as_ref() {
53 if t.is_valid() {
54 return Ok(t.value.clone());
55 }
56 }
57 }
58
59 let fresh = fetch_access_token(&self.http, &self.config).await?;
60 let value = fresh.value.clone();
61 *self.token.lock().await = Some(fresh);
62 Ok(value)
63 }
64
65 pub async fn refresh_access_token(&self) -> Result<String> {
67 *self.token.lock().await = None;
68 self.access_token().await
69 }
70
71 pub async fn get_json<T: DeserializeOwned>(
73 &self,
74 path: &str,
75 query: &[(&str, String)],
76 ) -> Result<T> {
77 let token = self.access_token().await?;
78 let url = self.build_url(path, &token, query);
79 let text = self.http.get(&url).send().await?.text().await?;
80 parse_wx_json(&text)
81 }
82
83 pub async fn post_json<B: Serialize, T: DeserializeOwned>(
85 &self,
86 path: &str,
87 body: &B,
88 ) -> Result<T> {
89 let token = self.access_token().await?;
90 let url = self.build_url(path, &token, &[]);
91 let text = self.http.post(&url).json(body).send().await?.text().await?;
92 parse_wx_json(&text)
93 }
94
95 pub async fn post_query<T: DeserializeOwned>(
97 &self,
98 path: &str,
99 query: &[(&str, String)],
100 ) -> Result<T> {
101 let token = self.access_token().await?;
102 let url = self.build_url(path, &token, query);
103 let text = self.http.post(&url).send().await?.text().await?;
104 parse_wx_json(&text)
105 }
106
107 pub async fn post_query_no_token<T: DeserializeOwned>(
109 &self,
110 path: &str,
111 query: &[(&str, String)],
112 ) -> Result<T> {
113 let base = self.config.base_url.trim_end_matches('/');
114 let path = if path.starts_with('/') {
115 path.to_string()
116 } else {
117 format!("/{path}")
118 };
119 let mut url = format!("{base}{path}");
120 if !query.is_empty() {
121 url.push('?');
122 for (i, (k, v)) in query.iter().enumerate() {
123 if i > 0 {
124 url.push('&');
125 }
126 url.push_str(k);
127 url.push('=');
128 url.push_str(&encode_query(v));
129 }
130 }
131 let text = self.http.post(&url).send().await?.text().await?;
132 parse_wx_json(&text)
133 }
134
135 pub async fn post_multipart<T: DeserializeOwned>(
139 &self,
140 path: &str,
141 query: &[(&str, String)],
142 fields: &[(&str, String)],
143 file: Option<(&str, &str, Vec<u8>)>,
144 ) -> Result<T> {
145 let token = self.access_token().await?;
146 let url = self.build_url(path, &token, query);
147
148 let mut form = reqwest::multipart::Form::new();
149 for (k, v) in fields {
150 form = form.text((*k).to_string(), v.clone());
151 }
152 if let Some((field, filename, bytes)) = file {
153 let part = reqwest::multipart::Part::bytes(bytes).file_name(filename.to_string());
154 form = form.part(field.to_string(), part);
155 }
156
157 let text = self
158 .http
159 .post(&url)
160 .multipart(form)
161 .send()
162 .await?
163 .text()
164 .await?;
165 parse_wx_json(&text)
166 }
167
168 pub async fn post_bytes<B: Serialize>(&self, path: &str, body: &B) -> Result<Vec<u8>> {
170 let token = self.access_token().await?;
171 let url = self.build_url(path, &token, &[]);
172 let bytes = self
173 .http
174 .post(&url)
175 .json(body)
176 .send()
177 .await?
178 .bytes()
179 .await?
180 .to_vec();
181
182 if bytes.first() == Some(&b'{') {
184 if let Ok(v) = serde_json::from_slice::<Value>(&bytes) {
185 if let Some(code) = v.get("errcode").and_then(|c| c.as_i64()) {
186 if code != 0 {
187 let message = v
188 .get("errmsg")
189 .and_then(|m| m.as_str())
190 .unwrap_or("")
191 .to_string();
192 return Err(MpError::Api { code, message });
193 }
194 }
195 }
196 }
197
198 Ok(bytes)
199 }
200
201 pub async fn get_json_no_token<T: DeserializeOwned>(&self, path_with_query: &str) -> Result<T> {
203 let url = format!(
204 "{}{}",
205 self.config.base_url.trim_end_matches('/'),
206 path_with_query
207 );
208 let text = self.http.get(&url).send().await?.text().await?;
209 parse_wx_json(&text)
210 }
211
212 fn build_url(&self, path: &str, token: &str, query: &[(&str, String)]) -> String {
213 let base = self.config.base_url.trim_end_matches('/');
214 let path = if path.starts_with('/') {
215 path.to_string()
216 } else {
217 format!("/{path}")
218 };
219
220 let mut url = format!("{base}{path}?access_token={token}");
221 for (k, v) in query {
222 url.push('&');
223 url.push_str(k);
224 url.push('=');
225 url.push_str(&encode_query(v));
226 }
227 url
228 }
229}
230
231pub fn parse_wx_json<T: DeserializeOwned>(text: &str) -> Result<T> {
233 if let Ok(v) = serde_json::from_str::<Value>(text) {
235 if let Some(code) = v.get("errcode").and_then(|c| c.as_i64()) {
236 if code != 0 {
237 let message = v
238 .get("errmsg")
239 .and_then(|m| m.as_str())
240 .unwrap_or("")
241 .to_string();
242 return Err(MpError::Api { code, message });
243 }
244 }
245 }
246 Ok(serde_json::from_str(text)?)
247}
248
249fn encode_query(s: &str) -> String {
250 s.chars()
251 .map(|c| match c {
252 'A'..='Z' | 'a'..='z' | '0'..='9' | '-' | '_' | '.' | '~' => c.to_string(),
253 _ => {
254 let mut buf = [0u8; 4];
255 let encoded = c.encode_utf8(&mut buf);
256 encoded
257 .as_bytes()
258 .iter()
259 .map(|b| format!("%{b:02X}"))
260 .collect::<String>()
261 }
262 })
263 .collect()
264}