发起在途异常资金付款指令

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/abnormal-fund-processing/receipts/0100011742874700562078230000/transfer-instructions \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "out_instruction_no" : "1200002",
8    "transfer_mode" : "TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT",
9    "notify_url" : "https://weixin.qq.com",
10    "receiver" : {
11      "mchid" : "1900001108"
12    }
13  }'
14

1package com.java.demo;
2
3import com.java.utils.WXPayUtility; // 引用微信支付工具库，参考：https://pay.weixin.qq.com/doc/v3/partner/4014985777
4
5import com.google.gson.annotations.SerializedName;
6import com.google.gson.annotations.Expose;
7import okhttp3.MediaType;
8import okhttp3.OkHttpClient;
9import okhttp3.Request;
10import okhttp3.RequestBody;
11import okhttp3.Response;
12
13import java.io.IOException;
14import java.io.UncheckedIOException;
15import java.security.PrivateKey;
16import java.security.PublicKey;
17import java.util.ArrayList;
18import java.util.HashMap;
19import java.util.List;
20import java.util.Map;
21
22/**
23 * 发起在途异常资金付款指令
24 */
25public class AcceptInstruction {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/abnormal-fund-processing/receipts/{receipt_id}/transfer-instructions";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    AcceptInstruction client = new AcceptInstruction(
33      "19xxxxxxxx",                    // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
34      "1DDE55AD98Exxxxxxxxxx",         // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
35      "/path/to/apiclient_key.pem",     // 商户API证书私钥文件路径，本地文件路径
36      "PUB_KEY_ID_xxxxxxxxxxxxx",      // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
37      "/path/to/wxp_pub.pem"           // 微信支付公钥文件路径，本地文件路径
38    );
39
40    AcceptInstructionRequest request = new AcceptInstructionRequest();
41    request.receiptId = "0100011742874700562078230000";
42    request.outInstructionNo = "1200002";
43    request.transferMode = TransferModeType.TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT;
44    request.notifyUrl = "https://weixin.qq.com";
45    request.receiver = new Receiver();
46    request.receiver.mchid = "1900001108";
47    try {
48      AbnormalFundReceipt response = client.run(request);
49        // TODO: 请求成功，继续业务逻辑
50        System.out.println(response);
51    } catch (WXPayUtility.ApiException e) {
52        // TODO: 请求失败，根据状态码执行不同的逻辑
53        e.printStackTrace();
54    }
55  }
56
57  public AbnormalFundReceipt run(AcceptInstructionRequest request) {
58    String uri = PATH;
59    uri = uri.replace("{receipt_id}", WXPayUtility.urlEncode(request.receiptId));
60    String reqBody = WXPayUtility.toJson(request);
61
62    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
63    reqBuilder.addHeader("Accept", "application/json");
64    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
65    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
66    reqBuilder.addHeader("Content-Type", "application/json");
67    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
68    reqBuilder.method(METHOD, requestBody);
69    Request httpRequest = reqBuilder.build();
70
71    // 发送HTTP请求
72    OkHttpClient client = new OkHttpClient.Builder().build();
73    try (Response httpResponse = client.newCall(httpRequest).execute()) {
74      String respBody = WXPayUtility.extractBody(httpResponse);
75      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
76        // 2XX 成功，验证应答签名
77        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
78            httpResponse.headers(), respBody);
79
80        // 从HTTP应答报文构建返回数据
81        return WXPayUtility.fromJson(respBody, AbnormalFundReceipt.class);
82      } else {
83        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
84      }
85    } catch (IOException e) {
86      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
87    }
88  }
89
90  private final String mchid;
91  private final String certificateSerialNo;
92  private final PrivateKey privateKey;
93  private final String wechatPayPublicKeyId;
94  private final PublicKey wechatPayPublicKey;
95
96  public AcceptInstruction(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
97    this.mchid = mchid;
98    this.certificateSerialNo = certificateSerialNo;
99    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
100    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
101    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
102  }
103
104  public static class AcceptInstructionRequest {
105    @SerializedName("receipt_id")
106    @Expose(serialize = false)
107    public String receiptId;
108  
109    @SerializedName("out_instruction_no")
110    public String outInstructionNo;
111  
112    @SerializedName("transfer_mode")
113    public TransferModeType transferMode;
114  
115    @SerializedName("notify_url")
116    public String notifyUrl;
117  
118    @SerializedName("receiver")
119    public Receiver receiver;
120  }
121  
122  public static class AbnormalFundReceipt {
123    @SerializedName("product_name")
124    public String productName;
125  
126    @SerializedName("receipt_id")
127    public String receiptId;
128  
129    @SerializedName("transfer_amount")
130    public Amount transferAmount;
131  
132    @SerializedName("receipt_state")
133    public ReceiptState receiptState;
134  
135    @SerializedName("create_time")
136    public String createTime;
137  
138    @SerializedName("last_update_time")
139    public String lastUpdateTime;
140  
141    @SerializedName("instruction")
142    public Instruction instruction;
143  }
144  
145  public enum TransferModeType {
146    @SerializedName("TRANSFER_TO_ORIGINAL_RECEIVE_USER")
147    TRANSFER_TO_ORIGINAL_RECEIVE_USER,
148    @SerializedName("TRANSFER_TO_ORIGINAL_RECEIVE_MERCHANT")
149    TRANSFER_TO_ORIGINAL_RECEIVE_MERCHANT,
150    @SerializedName("TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT")
151    TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT
152  }
153  
154  public static class Receiver {
155    @SerializedName("mchid")
156    public String mchid;
157  }
158  
159  public static class Amount {
160    @SerializedName("total")
161    public Long total;
162  
163    @SerializedName("currency")
164    public Currency currency;
165  }
166  
167  public enum ReceiptState {
168    @SerializedName("RECEIPT_STATE_PENDING")
169    RECEIPT_STATE_PENDING,
170    @SerializedName("RECEIPT_STATE_PROGRESS")
171    RECEIPT_STATE_PROGRESS,
172    @SerializedName("RECEIPT_STATE_COMPLETED")
173    RECEIPT_STATE_COMPLETED
174  }
175  
176  public static class Instruction {
177    @SerializedName("out_instruction_no")
178    public String outInstructionNo;
179  
180    @SerializedName("commander")
181    public Commander commander;
182  
183    @SerializedName("transfer_mode")
184    public TransferModeType transferMode;
185  
186    @SerializedName("receiver")
187    public Receiver receiver;
188  
189    @SerializedName("instruction_state")
190    public InstructionState instructionState;
191  
192    @SerializedName("create_time")
193    public String createTime;
194  
195    @SerializedName("success_time")
196    public String successTime;
197  
198    @SerializedName("notify_url")
199    public String notifyUrl;
200  }
201  
202  public enum Currency {
203    @SerializedName("CNY")
204    CNY
205  }
206  
207  public static class Commander {
208    @SerializedName("operator")
209    public Operator operator;
210  
211    @SerializedName("mchid")
212    public String mchid;
213  }
214  
215  public enum InstructionState {
216    @SerializedName("INSTRUCTION_STATE_PENDING")
217    INSTRUCTION_STATE_PENDING,
218    @SerializedName("INSTRUCTION_STATE_IN_PROGRESS")
219    INSTRUCTION_STATE_IN_PROGRESS,
220    @SerializedName("INSTRUCTION_STATE_CLOSED")
221    INSTRUCTION_STATE_CLOSED,
222    @SerializedName("INSTRUCTION_STATE_SUCCESS")
223    INSTRUCTION_STATE_SUCCESS
224  }
225  
226  public enum Operator {
227    @SerializedName("MERCHANT")
228    MERCHANT
229  }
230  
231}
232

