584 lines
15 KiB
Go
584 lines
15 KiB
Go
package leshua
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/md5"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
ErrConfigIncomplete = errors.New("leshua payment config incomplete")
|
|
ErrUnsupportedSign = errors.New("unsupported leshua sign type")
|
|
)
|
|
|
|
type Client struct {
|
|
cfg Config
|
|
httpClient *http.Client
|
|
}
|
|
|
|
type Config struct {
|
|
GatewayURL string
|
|
MerchantID string
|
|
SignKey string
|
|
NotifyKey string
|
|
NotifyURL string
|
|
JumpURL string
|
|
PayWay string
|
|
JSPayFlag string
|
|
SignType string
|
|
}
|
|
|
|
type CreatePaymentRequest struct {
|
|
ThirdOrderID string
|
|
AmountCent int64
|
|
PayWay string
|
|
JSPayFlag string
|
|
NotifyURL string
|
|
JumpURL string
|
|
ClientIP string
|
|
Body string
|
|
Attach string
|
|
}
|
|
|
|
type CreatePaymentResponse struct {
|
|
RespCode string
|
|
ResultCode string
|
|
ErrorCode string
|
|
ErrorMessage string
|
|
MerchantID string
|
|
ThirdOrderID string
|
|
ProviderOrderID string
|
|
PayWay string
|
|
TDCode string
|
|
JSPayURL string
|
|
JSPayInfo string
|
|
Raw map[string]string
|
|
}
|
|
|
|
type QueryPaymentResponse struct {
|
|
RespCode string
|
|
ResultCode string
|
|
ErrorCode string
|
|
ErrorMessage string
|
|
MerchantID string
|
|
ThirdOrderID string
|
|
ProviderOrderID string
|
|
Status string
|
|
Amount string
|
|
PayWay string
|
|
PayTime string
|
|
Raw map[string]string
|
|
}
|
|
|
|
type CreateRefundRequest struct {
|
|
ThirdOrderID string // 原支付商户订单号
|
|
LeshuaOrderID string // 原支付乐刷订单号(优先使用)
|
|
MerchantRefundID string // 商户退款单号(唯一)
|
|
RefundAmountCent int64 // 退款金额(分)
|
|
NotifyURL string
|
|
Attach string
|
|
}
|
|
|
|
type CreateRefundResponse struct {
|
|
RespCode string
|
|
ResultCode string
|
|
ErrorCode string
|
|
ErrorMessage string
|
|
MerchantID string
|
|
ThirdOrderID string
|
|
LeshuaOrderID string
|
|
MerchantRefundID string
|
|
LeshuaRefundID string
|
|
RefundAmount string
|
|
TotalAmount string
|
|
OrderBalance string
|
|
Status string
|
|
Raw map[string]string
|
|
}
|
|
|
|
type QueryRefundRequest struct {
|
|
ThirdOrderID string
|
|
LeshuaOrderID string
|
|
MerchantRefundID string
|
|
LeshuaRefundID string
|
|
}
|
|
|
|
type QueryRefundResponse struct {
|
|
RespCode string
|
|
ResultCode string
|
|
ErrorCode string
|
|
ErrorMessage string
|
|
MerchantID string
|
|
ThirdOrderID string
|
|
LeshuaOrderID string
|
|
MerchantRefundID string
|
|
LeshuaRefundID string
|
|
Status string
|
|
RefundAmount string
|
|
TotalAmount string
|
|
RefundTime string
|
|
Raw map[string]string
|
|
}
|
|
|
|
type VerifyNotifyResult struct {
|
|
OK bool
|
|
MatchedKey string
|
|
Got string
|
|
Expected map[string]string
|
|
BaseString map[string]string
|
|
ParamKeys []string
|
|
}
|
|
|
|
func NewClient(cfg Config) *Client {
|
|
return &Client{
|
|
cfg: cfg,
|
|
httpClient: &http.Client{
|
|
Timeout: 10 * time.Second,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c *Client) CreatePayment(ctx context.Context, req CreatePaymentRequest) (*CreatePaymentResponse, map[string]string, error) {
|
|
if err := c.validate(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
payWay := firstNonEmpty(req.PayWay, c.cfg.PayWay, "ZFBZF")
|
|
jsPayFlag := firstNonEmpty(req.JSPayFlag, c.cfg.JSPayFlag, "2")
|
|
params := map[string]string{
|
|
"service": "get_tdcode",
|
|
"merchant_id": c.cfg.MerchantID,
|
|
"third_order_id": req.ThirdOrderID,
|
|
"amount": fmt.Sprintf("%d", req.AmountCent),
|
|
"pay_way": payWay,
|
|
"jspay_flag": jsPayFlag,
|
|
"nonce_str": Nonce(32),
|
|
"body": sanitizeText(req.Body, 128),
|
|
"attach": sanitizeText(req.Attach, 64),
|
|
}
|
|
if c.cfg.SignType != "" && !strings.EqualFold(c.cfg.SignType, "MD5") {
|
|
params["sign_type"] = c.cfg.SignType
|
|
}
|
|
if req.NotifyURL != "" {
|
|
params["notify_url"] = req.NotifyURL
|
|
}
|
|
if req.JumpURL != "" {
|
|
params["jump_url"] = req.JumpURL
|
|
}
|
|
if req.ClientIP != "" {
|
|
params["client_ip"] = req.ClientIP
|
|
}
|
|
params["sign"] = Sign(params, c.cfg.SignKey, SignOptions{})
|
|
raw, err := c.post(ctx, params)
|
|
if err != nil {
|
|
return nil, params, err
|
|
}
|
|
resp := &CreatePaymentResponse{
|
|
RespCode: raw["resp_code"],
|
|
ResultCode: raw["result_code"],
|
|
ErrorCode: raw["error_code"],
|
|
ErrorMessage: firstNonEmpty(raw["error_msg"], raw["resp_msg"]),
|
|
MerchantID: raw["merchant_id"],
|
|
ThirdOrderID: raw["third_order_id"],
|
|
ProviderOrderID: raw["leshua_order_id"],
|
|
PayWay: raw["pay_way"],
|
|
TDCode: raw["td_code"],
|
|
JSPayURL: raw["jspay_url"],
|
|
JSPayInfo: raw["jspay_info"],
|
|
Raw: raw,
|
|
}
|
|
return resp, params, nil
|
|
}
|
|
|
|
func (c *Client) QueryPayment(ctx context.Context, thirdOrderID, providerOrderID string) (*QueryPaymentResponse, error) {
|
|
if err := c.validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
params := map[string]string{
|
|
"service": "query_status",
|
|
"merchant_id": c.cfg.MerchantID,
|
|
"nonce_str": Nonce(32),
|
|
}
|
|
if providerOrderID != "" {
|
|
params["leshua_order_id"] = providerOrderID
|
|
} else {
|
|
params["third_order_id"] = thirdOrderID
|
|
}
|
|
if c.cfg.SignType != "" && !strings.EqualFold(c.cfg.SignType, "MD5") {
|
|
params["sign_type"] = c.cfg.SignType
|
|
}
|
|
params["sign"] = Sign(params, c.cfg.SignKey, SignOptions{})
|
|
raw, err := c.post(ctx, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &QueryPaymentResponse{
|
|
RespCode: raw["resp_code"],
|
|
ResultCode: raw["result_code"],
|
|
ErrorCode: raw["error_code"],
|
|
ErrorMessage: firstNonEmpty(raw["error_msg"], raw["resp_msg"]),
|
|
MerchantID: raw["merchant_id"],
|
|
ThirdOrderID: raw["third_order_id"],
|
|
ProviderOrderID: raw["leshua_order_id"],
|
|
Status: raw["status"],
|
|
Amount: raw["amount"],
|
|
PayWay: raw["pay_way"],
|
|
PayTime: raw["pay_time"],
|
|
Raw: raw,
|
|
}, nil
|
|
}
|
|
|
|
func (c *Client) CreateRefund(ctx context.Context, req CreateRefundRequest) (*CreateRefundResponse, map[string]string, error) {
|
|
if err := c.validate(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
params := map[string]string{
|
|
"service": "unified_refund",
|
|
"merchant_id": c.cfg.MerchantID,
|
|
"merchant_refund_id": req.MerchantRefundID,
|
|
"refund_amount": fmt.Sprintf("%d", req.RefundAmountCent),
|
|
"nonce_str": Nonce(32),
|
|
}
|
|
if req.LeshuaOrderID != "" {
|
|
params["leshua_order_id"] = req.LeshuaOrderID
|
|
} else if req.ThirdOrderID != "" {
|
|
params["third_order_id"] = req.ThirdOrderID
|
|
}
|
|
if req.Attach != "" {
|
|
params["attach"] = sanitizeText(req.Attach, 64)
|
|
}
|
|
if c.cfg.SignType != "" && !strings.EqualFold(c.cfg.SignType, "MD5") {
|
|
params["sign_type"] = c.cfg.SignType
|
|
}
|
|
if req.NotifyURL != "" {
|
|
params["notify_url"] = req.NotifyURL
|
|
}
|
|
params["sign"] = Sign(params, c.cfg.SignKey, SignOptions{})
|
|
raw, err := c.post(ctx, params)
|
|
if err != nil {
|
|
return nil, params, err
|
|
}
|
|
resp := &CreateRefundResponse{
|
|
RespCode: raw["resp_code"],
|
|
ResultCode: raw["result_code"],
|
|
ErrorCode: raw["error_code"],
|
|
ErrorMessage: firstNonEmpty(raw["error_msg"], raw["resp_msg"]),
|
|
MerchantID: raw["merchant_id"],
|
|
ThirdOrderID: raw["third_order_id"],
|
|
LeshuaOrderID: raw["leshua_order_id"],
|
|
MerchantRefundID: raw["merchant_refund_id"],
|
|
LeshuaRefundID: raw["leshua_refund_id"],
|
|
RefundAmount: raw["refund_amount"],
|
|
TotalAmount: raw["total_amount"],
|
|
OrderBalance: raw["order_balance"],
|
|
Status: raw["status"],
|
|
Raw: raw,
|
|
}
|
|
return resp, params, nil
|
|
}
|
|
|
|
func (c *Client) QueryRefund(ctx context.Context, req QueryRefundRequest) (*QueryRefundResponse, error) {
|
|
if err := c.validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
params := map[string]string{
|
|
"service": "unified_query_refund",
|
|
"merchant_id": c.cfg.MerchantID,
|
|
"nonce_str": Nonce(32),
|
|
}
|
|
if req.LeshuaOrderID != "" {
|
|
params["leshua_order_id"] = req.LeshuaOrderID
|
|
} else if req.ThirdOrderID != "" {
|
|
params["third_order_id"] = req.ThirdOrderID
|
|
}
|
|
if req.LeshuaRefundID != "" {
|
|
params["leshua_refund_id"] = req.LeshuaRefundID
|
|
} else if req.MerchantRefundID != "" {
|
|
params["merchant_refund_id"] = req.MerchantRefundID
|
|
}
|
|
if c.cfg.SignType != "" && !strings.EqualFold(c.cfg.SignType, "MD5") {
|
|
params["sign_type"] = c.cfg.SignType
|
|
}
|
|
params["sign"] = Sign(params, c.cfg.SignKey, SignOptions{})
|
|
raw, err := c.post(ctx, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &QueryRefundResponse{
|
|
RespCode: raw["resp_code"],
|
|
ResultCode: raw["result_code"],
|
|
ErrorCode: raw["error_code"],
|
|
ErrorMessage: firstNonEmpty(raw["error_msg"], raw["resp_msg"]),
|
|
MerchantID: raw["merchant_id"],
|
|
ThirdOrderID: raw["third_order_id"],
|
|
LeshuaOrderID: raw["leshua_order_id"],
|
|
MerchantRefundID: raw["merchant_refund_id"],
|
|
LeshuaRefundID: raw["leshua_refund_id"],
|
|
Status: raw["status"],
|
|
RefundAmount: raw["refund_amount"],
|
|
TotalAmount: raw["total_amount"],
|
|
RefundTime: raw["refund_time"],
|
|
Raw: raw,
|
|
}, nil
|
|
}
|
|
|
|
func (c *Client) VerifyNotify(params map[string]string) bool {
|
|
return c.VerifyNotifyDetail(params).OK
|
|
}
|
|
|
|
func (c *Client) VerifyNotifyDetail(params map[string]string) VerifyNotifyResult {
|
|
got := strings.ToUpper(params["sign"])
|
|
result := VerifyNotifyResult{
|
|
Got: got,
|
|
Expected: map[string]string{},
|
|
BaseString: map[string]string{},
|
|
ParamKeys: notifyParamKeys(params),
|
|
}
|
|
if got == "" {
|
|
return result
|
|
}
|
|
for _, item := range c.notifyKeyCandidates() {
|
|
expected := Sign(params, item.key, notifySignOptions())
|
|
baseString := SignBaseString(params, notifySignOptions())
|
|
result.Expected[item.name] = expected
|
|
result.BaseString[item.name] = baseString
|
|
if got == expected {
|
|
result.OK = true
|
|
result.MatchedKey = item.name
|
|
return result
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func notifySignOptions() SignOptions {
|
|
return SignOptions{
|
|
IncludeEmpty: true,
|
|
ExcludeKeys: []string{"error_code", "leshua", "sign"},
|
|
}
|
|
}
|
|
|
|
type notifyKeyCandidate struct {
|
|
name string
|
|
key string
|
|
}
|
|
|
|
func (c *Client) notifyKeyCandidates() []notifyKeyCandidate {
|
|
candidates := []notifyKeyCandidate{}
|
|
if c.cfg.NotifyKey != "" {
|
|
candidates = append(candidates, notifyKeyCandidate{name: "notify_key", key: c.cfg.NotifyKey})
|
|
}
|
|
return candidates
|
|
}
|
|
|
|
func notifyParamKeys(params map[string]string) []string {
|
|
keys := make([]string, 0, len(params))
|
|
for key := range params {
|
|
if key == "sign" || key == "error_code" || key == "leshua" {
|
|
continue
|
|
}
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
return keys
|
|
}
|
|
|
|
func (c *Client) validate() error {
|
|
if strings.TrimSpace(c.cfg.GatewayURL) == "" || c.cfg.MerchantID == "" || c.cfg.SignKey == "" {
|
|
return ErrConfigIncomplete
|
|
}
|
|
if c.cfg.SignType != "" && !strings.EqualFold(c.cfg.SignType, "MD5") {
|
|
return ErrUnsupportedSign
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Client) post(ctx context.Context, params map[string]string) (map[string]string, error) {
|
|
values := url.Values{}
|
|
for key, value := range params {
|
|
values.Set(key, value)
|
|
}
|
|
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimSpace(c.cfg.GatewayURL), strings.NewReader(values.Encode()))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
httpReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
httpResp, err := c.httpClient.Do(httpReq)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer httpResp.Body.Close()
|
|
body, err := io.ReadAll(io.LimitReader(httpResp.Body, 1<<20))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
|
return nil, fmt.Errorf("leshua http status %d: %s", httpResp.StatusCode, string(body))
|
|
}
|
|
return ParsePayload(body)
|
|
}
|
|
|
|
type SignOptions struct {
|
|
IncludeEmpty bool
|
|
ExcludeKeys []string
|
|
}
|
|
|
|
func Sign(params map[string]string, key string, opts SignOptions) string {
|
|
baseString := SignBaseString(params, opts)
|
|
stringSignTemp := "key=" + key
|
|
if baseString != "" {
|
|
stringSignTemp = baseString + "&key=" + key
|
|
}
|
|
sum := md5.Sum([]byte(stringSignTemp))
|
|
return strings.ToUpper(hex.EncodeToString(sum[:]))
|
|
}
|
|
|
|
func SignBaseString(params map[string]string, opts SignOptions) string {
|
|
excluded := map[string]bool{}
|
|
for _, item := range opts.ExcludeKeys {
|
|
excluded[item] = true
|
|
}
|
|
if len(opts.ExcludeKeys) == 0 {
|
|
excluded["sign"] = true
|
|
}
|
|
keys := make([]string, 0, len(params))
|
|
for name, value := range params {
|
|
if excluded[name] {
|
|
continue
|
|
}
|
|
if !opts.IncludeEmpty && value == "" {
|
|
continue
|
|
}
|
|
keys = append(keys, name)
|
|
}
|
|
sort.Strings(keys)
|
|
parts := make([]string, 0, len(keys)+1)
|
|
for _, name := range keys {
|
|
parts = append(parts, name+"="+params[name])
|
|
}
|
|
return strings.Join(parts, "&")
|
|
}
|
|
|
|
func ParsePayload(body []byte) (map[string]string, error) {
|
|
trimmed := bytes.TrimSpace(body)
|
|
if len(trimmed) == 0 {
|
|
return map[string]string{}, nil
|
|
}
|
|
if trimmed[0] == '<' {
|
|
return parseXMLPayload(trimmed)
|
|
}
|
|
if trimmed[0] == '{' {
|
|
var raw map[string]any
|
|
if err := json.Unmarshal(trimmed, &raw); err != nil {
|
|
return nil, err
|
|
}
|
|
out := map[string]string{}
|
|
for key, value := range raw {
|
|
out[key] = fmt.Sprint(value)
|
|
}
|
|
return out, nil
|
|
}
|
|
values, err := url.ParseQuery(string(trimmed))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := map[string]string{}
|
|
for key, item := range values {
|
|
if len(item) > 0 {
|
|
out[key] = item[0]
|
|
}
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, fmt.Errorf("unsupported leshua payload: %s", string(trimmed))
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func parseXMLPayload(body []byte) (map[string]string, error) {
|
|
decoder := xml.NewDecoder(bytes.NewReader(body))
|
|
out := map[string]string{}
|
|
var current string
|
|
depth := 0
|
|
for {
|
|
token, err := decoder.Token()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch item := token.(type) {
|
|
case xml.StartElement:
|
|
depth++
|
|
if depth > 1 {
|
|
current = item.Name.Local
|
|
if _, exists := out[current]; !exists {
|
|
out[current] = ""
|
|
}
|
|
}
|
|
case xml.CharData:
|
|
value := strings.TrimSpace(string(item))
|
|
if current != "" && value != "" {
|
|
out[current] = value
|
|
}
|
|
case xml.EndElement:
|
|
if current == item.Name.Local {
|
|
current = ""
|
|
}
|
|
if depth > 0 {
|
|
depth--
|
|
}
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func Nonce(length int) string {
|
|
const alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
if length <= 0 {
|
|
length = 32
|
|
}
|
|
buf := make([]byte, length)
|
|
random := make([]byte, length)
|
|
if _, err := rand.Read(random); err != nil {
|
|
for i := range buf {
|
|
buf[i] = alphabet[int(time.Now().UnixNano())%len(alphabet)]
|
|
}
|
|
return string(buf)
|
|
}
|
|
for i, item := range random {
|
|
buf[i] = alphabet[int(item)%len(alphabet)]
|
|
}
|
|
return string(buf)
|
|
}
|
|
|
|
func firstNonEmpty(values ...string) string {
|
|
for _, value := range values {
|
|
if value != "" {
|
|
return value
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func sanitizeText(value string, max int) string {
|
|
value = strings.ReplaceAll(value, "\n", " ")
|
|
value = strings.ReplaceAll(value, "\r", " ")
|
|
value = strings.TrimSpace(value)
|
|
if max > 0 && len([]rune(value)) > max {
|
|
return string([]rune(value)[:max])
|
|
}
|
|
return value
|
|
}
|