WeChat Pay API v3

https://pay.weixin.qq.com/doc/v3/
Admin
WeChat Pay API v3 is Tencent's payment processing platform that enables merchants to accept payments...
Tokens:2,237,986
Snippets:7,876
Trust Score:10
Update:5 hours ago
Show doc for...
Tokens:
Raw
### Go main function and QueryReturnOrder function using wxpay_utility

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012526279

Go example that configures merchant credentials via wxpay_utility.CreateMchConfig, builds a QueryReturnOrderRequest, calls QueryReturnOrder, and handles success/failure. The QueryReturnOrder function constructs the GET request to /v3/profitsharing/return-orders/{out_return_no} with query parameter out_order_no, sets required headers, and extracts the response body.

```go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/merchant/4015119334
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	request := &QueryReturnOrderRequest{
		OutReturnNo: wxpay_utility.String("R20190516001"),
		OutOrderNo:  wxpay_utility.String("P20190806125346"),
	}

	response, err := QueryReturnOrder(config, request)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}

func QueryReturnOrder(config *wxpay_utility.MchConfig, request *QueryReturnOrderRequest) (response *ReturnOrdersEntity, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/profitsharing/return-orders/{out_return_no}"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	reqUrl.Path = strings.Replace(reqUrl.Path, "{out_return_no}", url.PathEscape(*request.OutReturnNo), -1)
	query := reqUrl.Query()
	if request.OutOrderNo != nil {
		query.Add("out_order_no", *request.OutOrderNo)
	}
	reqUrl.RawQuery = query.Encode()
	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Accept", "application/json")
	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Authorization", authorization)

	client := &http.Client{}
	httpResponse, err := client.Do(httpRequest)
	if err != nil {
		return nil, err
	}
	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
	if err != nil {
		return nil, err
	}
}
```

--------------------------------

### QueryOrderAmount Go example for /v3/profitsharing/transactions/{transaction_id}/amounts

Source: https://pay.weixin.qq.com/doc/v3/partner/4012457927

Go example that queries the unsplit amount for a profit-sharing transaction. It builds a GET request to the WeChat Pay partner API, sets required headers (Accept, Wechatpay-Serial, Authorization), validates the response signature, and unmarshals the JSON response. Requires a wxpay_utility MchConfig with merchant ID, certificate serial number, private key, WeChat Pay public key ID, and public key file path.

```Go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	request := &QueryOrderAmountRequest{
		TransactionId: wxpay_utility.String("4208450740201411110007820472"),
	}

	response, err := QueryOrderAmount(config, request)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}

func QueryOrderAmount(config *wxpay_utility.MchConfig, request *QueryOrderAmountRequest) (response *QueryOrderAmountResponse, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/profitsharing/transactions/{transaction_id}/amounts"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	reqUrl.Path = strings.Replace(reqUrl.Path, "{transaction_id}", url.PathEscape(*request.TransactionId), -1)
	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Accept", "application/json")
	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Authorization", authorization)

	client := &http.Client{}
	httpResponse, err := client.Do(httpRequest)
	if err != nil {
		return nil, err
	}
	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
	if err != nil {
		return nil, err
	}
	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
		// 2XX 成功，验证应答签名
		err = wxpay_utility.ValidateResponse(
			config.WechatPayPublicKeyId(),
			config.WechatPayPublicKey(),
			&httpResponse.Header,
			respBody,
		)
		if err != nil {
			return nil, err
		}
		response := &QueryOrderAmountResponse{}
		if err := json.Unmarshal(respBody, response); err != nil {
			return nil, err
		}

		return response, nil
	} else {
		return nil, wxpay_utility.NewApiException(
			httpResponse.StatusCode,
			httpResponse.Header,
			respBody,
		)
	}
}

type QueryOrderAmountRequest struct {
	TransactionId *string `json:"transaction_id,omitempty"`
}

func (o *QueryOrderAmountRequest) MarshalJSON() ([]byte, error) {
	type Alias QueryOrderAmountRequest
	a := &struct {
		TransactionId *string `json:"transaction_id,omitempty"`
		*Alias
	}{
		// 序列化时移除非 Body 字段
		TransactionId: nil,
		Alias:         (*Alias)(o),
	}
	return json.Marshal(a)
}

type QueryOrderAmountResponse struct {
	TransactionId *string `json:"transaction_id,omitempty"`
	UnsplitAmount *int64  `json:"unsplit_amount,omitempty"`
}
```

