Skip to main content

wechat_mp_core/
client.rs

1//! 小程序 HTTP 客户端:自动注入 access_token、统一解析 errcode
2
3use 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/// 小程序异步客户端
15#[derive(Clone)]
16pub struct MpClient {
17    config: Arc<Config>,
18    http: Client,
19    token: Arc<Mutex<Option<AccessToken>>>,
20}
21
22impl MpClient {
23    /// 使用配置创建客户端
24    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    /// 配置引用
39    pub fn config(&self) -> &Config {
40        &self.config
41    }
42
43    /// 底层 HTTP 客户端
44    pub fn http(&self) -> &Client {
45        &self.http
46    }
47
48    /// 获取有效 access_token(带内存缓存)
49    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    /// 强制刷新 access_token
66    pub async fn refresh_access_token(&self) -> Result<String> {
67        *self.token.lock().await = None;
68        self.access_token().await
69    }
70
71    /// GET JSON(自动附加 access_token)
72    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    /// POST JSON(自动附加 access_token)
84    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    /// POST(仅查询参数、无 JSON body),用于 OCR / 图像处理的 `img_url` 模式
96    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    /// POST(仅查询参数、不带 access_token),如 `clear_quota/v2`
108    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    /// POST `multipart/form-data`(可选查询参数、文本字段、文件)
136    ///
137    /// `file`:`(字段名, 文件名, 字节内容)`,常见字段名为 `img`
138    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    /// POST JSON,返回原始字节(小程序码等可能返回图片)
169    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        // 若返回 JSON 错误体则解析抛出
183        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    /// 不带 access_token 的 GET(如 code2session)
202    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
231/// 解析微信 JSON:若含 errcode 且非 0 则转错误
232pub fn parse_wx_json<T: DeserializeOwned>(text: &str) -> Result<T> {
233    // 先窥探 errcode
234    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}