预上传券CODE

1curl -X POST \
2  https://api.mch.weixin.qq.com/brand/marketing/product-coupon/product-coupons/200000001/stocks/123456789/upload-coupon-codes \
3  -H "Authorization: WECHATPAY-BRAND-SHA256-RSA2048 brand_id=\"XXXX\",..." \
4  -H "Accept: application/json" \
5  -H "Wechatpay-Serial: PUB_KEY_ID_XXXX"  \
6  -H "Content-Type: application/json" \
7  -d '{
8    "out_request_no" : "34657_20250101_123456",
9    "code_list" : [
10      "vCode_1234567890"
11    ]
12  }'
13

1package com.java.demo;
2
3import com.java.utils.WXPayBrandUtility; // 引用微信支付工具库，参考：https://pay.weixin.qq.com/doc/brand/4015826861
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 * 预上传券Code
24 */
25public class UploadCouponCodes {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/brand/marketing/product-coupon/product-coupons/{product_coupon_id}/stocks/{stock_id}/upload-coupon-codes";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
32    UploadCouponCodes client = new UploadCouponCodes(
33      "xxxxxxxx",                    // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
34      "1DDE55AD98Exxxxxxxxxx",         // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
35      "/path/to/apiclient_key.pem",     // 品牌API证书私钥文件路径，本地文件路径
36      "PUB_KEY_ID_xxxxxxxxxxxxx",      // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
37      "/path/to/wxp_pub.pem"           // 微信支付公钥文件路径，本地文件路径
38    );
39
40    UploadCouponCodesRequest request = new UploadCouponCodesRequest();
41    request.productCouponId = "200000001";
42    request.stockId = "123456789";
43    request.outRequestNo = "34657_20250101_123456";
44    request.codeList = new ArrayList<>();
45    {
46      request.codeList.add("vCode_1234567890");
47    };
48    try {
49      UploadCouponCodesResponse response = client.run(request);
50        // TODO: 请求成功，继续业务逻辑
51        System.out.println(response);
52    } catch (WXPayBrandUtility.ApiException e) {
53        // TODO: 请求失败，根据状态码执行不同的逻辑
54        e.printStackTrace();
55    }
56  }
57
58  public UploadCouponCodesResponse run(UploadCouponCodesRequest request) {
59    String uri = PATH;
60    uri = uri.replace("{product_coupon_id}", WXPayBrandUtility.urlEncode(request.productCouponId));
61    uri = uri.replace("{stock_id}", WXPayBrandUtility.urlEncode(request.stockId));
62    String reqBody = WXPayBrandUtility.toJson(request);
63
64    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
65    reqBuilder.addHeader("Accept", "application/json");
66    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
67    reqBuilder.addHeader("Authorization", WXPayBrandUtility.buildAuthorization(brand_id, certificateSerialNo,privateKey, METHOD, uri, reqBody));
68    reqBuilder.addHeader("Content-Type", "application/json");
69    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
70    reqBuilder.method(METHOD, requestBody);
71    Request httpRequest = reqBuilder.build();
72
73    // 发送HTTP请求
74    OkHttpClient client = new OkHttpClient.Builder().build();
75    try (Response httpResponse = client.newCall(httpRequest).execute()) {
76      String respBody = WXPayBrandUtility.extractBody(httpResponse);
77      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
78        // 2XX 成功，验证应答签名
79        WXPayBrandUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
80            httpResponse.headers(), respBody);
81
82        // 从HTTP应答报文构建返回数据
83        return WXPayBrandUtility.fromJson(respBody, UploadCouponCodesResponse.class);
84      } else {
85        throw new WXPayBrandUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
86      }
87    } catch (IOException e) {
88      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
89    }
90  }
91
92  private final String brand_id;
93  private final String certificateSerialNo;
94  private final PrivateKey privateKey;
95  private final String wechatPayPublicKeyId;
96  private final PublicKey wechatPayPublicKey;
97
98  public UploadCouponCodes(String brand_id, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
99    this.brand_id = brand_id;
100    this.certificateSerialNo = certificateSerialNo;
101    this.privateKey = WXPayBrandUtility.loadPrivateKeyFromPath(privateKeyFilePath);
102    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
103    this.wechatPayPublicKey = WXPayBrandUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
104  }
105
106  public static class UploadCouponCodesRequest {
107    @SerializedName("out_request_no")
108    public String outRequestNo;
109  
110    @SerializedName("product_coupon_id")
111    @Expose(serialize = false)
112    public String productCouponId;
113  
114    @SerializedName("stock_id")
115    @Expose(serialize = false)
116    public String stockId;
117  
118    @SerializedName("code_list")
119    public List<String> codeList = new ArrayList<String>();
120  }
121  
122  public static class UploadCouponCodesResponse {
123    @SerializedName("total_count")
124    public Long totalCount;
125  
126    @SerializedName("success_code_list")
127    public List<String> successCodeList;
128  
129    @SerializedName("failed_code_list")
130    public List<FailedCouponCodeInfo> failedCodeList;
131  
132    @SerializedName("already_exist_code_list")
133    public List<String> alreadyExistCodeList;
134  
135    @SerializedName("duplicate_code_list")
136    public List<String> duplicateCodeList;
137  }
138  
139  public static class FailedCouponCodeInfo {
140    @SerializedName("coupon_code")
141    public String couponCode;
142  
143    @SerializedName("code")
144    public String code;
145  
146    @SerializedName("message")
147    public String message;
148  }
149  
150}
151