--------------------------------

### Go: AcquireFapiaoTitleUrl main with wxpay_utility config

Source: https://pay.weixin.qq.com/doc/v3/partner/4015770776

Sets up merchant configuration using wxpay_utility.CreateMchConfig with placeholder values for merchant ID, certificate serial, private key path, public key ID, and public key path. Requires the wxpay_utility library referenced at the provided URL. Placeholder values must be replaced with actual merchant parameters.

```go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
```

--------------------------------

### QueryElecsignByOutNo Go example

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012716436

Go code for querying an electronic signature by out bill number using the WeChat Pay v3 API. It includes a main function that creates a merchant config, sends a GET request to /v3/fund-app/mch-transfer/elecsign/out-bill-no/{out_bill_no}, and handles success or failure. The code defines request/response structs and enums for status and hash type.

```go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/merchant/4015119334
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	request := &QueryElecsignByOutNoRequest{
		OutBillNo: wxpay_utility.String("plfk2020042013"),
	}

	response, err := QueryElecsignByOutNo(config, request)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}

func QueryElecsignByOutNo(config *wxpay_utility.MchConfig, request *QueryElecsignByOutNoRequest) (response *QueryElecsignResponse, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/fund-app/mch-transfer/elecsign/out-bill-no/{out_bill_no}"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	reqUrl.Path = strings.Replace(reqUrl.Path, "{out_bill_no}", url.PathEscape(*request.OutBillNo), -1)
	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Accept", "application/json")
	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Authorization", authorization)

	client := &http.Client{}
	httpResponse, err := client.Do(httpRequest)
	if err != nil {
		return nil, err
	}
	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
	if err != nil {
		return nil, err
	}
	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
		// 2XX 成功，验证应答签名
		err = wxpay_utility.ValidateResponse(
			config.WechatPayPublicKeyId(),
			config.WechatPayPublicKey(),
			&httpResponse.Header,
			respBody,
		)
		if err != nil {
			return nil, err
		}
		response := &QueryElecsignResponse{}
		if err := json.Unmarshal(respBody, response); err != nil {
			return nil, err
		}

		return response, nil
	} else {
		return nil, wxpay_utility.NewApiException(
			httpResponse.StatusCode,
			httpResponse.Header,
			respBody,
		)
	}
}

type QueryElecsignByOutNoRequest struct {
	OutBillNo *string `json:"out_bill_no,omitempty"`
}

func (o *QueryElecsignByOutNoRequest) MarshalJSON() ([]byte, error) {
	type Alias QueryElecsignByOutNoRequest
	a := &struct {
		OutBillNo *string `json:"out_bill_no,omitempty"`
		*Alias
	}{
		// 序列化时移除非 Body 字段
		OutBillNo: nil,
		Alias:     (*Alias)(o),
	}
	return json.Marshal(a)
}

type QueryElecsignResponse struct {
	State       *ElecsignStatus   `json:"state,omitempty"`
	CreateTime  *string           `json:"create_time,omitempty"`
	UpdateTime  *string           `json:"update_time,omitempty"`
	HashType    *ElecsignHashType `json:"hash_type,omitempty"`
	HashValue   *string           `json:"hash_value,omitempty"`
	DownloadUrl *string           `json:"download_url,omitempty"`
}

type ElecsignStatus string

func (e ElecsignStatus) Ptr() *ElecsignStatus {
	return &e
}

const (
	ELECSIGNSTATUS_GENERATING ElecsignStatus = "GENERATING"
	ELECSIGNSTATUS_FINISHED   ElecsignStatus = "FINISHED"
	ELECSIGNSTATUS_FAILED     ElecsignStatus = "FAILED"
)

type ElecsignHashType string

func (e ElecsignHashType) Ptr() *ElecsignHashType {
	return &e
}

const (
	ELECSIGNHASHTYPE_SHA256 ElecsignHashType = "SHA256"
	ELECSIGNHASHTYPE_SM3    ElecsignHashType = "SM3"
)
```

--------------------------------

### Go 创建退款请求并调用 Create 函数

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012791862

使用 wxpay_utility 工具库配置商户参数，构造 CreateRequest 退款请求并调用 Create 函数发起退款。请求失败时打印错误并返回，成功时打印响应。