1package main
2
3import (
4	"bytes"
5	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
6	"encoding/json"
7	"fmt"
8	"net/http"
9	"net/url"
10	"strings"
11	"time"
12)
13
14func main() {
15	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
16	config, err := wxpay_utility.CreateMchConfig(
17		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
18		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
19		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
20		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
21		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
22	)
23	if err != nil {
24		fmt.Println(err)
25		return
26	}
27
28	request := &AcceptInstructionRequest{
29		ReceiptId:        wxpay_utility.String("0100011742874700562078230000"),
30		OutInstructionNo: wxpay_utility.String("1200002"),
31		TransferMode:     TRANSFERMODETYPE_TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT.Ptr(),
32		NotifyUrl:        wxpay_utility.String("https://weixin.qq.com"),
33		Receiver: &Receiver{
34			Mchid: wxpay_utility.String("1900001108"),
35		},
36	}
37
38	response, err := AcceptInstruction(config, request)
39	if err != nil {
40		fmt.Printf("请求失败: %+v\n", err)
41		// TODO: 请求失败，根据状态码执行不同的处理
42		return
43	}
44
45	// TODO: 请求成功，继续业务逻辑
46	fmt.Printf("请求成功: %+v\n", response)
47}
48
49func AcceptInstruction(config *wxpay_utility.MchConfig, request *AcceptInstructionRequest) (response *AbnormalFundReceipt, err error) {
50	const (
51		host   = "https://api.mch.weixin.qq.com"
52		method = "POST"
53		path   = "/v3/abnormal-fund-processing/receipts/{receipt_id}/transfer-instructions"
54	)
55
56	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
57	if err != nil {
58		return nil, err
59	}
60	reqUrl.Path = strings.Replace(reqUrl.Path, "{receipt_id}", url.PathEscape(*request.ReceiptId), -1)
61	reqBody, err := json.Marshal(request)
62	if err != nil {
63		return nil, err
64	}
65	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
66	if err != nil {
67		return nil, err
68	}
69	httpRequest.Header.Set("Accept", "application/json")
70	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
71	httpRequest.Header.Set("Content-Type", "application/json")
72	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
73	if err != nil {
74		return nil, err
75	}
76	httpRequest.Header.Set("Authorization", authorization)
77
78	client := &http.Client{}
79	httpResponse, err := client.Do(httpRequest)
80	if err != nil {
81		return nil, err
82	}
83	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
84	if err != nil {
85		return nil, err
86	}
87	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
88		// 2XX 成功，验证应答签名
89		err = wxpay_utility.ValidateResponse(
90			config.WechatPayPublicKeyId(),
91			config.WechatPayPublicKey(),
92			&httpResponse.Header,
93			respBody,
94		)
95		if err != nil {
96			return nil, err
97		}
98		response := &AbnormalFundReceipt{}
99		if err := json.Unmarshal(respBody, response); err != nil {
100			return nil, err
101		}
102
103		return response, nil
104	} else {
105		return nil, wxpay_utility.NewApiException(
106			httpResponse.StatusCode,
107			httpResponse.Header,
108			respBody,
109		)
110	}
111}
112
113type AcceptInstructionRequest struct {
114	ReceiptId        *string           `json:"receipt_id,omitempty"`
115	OutInstructionNo *string           `json:"out_instruction_no,omitempty"`
116	TransferMode     *TransferModeType `json:"transfer_mode,omitempty"`
117	NotifyUrl        *string           `json:"notify_url,omitempty"`
118	Receiver         *Receiver         `json:"receiver,omitempty"`
119}
120
121func (o *AcceptInstructionRequest) MarshalJSON() ([]byte, error) {
122	type Alias AcceptInstructionRequest
123	a := &struct {
124		ReceiptId *string `json:"receipt_id,omitempty"`
125		*Alias
126	}{
127		// 序列化时移除非 Body 字段
128		ReceiptId: nil,
129		Alias:     (*Alias)(o),
130	}
131	return json.Marshal(a)
132}
133
134type AbnormalFundReceipt struct {
135	ProductName    *string       `json:"product_name,omitempty"`
136	ReceiptId      *string       `json:"receipt_id,omitempty"`
137	TransferAmount *Amount       `json:"transfer_amount,omitempty"`
138	ReceiptState   *ReceiptState `json:"receipt_state,omitempty"`
139	CreateTime     *time.Time    `json:"create_time,omitempty"`
140	LastUpdateTime *time.Time    `json:"last_update_time,omitempty"`
141	Instruction    *Instruction  `json:"instruction,omitempty"`
142}
143
144type TransferModeType string
145
146func (e TransferModeType) Ptr() *TransferModeType {
147	return &e
148}
149
150const (
151	TRANSFERMODETYPE_TRANSFER_TO_ORIGINAL_RECEIVE_USER      TransferModeType = "TRANSFER_TO_ORIGINAL_RECEIVE_USER"
152	TRANSFERMODETYPE_TRANSFER_TO_ORIGINAL_RECEIVE_MERCHANT  TransferModeType = "TRANSFER_TO_ORIGINAL_RECEIVE_MERCHANT"
153	TRANSFERMODETYPE_TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT TransferModeType = "TRANSFER_TO_SPECIFIED_RECEIVE_MERCHANT"
154)
155
156type Receiver struct {
157	Mchid *string `json:"mchid,omitempty"`
158}
159
160type Amount struct {
161	Total    *int64    `json:"total,omitempty"`
162	Currency *Currency `json:"currency,omitempty"`
163}
164
165type ReceiptState string
166
167func (e ReceiptState) Ptr() *ReceiptState {
168	return &e
169}
170
171const (
172	RECEIPTSTATE_RECEIPT_STATE_PENDING   ReceiptState = "RECEIPT_STATE_PENDING"
173	RECEIPTSTATE_RECEIPT_STATE_PROGRESS  ReceiptState = "RECEIPT_STATE_PROGRESS"
174	RECEIPTSTATE_RECEIPT_STATE_COMPLETED ReceiptState = "RECEIPT_STATE_COMPLETED"
175)
176
177type Instruction struct {
178	OutInstructionNo *string           `json:"out_instruction_no,omitempty"`
179	Commander        *Commander        `json:"commander,omitempty"`
180	TransferMode     *TransferModeType `json:"transfer_mode,omitempty"`
181	Receiver         *Receiver         `json:"receiver,omitempty"`
182	InstructionState *InstructionState `json:"instruction_state,omitempty"`
183	CreateTime       *time.Time        `json:"create_time,omitempty"`
184	SuccessTime      *time.Time        `json:"success_time,omitempty"`
185	NotifyUrl        *string           `json:"notify_url,omitempty"`
186}
187
188type Currency string
189
190func (e Currency) Ptr() *Currency {
191	return &e
192}
193
194const (
195	CURRENCY_CNY Currency = "CNY"
196)
197
198type Commander struct {
199	Operator *Operator `json:"operator,omitempty"`
200	Mchid    *string   `json:"mchid,omitempty"`
201}
202
203type InstructionState string
204
205func (e InstructionState) Ptr() *InstructionState {
206	return &e
207}
208
209const (
210	INSTRUCTIONSTATE_INSTRUCTION_STATE_PENDING     InstructionState = "INSTRUCTION_STATE_PENDING"
211	INSTRUCTIONSTATE_INSTRUCTION_STATE_IN_PROGRESS InstructionState = "INSTRUCTION_STATE_IN_PROGRESS"
212	INSTRUCTIONSTATE_INSTRUCTION_STATE_CLOSED      InstructionState = "INSTRUCTION_STATE_CLOSED"
213	INSTRUCTIONSTATE_INSTRUCTION_STATE_SUCCESS     InstructionState = "INSTRUCTION_STATE_SUCCESS"
214)
215
216type Operator string
217
218func (e Operator) Ptr() *Operator {
219	return &e
220}
221
222const (
223	OPERATOR_MERCHANT Operator = "MERCHANT"
224)
225