1package main
2
3import (
4	"bytes"
5	"demo/wxpay_brand_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/brand/4015826866
6	"encoding/json"
7	"fmt"
8	"net/http"
9	"net/url"
10	"strings"
11)
12
13func main() {
14	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
15	config, err := wxpay_brand_utility.CreateBrandConfig(
16		"xxxxxxxx",                   // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
17		"1DDE55AD98Exxxxxxxxxx",      // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
18		"/path/to/apiclient_key.pem", // 品牌API证书私钥文件路径，本地文件路径
19		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
20		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
21	)
22	if err != nil {
23		fmt.Println(err)
24		return
25	}
26
27	request := &UploadCouponCodesRequest{
28		ProductCouponId: wxpay_brand_utility.String("200000001"),
29		StockId:         wxpay_brand_utility.String("123456789"),
30		OutRequestNo:    wxpay_brand_utility.String("34657_20250101_123456"),
31		CodeList:        []string{"vCode_1234567890"},
32	}
33
34	response, err := UploadCouponCodes(config, request)
35	if err != nil {
36		fmt.Printf("请求失败: %+v\n", err)
37		// TODO: 请求失败，根据状态码执行不同的处理
38		return
39	}
40
41	// TODO: 请求成功，继续业务逻辑
42	fmt.Printf("请求成功: %+v\n", response)
43}
44
45func UploadCouponCodes(config *wxpay_brand_utility.BrandConfig, request *UploadCouponCodesRequest) (response *UploadCouponCodesResponse, err error) {
46	const (
47		host   = "https://api.mch.weixin.qq.com"
48		method = "POST"
49		path   = "/brand/marketing/product-coupon/product-coupons/{product_coupon_id}/stocks/{stock_id}/upload-coupon-codes"
50	)
51
52	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
53	if err != nil {
54		return nil, err
55	}
56	reqUrl.Path = strings.Replace(reqUrl.Path, "{product_coupon_id}", url.PathEscape(*request.ProductCouponId), -1)
57	reqUrl.Path = strings.Replace(reqUrl.Path, "{stock_id}", url.PathEscape(*request.StockId), -1)
58	reqBody, err := json.Marshal(request)
59	if err != nil {
60		return nil, err
61	}
62	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
63	if err != nil {
64		return nil, err
65	}
66	httpRequest.Header.Set("Accept", "application/json")
67	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
68	httpRequest.Header.Set("Content-Type", "application/json")
69	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
70	if err != nil {
71		return nil, err
72	}
73	httpRequest.Header.Set("Authorization", authorization)
74
75	client := &http.Client{}
76	httpResponse, err := client.Do(httpRequest)
77	if err != nil {
78		return nil, err
79	}
80	respBody, err := wxpay_brand_utility.ExtractResponseBody(httpResponse)
81	if err != nil {
82		return nil, err
83	}
84	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
85		// 2XX 成功，验证应答签名
86		err = wxpay_brand_utility.ValidateResponse(
87			config.WechatPayPublicKeyId(),
88			config.WechatPayPublicKey(),
89			&httpResponse.Header,
90			respBody,
91		)
92		if err != nil {
93			return nil, err
94		}
95		response := &UploadCouponCodesResponse{}
96		if err := json.Unmarshal(respBody, response); err != nil {
97			return nil, err
98		}
99
100		return response, nil
101	} else {
102		return nil, wxpay_brand_utility.NewApiException(
103			httpResponse.StatusCode,
104			httpResponse.Header,
105			respBody,
106		)
107	}
108}
109
110type UploadCouponCodesRequest struct {
111	OutRequestNo    *string  `json:"out_request_no,omitempty"`
112	ProductCouponId *string  `json:"product_coupon_id,omitempty"`
113	StockId         *string  `json:"stock_id,omitempty"`
114	CodeList        []string `json:"code_list,omitempty"`
115}
116
117func (o *UploadCouponCodesRequest) MarshalJSON() ([]byte, error) {
118	type Alias UploadCouponCodesRequest
119	a := &struct {
120		ProductCouponId *string `json:"product_coupon_id,omitempty"`
121		StockId         *string `json:"stock_id,omitempty"`
122		*Alias
123	}{
124		// 序列化时移除非 Body 字段
125		ProductCouponId: nil,
126		StockId:         nil,
127		Alias:           (*Alias)(o),
128	}
129	return json.Marshal(a)
130}
131
132type UploadCouponCodesResponse struct {
133	TotalCount           *int64                 `json:"total_count,omitempty"`
134	SuccessCodeList      []string               `json:"success_code_list,omitempty"`
135	FailedCodeList       []FailedCouponCodeInfo `json:"failed_code_list,omitempty"`
136	AlreadyExistCodeList []string               `json:"already_exist_code_list,omitempty"`
137	DuplicateCodeList    []string               `json:"duplicate_code_list,omitempty"`
138}
139
140type FailedCouponCodeInfo struct {
141	CouponCode *string `json:"coupon_code,omitempty"`
142	Code       *string `json:"code,omitempty"`
143	Message    *string `json:"message,omitempty"`
144}
145