```go
func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	request := &CreateRequest{
		TransactionId: wxpay_utility.String("1217752501201407033233368018"),
		OutTradeNo:    wxpay_utility.String("1217752501201407033233368018"),
		OutRefundNo:   wxpay_utility.String("1217752501201407033233368018"),
		Reason:        wxpay_utility.String("商品已售完"),
		NotifyUrl:     wxpay_utility.String("https://weixin.qq.com"),
		FundsAccount:  REQFUNDSACCOUNT_AVAILABLE.Ptr(),
		Amount: &AmountReq{
			Refund: wxpay_utility.Int64(888),
			From: []FundsFromItem{FundsFromItem{
				Account: ACCOUNT_AVAILABLE.Ptr(),
				Amount:  wxpay_utility.Int64(444),
			}},
			Total:    wxpay_utility.Int64(888),
			Currency: wxpay_utility.String("CNY"),
		},
		GoodsDetail: []GoodsDetail{GoodsDetail{
			MerchantGoodsId:  wxpay_utility.String("1217752501201407033233368018"),
			WechatpayGoodsId: wxpay_utility.String("1001"),
			GoodsName:        wxpay_utility.String("iPhone6s 16G"),
			UnitPrice:        wxpay_utility.Int64(528800),
			RefundAmount:     wxpay_utility.Int64(528800),
			RefundQuantity:   wxpay_utility.Int64(1),
		}},
	}

	response, err := Create(config, request)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}
```

--------------------------------

### String 复制string对象

Source: https://pay.weixin.qq.com/doc/v3/merchant/4015119334

复制string对象并返回指针。

```Go
// String 复制 string 对象，并返回复制体的指针
func String(s string) *string {
	return &s
}
```

--------------------------------

### Go 查询用户确认授权 (Get)

Source: https://pay.weixin.qq.com/doc/v3/merchant/4014399423

Go 示例，使用 wxpay_utility 工具库发送 GET 请求查询用户确认授权信息。需先创建 MchConfig 并准备商户参数。请求失败时根据状态码处理，成功后可继续业务逻辑。

```go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/merchant/4015119334
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	request := &GetRequest{
		OutAuthorizationNo:     wxpay_utility.String("plfk2020042013"),
		IsDisplayAuthorization: wxpay_utility.Bool(true),
	}

	response, err := Get(config, request)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}

func Get(config *wxpay_utility.MchConfig, request *GetRequest) (response *UserConfirmAuthorizationEntity, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/fund-app/mch-transfer/user-confirm-authorization/out-authorization-no/{out_authorization_no}"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	reqUrl.Path = strings.Replace(reqUrl.Path, "{out_authorization_no}", url.PathEscape(*request.OutAuthorizationNo), -1)
```

--------------------------------

### Go 查询投诉通知回调地址 (GET /v3/merchant-service/complaint-notifications)

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012459014

使用微信支付工具库发送 GET 请求查询投诉通知回调地址。需要先配置商户号、API 证书序列号、私钥文件、微信支付公钥 ID 和公钥文件。请求成功时验证应答签名并解析响应，失败时抛出 ApiException。

```Go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/merchant/4015119334
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	response, err := QueryComplaintNotifications(config)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}

func QueryComplaintNotifications(config *wxpay_utility.MchConfig) (response *QueryComplaintNotificationsResponse, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/merchant-service/complaint-notifications"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Accept", "application/json")
	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Authorization", authorization)

	client := &http.Client{}
	httpResponse, err := client.Do(httpRequest)
	if err != nil {
		return nil, err
	}
	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
	if err != nil {
		return nil, err
	}
	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
		// 2XX 成功，验证应答签名
		err = wxpay_utility.ValidateResponse(
			config.WechatPayPublicKeyId(),
			config.WechatPayPublicKey(),
			&httpResponse.Header,
			respBody,
		)
		if err != nil {
			return nil, err
		}
		response := &QueryComplaintNotificationsResponse{}
		if err := json.Unmarshal(respBody, response); err != nil {
			return nil, err
		}

		return response, nil
	} else {
		return nil, wxpay_utility.NewApiException(
			httpResponse.StatusCode,
			httpResponse.Header,
			respBody,
		)
	}
}

type QueryComplaintNotificationsResponse struct {
	Mchid *string `json:"mchid,omitempty"`
	Url   *string `json:"url,omitempty"`
}

```

--------------------------------

### Go 调用 GetApplication 查询申请状态

Source: https://pay.weixin.qq.com/doc/v3/partner/4012760660

