失效商品券

1curl -X POST \
2  https://api.mch.weixin.qq.com/brand/marketing/product-coupon/product-coupons/200000001/deactivate \
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    "deactivate_reason" : "批次信息有误，重新创建"
10  }'
11

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 * 失效商品券
24 */
25public class DeactivateProductCoupon {
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}/deactivate";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
32    DeactivateProductCoupon client = new DeactivateProductCoupon(
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    DeactivateProductCouponRequest request = new DeactivateProductCouponRequest();
41    request.productCouponId = "200000001";
42    request.outRequestNo = "34657_20250101_123456";
43    request.deactivateReason = "批次信息有误，重新创建";
44    try {
45      ProductCouponEntity response = client.run(request);
46        // TODO: 请求成功，继续业务逻辑
47        System.out.println(response);
48    } catch (WXPayBrandUtility.ApiException e) {
49        // TODO: 请求失败，根据状态码执行不同的逻辑
50        e.printStackTrace();
51    }
52  }
53
54  public ProductCouponEntity run(DeactivateProductCouponRequest request) {
55    String uri = PATH;
56    uri = uri.replace("{product_coupon_id}", WXPayBrandUtility.urlEncode(request.productCouponId));
57    String reqBody = WXPayBrandUtility.toJson(request);
58
59    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
60    reqBuilder.addHeader("Accept", "application/json");
61    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
62    reqBuilder.addHeader("Authorization", WXPayBrandUtility.buildAuthorization(brand_id, certificateSerialNo,privateKey, METHOD, uri, reqBody));
63    reqBuilder.addHeader("Content-Type", "application/json");
64    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
65    reqBuilder.method(METHOD, requestBody);
66    Request httpRequest = reqBuilder.build();
67
68    // 发送HTTP请求
69    OkHttpClient client = new OkHttpClient.Builder().build();
70    try (Response httpResponse = client.newCall(httpRequest).execute()) {
71      String respBody = WXPayBrandUtility.extractBody(httpResponse);
72      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
73        // 2XX 成功，验证应答签名
74        WXPayBrandUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
75            httpResponse.headers(), respBody);
76
77        // 从HTTP应答报文构建返回数据
78        return WXPayBrandUtility.fromJson(respBody, ProductCouponEntity.class);
79      } else {
80        throw new WXPayBrandUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
81      }
82    } catch (IOException e) {
83      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
84    }
85  }
86
87  private final String brand_id;
88  private final String certificateSerialNo;
89  private final PrivateKey privateKey;
90  private final String wechatPayPublicKeyId;
91  private final PublicKey wechatPayPublicKey;
92
93  public DeactivateProductCoupon(String brand_id, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
94    this.brand_id = brand_id;
95    this.certificateSerialNo = certificateSerialNo;
96    this.privateKey = WXPayBrandUtility.loadPrivateKeyFromPath(privateKeyFilePath);
97    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
98    this.wechatPayPublicKey = WXPayBrandUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
99  }
100
101  public static class DeactivateProductCouponRequest {
102    @SerializedName("out_request_no")
103    public String outRequestNo;
104  
105    @SerializedName("product_coupon_id")
106    @Expose(serialize = false)
107    public String productCouponId;
108  
109    @SerializedName("deactivate_reason")
110    public String deactivateReason;
111  }
112  
113  public static class ProductCouponEntity {
114    @SerializedName("product_coupon_id")
115    public String productCouponId;
116  
117    @SerializedName("scope")
118    public ProductCouponScope scope;
119  
120    @SerializedName("type")
121    public ProductCouponType type;
122  
123    @SerializedName("usage_mode")
124    public UsageMode usageMode;
125  
126    @SerializedName("single_usage_info")
127    public SingleUsageInfo singleUsageInfo;
128  
129    @SerializedName("sequential_usage_info")
130    public SequentialUsageInfo sequentialUsageInfo;
131  
132    @SerializedName("display_info")
133    public ProductCouponDisplayInfo displayInfo;
134  
135    @SerializedName("out_product_no")
136    public String outProductNo;
137  
138    @SerializedName("state")
139    public ProductCouponState state;
140  
141    @SerializedName("deactivate_request_no")
142    public String deactivateRequestNo;
143  
144    @SerializedName("deactivate_time")
145    public String deactivateTime;
146  
147    @SerializedName("deactivate_reason")
148    public String deactivateReason;
149  }
150  
151  public enum ProductCouponScope {
152    @SerializedName("ALL")
153    ALL,
154    @SerializedName("SINGLE")
155    SINGLE
156  }
157  
158  public enum ProductCouponType {
159    @SerializedName("NORMAL")
160    NORMAL,
161    @SerializedName("DISCOUNT")
162    DISCOUNT,
163    @SerializedName("EXCHANGE")
164    EXCHANGE
165  }
166  
167  public enum UsageMode {
168    @SerializedName("SINGLE")
169    SINGLE,
170    @SerializedName("SEQUENTIAL")
171    SEQUENTIAL
172  }
173  
174  public static class SingleUsageInfo {
175    @SerializedName("normal_coupon")
176    public NormalCouponUsageRule normalCoupon;
177  
178    @SerializedName("discount_coupon")
179    public DiscountCouponUsageRule discountCoupon;
180  }
181  
182  public static class SequentialUsageInfo {
183    @SerializedName("type")
184    public SequentialUsageType type;
185  
186    @SerializedName("count")
187    public Long count;
188  
189    @SerializedName("available_days")
190    public Long availableDays;
191  
192    @SerializedName("interval_days")
193    public Long intervalDays;
194  }
195  
196  public static class ProductCouponDisplayInfo {
197    @SerializedName("name")
198    public String name;
199  
200    @SerializedName("image_url")
201    public String imageUrl;
202  
203    @SerializedName("background_url")
204    public String backgroundUrl;
205  
206    @SerializedName("detail_image_url_list")
207    public List<String> detailImageUrlList;
208  
209    @SerializedName("original_price")
210    public Long originalPrice;
211  
212    @SerializedName("combo_package_list")
213    public List<ComboPackage> comboPackageList;
214  }
215  
216  public enum ProductCouponState {
217    @SerializedName("AUDITING")
218    AUDITING,
219    @SerializedName("EFFECTIVE")
220    EFFECTIVE,
221    @SerializedName("DEACTIVATED")
222    DEACTIVATED
223  }
224  
225  public static class NormalCouponUsageRule {
226    @SerializedName("threshold")
227    public Long threshold;
228  
229    @SerializedName("discount_amount")
230    public Long discountAmount;
231  }
232  
233  public static class DiscountCouponUsageRule {
234    @SerializedName("threshold")
235    public Long threshold;
236  
237    @SerializedName("percent_off")
238    public Long percentOff;
239  }
240  
241  public enum SequentialUsageType {
242    @SerializedName("INCREMENTAL")
243    INCREMENTAL,
244    @SerializedName("EQUAL")
245    EQUAL
246  }
247  
248  public static class ComboPackage {
249    @SerializedName("name")
250    public String name;
251  
252    @SerializedName("pick_count")
253    public Long pickCount;
254  
255    @SerializedName("choice_list")
256    public List<ComboPackageChoice> choiceList = new ArrayList<ComboPackageChoice>();
257  }
258  
259  public static class ComboPackageChoice {
260    @SerializedName("name")
261    public String name;
262  
263    @SerializedName("price")
264    public Long price;
265  
266    @SerializedName("count")
267    public Long count;
268  
269    @SerializedName("image_url")
270    public String imageUrl;
271  
272    @SerializedName("mini_program_appid")
273    public String miniProgramAppid;
274  
275    @SerializedName("mini_program_path")
276    public String miniProgramPath;
277  }
278  
279}
280

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 := &DeactivateProductCouponRequest{
28		ProductCouponId:  wxpay_brand_utility.String("200000001"),
29		OutRequestNo:     wxpay_brand_utility.String("34657_20250101_123456"),
30		DeactivateReason: wxpay_brand_utility.String("批次信息有误，重新创建"),
31	}
32
33	response, err := DeactivateProductCoupon(config, request)
34	if err != nil {
35		fmt.Printf("请求失败: %+v\n", err)
36		// TODO: 请求失败，根据状态码执行不同的处理
37		return
38	}
39
40	// TODO: 请求成功，继续业务逻辑
41	fmt.Printf("请求成功: %+v\n", response)
42}
43
44func DeactivateProductCoupon(config *wxpay_brand_utility.BrandConfig, request *DeactivateProductCouponRequest) (response *ProductCouponEntity, err error) {
45	const (
46		host   = "https://api.mch.weixin.qq.com"
47		method = "POST"
48		path   = "/brand/marketing/product-coupon/product-coupons/{product_coupon_id}/deactivate"
49	)
50
51	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
52	if err != nil {
53		return nil, err
54	}
55	reqUrl.Path = strings.Replace(reqUrl.Path, "{product_coupon_id}", url.PathEscape(*request.ProductCouponId), -1)
56	reqBody, err := json.Marshal(request)
57	if err != nil {
58		return nil, err
59	}
60	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
61	if err != nil {
62		return nil, err
63	}
64	httpRequest.Header.Set("Accept", "application/json")
65	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
66	httpRequest.Header.Set("Content-Type", "application/json")
67	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
68	if err != nil {
69		return nil, err
70	}
71	httpRequest.Header.Set("Authorization", authorization)
72
73	client := &http.Client{}
74	httpResponse, err := client.Do(httpRequest)
75	if err != nil {
76		return nil, err
77	}
78	respBody, err := wxpay_brand_utility.ExtractResponseBody(httpResponse)
79	if err != nil {
80		return nil, err
81	}
82	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
83		// 2XX 成功，验证应答签名
84		err = wxpay_brand_utility.ValidateResponse(
85			config.WechatPayPublicKeyId(),
86			config.WechatPayPublicKey(),
87			&httpResponse.Header,
88			respBody,
89		)
90		if err != nil {
91			return nil, err
92		}
93		response := &ProductCouponEntity{}
94		if err := json.Unmarshal(respBody, response); err != nil {
95			return nil, err
96		}
97
98		return response, nil
99	} else {
100		return nil, wxpay_brand_utility.NewApiException(
101			httpResponse.StatusCode,
102			httpResponse.Header,
103			respBody,
104		)
105	}
106}
107
108type DeactivateProductCouponRequest struct {
109	OutRequestNo     *string `json:"out_request_no,omitempty"`
110	ProductCouponId  *string `json:"product_coupon_id,omitempty"`
111	DeactivateReason *string `json:"deactivate_reason,omitempty"`
112}
113
114func (o *DeactivateProductCouponRequest) MarshalJSON() ([]byte, error) {
115	type Alias DeactivateProductCouponRequest
116	a := &struct {
117		ProductCouponId *string `json:"product_coupon_id,omitempty"`
118		*Alias
119	}{
120		// 序列化时移除非 Body 字段
121		ProductCouponId: nil,
122		Alias:           (*Alias)(o),
123	}
124	return json.Marshal(a)
125}
126
127type ProductCouponEntity struct {
128	ProductCouponId     *string                   `json:"product_coupon_id,omitempty"`
129	Scope               *ProductCouponScope       `json:"scope,omitempty"`
130	Type                *ProductCouponType        `json:"type,omitempty"`
131	UsageMode           *UsageMode                `json:"usage_mode,omitempty"`
132	SingleUsageInfo     *SingleUsageInfo          `json:"single_usage_info,omitempty"`
133	SequentialUsageInfo *SequentialUsageInfo      `json:"sequential_usage_info,omitempty"`
134	DisplayInfo         *ProductCouponDisplayInfo `json:"display_info,omitempty"`
135	OutProductNo        *string                   `json:"out_product_no,omitempty"`
136	State               *ProductCouponState       `json:"state,omitempty"`
137	DeactivateRequestNo *string                   `json:"deactivate_request_no,omitempty"`
138	DeactivateTime      *string                   `json:"deactivate_time,omitempty"`
139	DeactivateReason    *string                   `json:"deactivate_reason,omitempty"`
140}
141
142type ProductCouponScope string
143
144func (e ProductCouponScope) Ptr() *ProductCouponScope {
145	return &e
146}
147
148const (
149	PRODUCTCOUPONSCOPE_ALL    ProductCouponScope = "ALL"
150	PRODUCTCOUPONSCOPE_SINGLE ProductCouponScope = "SINGLE"
151)
152
153type ProductCouponType string
154
155func (e ProductCouponType) Ptr() *ProductCouponType {
156	return &e
157}
158
159const (
160	PRODUCTCOUPONTYPE_NORMAL   ProductCouponType = "NORMAL"
161	PRODUCTCOUPONTYPE_DISCOUNT ProductCouponType = "DISCOUNT"
162	PRODUCTCOUPONTYPE_EXCHANGE ProductCouponType = "EXCHANGE"
163)
164
165type UsageMode string
166
167func (e UsageMode) Ptr() *UsageMode {
168	return &e
169}
170
171const (
172	USAGEMODE_SINGLE     UsageMode = "SINGLE"
173	USAGEMODE_SEQUENTIAL UsageMode = "SEQUENTIAL"
174)
175
176type SingleUsageInfo struct {
177	NormalCoupon   *NormalCouponUsageRule   `json:"normal_coupon,omitempty"`
178	DiscountCoupon *DiscountCouponUsageRule `json:"discount_coupon,omitempty"`
179}
180
181type SequentialUsageInfo struct {
182	Type          *SequentialUsageType `json:"type,omitempty"`
183	Count         *int64               `json:"count,omitempty"`
184	AvailableDays *int64               `json:"available_days,omitempty"`
185	IntervalDays  *int64               `json:"interval_days,omitempty"`
186}
187
188type ProductCouponDisplayInfo struct {
189	Name               *string        `json:"name,omitempty"`
190	ImageUrl           *string        `json:"image_url,omitempty"`
191	BackgroundUrl      *string        `json:"background_url,omitempty"`
192	DetailImageUrlList []string       `json:"detail_image_url_list,omitempty"`
193	OriginalPrice      *int64         `json:"original_price,omitempty"`
194	ComboPackageList   []ComboPackage `json:"combo_package_list,omitempty"`
195}
196
197type ProductCouponState string
198
199func (e ProductCouponState) Ptr() *ProductCouponState {
200	return &e
201}
202
203const (
204	PRODUCTCOUPONSTATE_AUDITING    ProductCouponState = "AUDITING"
205	PRODUCTCOUPONSTATE_EFFECTIVE   ProductCouponState = "EFFECTIVE"
206	PRODUCTCOUPONSTATE_DEACTIVATED ProductCouponState = "DEACTIVATED"
207)
208
209type NormalCouponUsageRule struct {
210	Threshold      *int64 `json:"threshold,omitempty"`
211	DiscountAmount *int64 `json:"discount_amount,omitempty"`
212}
213
214type DiscountCouponUsageRule struct {
215	Threshold  *int64 `json:"threshold,omitempty"`
216	PercentOff *int64 `json:"percent_off,omitempty"`
217}
218
219type SequentialUsageType string
220
221func (e SequentialUsageType) Ptr() *SequentialUsageType {
222	return &e
223}
224
225const (
226	SEQUENTIALUSAGETYPE_INCREMENTAL SequentialUsageType = "INCREMENTAL"
227	SEQUENTIALUSAGETYPE_EQUAL       SequentialUsageType = "EQUAL"
228)
229
230type ComboPackage struct {
231	Name       *string              `json:"name,omitempty"`
232	PickCount  *int64               `json:"pick_count,omitempty"`
233	ChoiceList []ComboPackageChoice `json:"choice_list,omitempty"`
234}
235
236type ComboPackageChoice struct {
237	Name             *string `json:"name,omitempty"`
238	Price            *int64  `json:"price,omitempty"`
239	Count            *int64  `json:"count,omitempty"`
240	ImageUrl         *string `json:"image_url,omitempty"`
241	MiniProgramAppid *string `json:"mini_program_appid,omitempty"`
242	MiniProgramPath  *string `json:"mini_program_path,omitempty"`
243}
244