br_pay/
alipay.rs

1use br_reqwest::Client;
2use std::collections::{HashMap};
3use base64::{Engine};
4use base64::engine::general_purpose::STANDARD;
5use chrono::{Local};
6use crate::{PayMode, PayNotify, RefundNotify, RefundStatus, TradeState, TradeType, Types};
7use json::{array, object, JsonValue};
8use openssl::hash::MessageDigest;
9use openssl::pkey::{PKey};
10use openssl::rsa::Rsa;
11use openssl::sign::{Signer, Verifier};
12use urlencoding::{decode, encode};
13use log::error;
14
15#[derive(Clone, Debug)]
16pub struct AliPay {
17    /// 应用appid
18    pub appid: String,
19    /// 服务商商家号
20    pub sp_mchid: String,
21    /// 授权token
22    pub app_auth_token: String,
23    /// 应用私钥证书路径
24    pub app_private: String,
25    /// 接口内容加密密钥
26    pub content_encryp: String,
27    /// 支付宝公钥
28    pub alipay_public_key: String,
29    pub notify_url: String,
30}
31impl AliPay {
32    pub fn sign(&mut self, txt: &str) -> Result<JsonValue, String> {
33        let t = self.app_private.as_bytes().chunks(64).map(|chunk| std::str::from_utf8(chunk).unwrap_or("")).collect::<Vec<&str>>().join("\n");
34        let cart = format!("-----BEGIN PRIVATE KEY-----\n{t}\n-----END PRIVATE KEY-----\n");
35
36        // 1. 加载私钥
37        let rsa = match Rsa::private_key_from_pem(cart.as_bytes()) {
38            Ok(e) => e,
39            Err(e) => return Err(e.to_string())
40        };
41
42        let pkey = match PKey::from_rsa(rsa) {
43            Ok(e) => e,
44            Err(e) => return Err(e.to_string())
45        };
46
47        // 2. 创建签名器，使用 SHA256
48        let mut signer = match Signer::new(MessageDigest::sha256(), &pkey) {
49            Ok(e) => e,
50            Err(e) => return Err(e.to_string())
51        };
52        match signer.update(txt.as_bytes()) {
53            Ok(()) => {}
54            Err(e) => return Err(e.to_string())
55        };
56        // 3. 生成签名
57        let signature = match signer.sign_to_vec() {
58            Ok(e) => e,
59            Err(e) => return Err(e.to_string())
60        };
61        // 4. Base64 编码输出
62        Ok(STANDARD.encode(signature).into())
63    }
64    pub fn http(&mut self, method: &str, biz_content: JsonValue) -> Result<JsonValue, String> {
65        let mut http = Client::new();
66        //http.debug();
67        let sign = "";
68
69        let now = Local::now();
70        let timestamp = now.format("%Y-%m-%d %H:%M:%S").to_string();
71
72        let mut data = object! {
73                    "charset":"UTF-8",
74                    "method":method,
75                    "app_id":self.appid.clone(),
76                    "app_private_key":self.app_private.clone(),
77                    "version":"1.0",
78                    "sign_type":"RSA2",
79                    "timestamp":timestamp,
80                    "alipay_public_key":self.alipay_public_key.clone(),
81                    "sign":sign
82        };
83        if !self.app_auth_token.is_empty() {
84            data["app_auth_token"] = self.app_auth_token.clone().into();
85        }
86        if method.contains("alipay.trade.") {
87            data["notify_url"] = self.notify_url.clone().into();
88        }
89        for (key, value) in biz_content.entries() {
90            data[key] = value.clone()
91        }
92        let mut map = HashMap::new();
93        for (key, value) in data.entries() {
94            if key == "sign" {
95                continue;
96            }
97            if value.is_empty() {
98                continue;
99            }
100            map.insert(key, value);
101        }
102
103        let mut keys: Vec<_> = map.keys().cloned().collect();
104        keys.sort();
105        let mut txt = vec![];
106        for key in keys {
107            txt.push(format!("{}={}", key, map.get(&key).unwrap()));
108        }
109        let txt = txt.join("&");
110        data["sign"] = self.sign(&txt)?;
111
112        let mut new_data = object! {};
113        for (key, value) in data.entries() {
114            let t = encode(value.to_string().as_str()).to_string();
115            new_data[key] = t.into();
116        }
117        data = new_data;
118        let url = "https://openapi.alipay.com/gateway.do".to_string();
119        let res = match method {
120            "alipay.trade.wap.pay" => {
121                let tt = http.get(url.as_str()).query(data);
122                return Ok(tt.url.clone().into());
123            }
124            _ => {
125                match http.get(&url).query(data).form_data(biz_content).send() {
126                    Ok(e) => e,
127                    Err(e) => return Err(e.to_string())
128                }
129            }
130        };
131
132        let res = res.json()?;
133        if res.has_key("error_response") {
134            return Err(res["error_response"]["sub_msg"].to_string());
135        }
136        let key = method.replace(".", "_");
137        let key = format!("{key}_response");
138        let data = res[key].clone();
139        if data.has_key("code") {
140            if data["code"] != "10000" {
141                Err(data["sub_msg"].to_string())
142            } else {
143                Ok(data)
144            }
145        } else {
146            Err(data.to_string())
147        }
148    }
149    pub fn https(&mut self, method: &str, biz_content: JsonValue) -> Result<JsonValue, String> {
150        let mut http = Client::new();
151        //http.debug();
152        let sign = "";
153
154        let now = Local::now();
155        let timestamp = now.format("%Y-%m-%d %H:%M:%S").to_string();
156
157        let mut data = object! {
158                    "charset":"UTF-8",
159                    "method":method,
160                    "app_id":self.appid.clone(),
161                    "app_private_key":self.app_private.clone(),
162                    "version":"1.0",
163                    "sign_type":"RSA2",
164                    "timestamp":timestamp,
165                    "alipay_public_key":self.alipay_public_key.clone(),
166                    "sign":sign
167        };
168        if !self.app_auth_token.is_empty() {
169            data["app_auth_token"] = self.app_auth_token.clone().into();
170        }
171        if method.contains("alipay.trade.") {
172            data["notify_url"] = self.notify_url.clone().into();
173        }
174        for (key, value) in biz_content.entries() {
175            data[key] = value.clone()
176        }
177        let mut map = HashMap::new();
178        for (key, value) in data.entries() {
179            if key == "sign" {
180                continue;
181            }
182            if value.is_empty() {
183                continue;
184            }
185            map.insert(key, value);
186        }
187
188        let mut keys: Vec<_> = map.keys().cloned().collect();
189        keys.sort();
190        let mut txt = vec![];
191        for key in keys {
192            txt.push(format!("{}={}", key, map.get(&key).unwrap()));
193        }
194        let txt = txt.join("&");
195        data["sign"] = self.sign(&txt)?;
196
197        let mut new_data = object! {};
198        for (key, value) in data.entries() {
199            let t = encode(value.to_string().as_str()).to_string();
200            new_data[key] = t.into();
201        }
202        data = new_data;
203        let url = "https://openapi.alipay.com/gateway.do".to_string();
204        let res = match method {
205            "alipay.trade.wap.pay" => {
206                let tt = http.get(url.as_str()).query(data);
207                return Ok(tt.url.clone().into());
208            }
209            _ => {
210                match http.get(&url).query(data).form_data(biz_content).send() {
211                    Ok(e) => e,
212                    Err(e) => return Err(e.to_string())
213                }
214            }
215        };
216
217        let res = res.json()?;
218        if res.has_key("error_response") {
219            return Err(res["error_response"]["sub_msg"].to_string());
220        }
221        let key = method.replace(".", "_");
222        let key = format!("{key}_response");
223        let data = res[key].clone();
224        Ok(data)
225    }
226}
227impl PayMode for AliPay {
228    fn check(&mut self) -> Result<bool, String> {
229        let biz_content = object! {
230            "biz_content":{
231                "grant_type":"authorization_code",
232                "code":"123"
233            }
234        };
235        match self.http("alipay.open.auth.token.app", biz_content) {
236            Ok(e) => e,
237            Err(e) => {
238                if e.contains("auth_code不存在") {
239                    return Ok(true);
240                }
241                return Err(e);
242            }
243        };
244        Ok(true)
245    }
246
247    fn get_sub_mchid(&mut self, sub_mchid: &str) -> Result<JsonValue, String> {
248        let res = self.https("alipay.open.agent.signstatus.query", object! {
249            "biz_content":{
250                "pid":sub_mchid,
251                "product_codes":array!["QUICK_WAP_WAY"]
252            }
253        })?;
254        if !res["code"].eq("10000") {
255            return Err(res["msg"].to_string());
256        }
257        for item in res["sign_status_list"].members() {
258            if item["status"].eq("none") {
259                return Err(format!("{} 未开通", res["product_name"]));
260            }
261        }
262        Ok(true.into())
263    }
264
265    fn notify(&mut self, data: JsonValue) -> Result<JsonValue, String> {
266        let sign = match STANDARD.decode(data["sign"].to_string()) {
267            Ok(e) => e,
268            Err(e) => return Err(format!("decode sign: {e}"))
269        };
270        let mut map = HashMap::new();
271        for (key, value) in data.entries() {
272            if key == "sign" {
273                continue;
274            }
275            if value.is_empty() {
276                continue;
277            }
278            map.insert(key, value);
279        }
280
281        let mut keys: Vec<_> = map.keys().cloned().collect();
282        keys.sort();
283
284        let mut txt = vec![];
285        for key in keys {
286            let value = decode(map.get(&key).unwrap().to_string().as_str()).unwrap().to_string();
287            txt.push(format!("{key}={value}"));
288        }
289        let txt = txt.join("&");
290
291        let public_key_pem = self.alipay_public_key.clone();
292        let public_key_pem = format!("-----BEGIN PUBLIC KEY-----\n{public_key_pem}\n-----END PUBLIC KEY-----\n");
293        let public_key = match PKey::public_key_from_pem(public_key_pem.as_bytes()) {
294            Ok(e) => e,
295            Err(e) => return Err(format!("Invalid public key: {e}"))
296        };
297
298        // 4. 验签
299        let mut verifier = match Verifier::new(MessageDigest::sha256(), &public_key) {
300            Ok(e) => e,
301            Err(e) => return Err(format!("Invalid verifier: {e}"))
302        };
303        match verifier.update(txt.as_bytes()) {
304            Ok(_) => {}
305            Err(_) => return Err("Invalid transaction signature".to_string())
306        };
307
308        let result = match verifier.verify(&sign) {
309            Ok(e) => e,
310            Err(_) => return Err("Invalid transaction signature".to_string())
311        };
312        if !result {
313            return Err("sign error".to_string());
314        }
315        if data.has_key("service") {
316            let service = data["service"].to_string();
317            if service.as_str() == "alipay.service.check" {
318                let sign_txt = "<success>true</success>";
319                let sign = self.sign(sign_txt)?;
320                let text = format!(r#"<?xml version="1.0" encoding="GBK"?><alipay><response><success>true</success></response><sign>{sign}</sign><sign_type>RSA2</sign_type></alipay>"#);
321                return Ok(JsonValue::String(text));
322            }
323        }
324        Ok(result.into())
325    }
326
327    fn config(&mut self) -> JsonValue {
328        todo!()
329    }
330
331    fn login(&mut self, code: &str) -> Result<JsonValue, String> {
332        let res = self.https("alipay.system.oauth.token", object! {
333            "grant_type":"authorization_code",
334            "code":code
335        })?;
336        Ok(res)
337    }
338
339    fn auth(&mut self, code: &str) -> Result<JsonValue, String> {
340        let biz_content = object! {
341            "biz_content":{
342                "grant_type":"authorization_code",
343                "code":code
344            }
345        };
346        let res = match self.http("alipay.open.auth.token.app", biz_content) {
347            Ok(e) => e,
348            Err(e) => {
349                error!("Err: {e:#}");
350                return Err(e);
351            }
352        };
353
354        let data = object! {
355            data:res.clone(),
356            user_id : res["user_id"].clone(),
357            auth_app_id : res["auth_app_id"].clone(),
358            re_expires_in :res["re_expires_in"].clone(),
359            app_auth_token:res["app_auth_token"].clone(),
360            app_refresh_token:res["app_refresh_token"].clone()
361        };
362        Ok(data)
363    }
364
365    fn pay(&mut self, _channel: &str, types: Types, sub_mchid: &str, out_trade_no: &str, description: &str, total_fee: f64, sp_openid: &str) -> Result<JsonValue, String> {
366        let mut api = "";
367        let mut order = object! {
368            out_trade_no:out_trade_no,
369            total_amount:total_fee,
370            subject:description,
371            product_code:"JSAPI_PAY",
372            op_app_id:sub_mchid,
373            buyer_open_id:sp_openid
374        };
375
376        match types {
377            Types::MiniJsapi => {
378                api = "alipay.trade.create";
379                order["product_code"] = "JSAPI_PAY".into();
380                order["op_app_id"] = self.appid.clone().into();
381                order["buyer_open_id"] = sp_openid.into();
382                self.app_auth_token = "".to_string();
383            }
384            Types::Jsapi => {
385                api = "alipay.trade.create";
386                order["product_code"] = "JSAPI_PAY".into();
387            }
388            Types::H5 => {
389                api = "alipay.trade.wap.pay";
390                order["product_code"] = "QUICK_WAP_WAY".into();
391            }
392            Types::Native => {
393                api = "alipay.trade.wap.pay";
394                order["product_code"] = "QUICK_WAP_WAY".into();
395            }
396            _ => {
397                order["product_code"] = "JSAPI_PAY".into();
398            }
399        };
400        match self.http(api, object! {"biz_content":order}) {
401            Ok(e) => {
402                match types {
403                    Types::Jsapi => {}
404                    Types::Native => {}
405                    Types::H5 => {
406                        return Ok(object! {url:e});
407                    }
408                    Types::MiniJsapi => {
409                        println!("alipay.trade.wap.pay:{e:#}");
410                        return Ok(e);
411                    }
412                    Types::App => {}
413                    Types::Micropay => {}
414                }
415                Ok(e)
416            }
417            Err(e) => {
418                println!("Err: {e:#}");
419                Err(e)
420            }
421        }
422    }
423
424    fn micropay(&mut self, _channel: &str, auth_code: &str, sub_mchid: &str, out_trade_no: &str, description: &str, total_fee: f64, org_openid: &str, _ip: &str) -> Result<JsonValue, String> {
425        let order = object! {
426            out_trade_no:out_trade_no,
427            total_amount:total_fee,
428            subject:description,
429            seller_id:sub_mchid,
430            auth_code:auth_code,
431            scene:"bar_code",
432            operator_id:org_openid,
433        };
434
435        match self.http("alipay.trade.create", object! {"biz_content":order}) {
436            Ok(e) => {
437                Ok(e)
438            }
439            Err(e) => {
440                println!("Err: {e:#}");
441                Err(e)
442            }
443        }
444    }
445
446
447    fn close(&mut self, out_trade_no: &str, sub_mchid: &str) -> Result<JsonValue, String> {
448        let order = object! {
449              "biz_content"=> object! {
450                out_trade_no:out_trade_no,
451                operator_id:sub_mchid
452              }
453        };
454        match self.http("alipay.trade.close", order) {
455            Ok(_) => {
456                Ok(true.into())
457            }
458            Err(e) => {
459                if e.contains("交易不存在") {
460                    return Ok(true.into());
461                }
462                Err(e)
463            }
464        }
465    }
466
467    fn pay_query(&mut self, out_trade_no: &str, sub_mchid: &str) -> Result<JsonValue, String> {
468        let order = object! {
469              "biz_content"=> object! {
470               out_trade_no:out_trade_no
471              }
472        };
473        match self.http("alipay.trade.query", order) {
474            Ok(e) => {
475                if e.has_key("code") && e["code"].as_str().unwrap() != "10000" {
476                    return Err(e["msg"].to_string());
477                }
478                let buyer_open_id = if e.has_key("buyer_open_id") {
479                    e["buyer_open_id"].to_string()
480                } else {
481                    e["buyer_user_id"].to_string()
482                };
483                let res = PayNotify {
484                    trade_type: TradeType::None,
485                    out_trade_no: e["out_trade_no"].to_string(),
486                    sp_mchid: "".to_string(),
487                    sub_mchid: sub_mchid.to_string(),
488                    sp_appid: "".to_string(),
489                    transaction_id: e["trade_no"].to_string(),
490                    success_time: PayNotify::alipay_time(e["send_pay_date"].as_str().unwrap()),
491                    sp_openid: buyer_open_id.clone(),
492                    sub_openid: buyer_open_id.clone(),
493                    total: (e["total_amount"].to_string().parse::<f64>().unwrap_or(0.0)),
494                    payer_total: (e["total_amount"].to_string().parse::<f64>().unwrap_or(0.0)),
495                    currency: "CNY".to_string(),
496                    payer_currency: "CNY".to_string(),
497                    trade_state: TradeState::from(e["trade_status"].as_str().unwrap()),
498                };
499                Ok(res.json())
500            }
501            Err(e) => Err(e)
502        }
503    }
504
505    fn pay_micropay_query(&mut self, _out_trade_no: &str, _sub_mchid: &str) -> Result<JsonValue, String> {
506        todo!()
507    }
508
509    fn pay_notify(&mut self, _nonce: &str, _ciphertext: &str, _associated_data: &str) -> Result<JsonValue, String> {
510        todo!()
511    }
512
513    fn refund(&mut self, sub_mchid: &str, out_trade_no: &str, transaction_id: &str, out_refund_no: &str, amount: f64, total: f64, _currency: &str) -> Result<JsonValue, String> {
514        let body = object! {
515            "biz_content"=> object! {
516                "trade_no"=>transaction_id,
517                "out_trade_no"=>out_trade_no,
518                "out_request_no"=>out_refund_no,
519                "refund_amount"=>format!("{:.2}",amount),
520            }
521        };
522        match self.http("alipay.trade.refund", body.clone()) {
523            Ok(e) => {
524                if e.has_key("code") && e["code"].as_str().unwrap() != "10000" {
525                    return Err(e["msg"].to_string());
526                }
527                let res = RefundNotify {
528                    out_trade_no: e["out_trade_no"].to_string(),
529                    refund_no: out_refund_no.to_string(),
530                    sp_mchid: "".to_string(),
531                    sub_mchid: sub_mchid.to_string(),
532                    transaction_id: e["trade_no"].to_string(),
533                    refund_id: out_refund_no.to_string(),
534                    success_time: PayNotify::alipay_time(e["gmt_refund_pay"].as_str().unwrap()),
535                    total,
536                    refund: e["refund_fee"].to_string().parse::<f64>().unwrap(),
537                    payer_total: e["refund_fee"].to_string().parse::<f64>().unwrap(),
538                    payer_refund: e["send_back_fee"].to_string().parse::<f64>().unwrap(),
539                    status: RefundStatus::from(e["fund_change"].as_str().unwrap()),
540                };
541                Ok(res.json())
542            }
543            Err(e) => Err(e)
544        }
545    }
546
547    fn micropay_refund(&mut self, _sub_mchid: &str, _out_trade_no: &str, _transaction_id: &str, _out_refund_no: &str, _amount: f64, _total: f64, _currency: &str, _refund_text: &str) -> Result<JsonValue, String> {
548        todo!()
549    }
550
551    fn refund_notify(&mut self, _nonce: &str, _ciphertext: &str, _associated_data: &str) -> Result<JsonValue, String> {
552        todo!()
553    }
554
555    fn refund_query(&mut self, trade_no: &str, out_refund_no: &str, sub_mchid: &str) -> Result<JsonValue, String> {
556        let body = object! {
557             "biz_content"=> object! {
558               "out_request_no"=>out_refund_no,
559            "trade_no"=>trade_no,
560             }
561        };
562        match self.http("alipay.trade.fastpay.refund.query", body.clone()) {
563            Ok(e) => {
564                if e.has_key("code") && e["code"].as_str().unwrap() != "10000" {
565                    return Err(e["msg"].to_string());
566                }
567                let res = RefundNotify {
568                    out_trade_no: e["out_trade_no"].to_string(),
569                    refund_no: e["out_request_no"].to_string(),
570                    sp_mchid: "".to_string(),
571                    sub_mchid: sub_mchid.to_string(),
572                    transaction_id: e["trade_no"].to_string(),
573                    refund_id: e["out_request_no"].to_string(),
574                    success_time: Local::now().timestamp(),
575                    total: e["total_amount"].to_string().parse::<f64>().unwrap(),
576                    payer_total: e["total_amount"].to_string().parse::<f64>().unwrap(),
577                    refund: e["refund_amount"].to_string().parse::<f64>().unwrap(),
578                    payer_refund: e["refund_amount"].to_string().parse::<f64>().unwrap(),
579                    status: RefundStatus::from(e["refund_status"].as_str().unwrap()),
580                };
581                Ok(res.json())
582            }
583            Err(e) => Err(e)
584        }
585    }
586
587    fn incoming(&mut self, _business_code: &str, _contact_info: JsonValue, _subject_info: JsonValue, _business_info: JsonValue, _settlement_info: JsonValue, _bank_account_info: JsonValue) -> Result<JsonValue, String> {
588        todo!()
589    }
590}
br_pay/alipay.rs

br_pay/
alipay.rs