使用微信支付工具库 wxpay_utility 发起 GET /v3/apply4sub/sub_merchants/{sub_mchid}/application/{application_no} 请求，查询子商户入驻申请状态。需先准备商户号、API证书序列号、私钥文件、微信支付公钥ID及公钥文件。请求参数包括 sub_mchid、application_no 和可选的 account_number_rule。

```Go
package main

import (
	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
)

func main() {
	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
	config, err := wxpay_utility.CreateMchConfig(
		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	request := &GetApplicationRequest{
		SubMchid:          wxpay_utility.String("1511101111"),
		ApplicationNo:     wxpay_utility.String("102329389XXXX"),
		AccountNumberRule: ACCOUNTNUMBERRULE_ACCOUNT_NUMBER_RULE_MASK_V1.Ptr(),
	}

	response, err := GetApplication(config, request)
	if err != nil {
		fmt.Printf("请求失败: %+v\n", err)
		// TODO: 请求失败，根据状态码执行不同的处理
		return
	}

	// TODO: 请求成功，继续业务逻辑
	fmt.Printf("请求成功: %+v\n", response)
}

func GetApplication(config *wxpay_utility.MchConfig, request *GetApplicationRequest) (response *SubMerchantsGetApplicationResponse, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/apply4sub/sub_merchants/{sub_mchid}/application/{application_no}"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	reqUrl.Path = strings.Replace(reqUrl.Path, "{sub_mchid}", url.PathEscape(*request.SubMchid), -1)
	reqUrl.Path = strings.Replace(reqUrl.Path, "{application_no}", url.PathEscape(*request.ApplicationNo), -1)
	query := reqUrl.Query()
	if request.AccountNumberRule != nil {
		query.Add("account_number_rule", fmt.Sprintf("%v", *request.AccountNumberRule))
	}

```

--------------------------------

### GET 请求示例：查询对私银行卡号开户银行

Source: https://pay.weixin.qq.com/doc/v3/partner/4012697541

使用 GET 方法调用 /v3/capital/capitallhh/banks/search-banks-by-bank-account 接口，account_number 参数需使用微信支付公钥或平台证书公钥加密。请求头需包含 Authorization、Accept 和 Wechatpay-Serial。

```bash
curl -X GET \
  https://api.mch.weixin.qq.com/v3/capital/capitallhh/banks/search-banks-by-bank-account?account_number=Iuas%2BxWj7ma0t%2Frcuy6eLqTBVkoxfc1vGVTjl4lqgPKinK24WHVnHao%2BJVp5xAJlvrkGPndf8LHOmroQ9qq44y2rUiPY7fEErV0zMh0vAKAG76M6yqcqQ9A1wOQ8l%2BIL7iQGAnd6SfqRMUsy8AU1nhzDwl7MUn2lBAPyFiR1LtJdc1ASagvSW3CP53iXyaVSkvVianWI6WUzb3xHv7HpEOSpaG3H9bhOjjdkbi8eaCudkbhXgF2f3QKfwO696j5DJTxN56r%2BomxtVfpgvi9B2fQOgDu7pZ%2FoqkkeTSyht%2BL8lL7T14%2FUj5T1m8fV9LOgjk2gGxziLjDgXCiX3jLXNw%3D%3D \
  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
  -H "Accept: application/json" \
  -H "Wechatpay-Serial: 5157F09EFDC096DE15EBE81A47057A7232F1B8E1"
```

--------------------------------

### QueryByOutRefundNo Go example with config and request

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012791863

Shows how to create a merchant config, build a QueryByOutRefundNoRequest, and call QueryByOutRefundNo. The config requires merchant ID, API certificate serial number, private key path, WeChat Pay public key ID, and public key path. On failure, prints the error; on success, prints the response.

```go
config, err := wxpay_utility.CreateMchConfig(
	"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
	"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
	"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
	"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
)
if err != nil {
	fmt.Println(err)
	return
}

request := &QueryByOutRefundNoRequest{
	OutRefundNo: wxpay_utility.String("1217752501201407033233368018")
}

response, err := QueryByOutRefundNo(config, request)
if err != nil {
	fmt.Printf("请求失败: %+v\n", err)
	// TODO: 请求失败，根据状态码执行不同的处理
	return
}

// TODO: 请求成功，继续业务逻辑
fmt.Printf("请求成功: %+v\n", response)
}
```

--------------------------------

### GET 请求查询税收分类编码对照表

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012538236

使用 GET 请求查询商户在微信支付商户平台配置的电子发票税收分类编码对照表。请求需携带 Authorization 和 Accept 请求头，并通过 offset 和 limit 查询参数控制分页。

```bash
curl -X GET \
  https://api.mch.weixin.qq.com/v3/new-tax-control-fapiao/merchant/tax-codes?offset=0&limit=5 \
  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
  -H "Accept: application/json" 

```

--------------------------------

### Go main function using wxpay_utility to create merchant config

Source: https://pay.weixin.qq.com/doc/v3/partner/4012738964

Starts a Go program that imports the wxpay_utility package and calls CreateMchConfig with a merchant ID placeholder. Requires the wxpay_utility library (see referenced documentation) and merchant parameters prepared as noted in the TODO comment.

```go
1package main
2
3import (
4	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
5	"encoding/json"
6	"fmt"
7	"net/http"
8	"net/url"
9	"strings"
10)
11
12func main() {
13	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
14	config, err := wxpay_utility.CreateMchConfig(
15		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
```

--------------------------------

### LoadPublicKeyWithPath

Source: https://pay.weixin.qq.com/doc/v3/merchant/4015119334

通过公钥的文件路径加载 RSA 公钥。读取文件内容并调用 LoadPublicKey 进行解析。

```APIDOC
## LoadPublicKeyWithPath

### Description
通过公钥的文件路径加载 RSA 公钥。

### Method
LoadPublicKeyWithPath

### Parameters
- **path** (string) - Required - 公钥文件路径

### Returns
- **publicKey** (*rsa.PublicKey) - 公钥对象
- **err** (error) - 错误信息
```

--------------------------------

### GET 请求查询商户配置开发选项

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012529526

使用 GET 请求调用 /v3/new-tax-control-fapiao/merchant/development-config 接口，需在 Header 中携带 Authorization 和 Accept 参数。适用于直连商户和服务商。

```bash
curl -X GET \
  https://api.mch.weixin.qq.com/v3/new-tax-control-fapiao/merchant/development-config \
  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
  -H "Accept: application/json"
```

--------------------------------

### QueryByOutRefundNo function and request setup

Source: https://pay.weixin.qq.com/doc/v3/merchant/4012810601

Initializes the merchant configuration and creates a query request for a refund by out_refund_no. Calls QueryByOutRefundNo and handles success or failure responses.

```go
config, err := wxpay_utility.CreateMchConfig(
	"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/merchant/4013070756
	"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013053053
	"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
	"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/merchant/4013038816
	"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
)
if err != nil {
	fmt.Println(err)
	return
}

request := &QueryByOutRefundNoRequest{
	OutRefundNo: wxpay_utility.String("1217752501201407033233368018")
}

response, err := QueryByOutRefundNo(config, request)
if err != nil {
	fmt.Printf("请求失败: %+v\n", err)
	// TODO: 请求失败，根据状态码执行不同的处理
	return
}

// TODO: 请求成功，继续业务逻辑
fmt.Printf("请求成功: %+v\n", response)
}
```

```go
func QueryByOutRefundNo(config *wxpay_utility.MchConfig, request *QueryByOutRefundNoRequest) (response *Refund, err error) {
	const (
		host   = "https://api.mch.weixin.qq.com"
		method = "GET"
		path   = "/v3/refund/domestic/refunds/{out_refund_no}"
	)

	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
	if err != nil {
		return nil, err
	}
	reqUrl.Path = strings.Replace(reqUrl.Path, "{out_refund_no}", url.PathEscape(*request.OutRefundNo), -1)
	query := reqUrl.Query()
	reqUrl.RawQuery = query.Encode()
	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Accept", "application/json")
	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
	if err != nil {
		return nil, err
	}
	httpRequest.Header.Set("Authorization", authorization)

	client := &http.Client{}
	httpResponse, err := client.Do(httpRequest)
	if err != nil {
		return nil, err
	}
	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
	if err != nil {
		return nil, err
	}
	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
		// 2XX 成功，验证应答签名
		err = wxpay_utility.ValidateResponse(
			config.WechatPayPublicKeyId(),
			config.WechatPayPublicKey(),
			&httpResponse.Header,
			respBody,
		)
		if err != nil {
			return nil, err
		}
		response := &Refund{}
		if err := json.Unmarshal(respBody, response); err != nil {
			return nil, err
		}

		return response, nil
	} else {
		return nil, wxpay_utility.NewApiException(
			httpResponse.StatusCode,
			httpResponse.Header,
			respBody,
		)
	}
}
```
Tokens:
Raw