添加商品券批次

1curl -X POST \
2  https://api.mch.weixin.qq.com/brand/marketing/product-coupon/product-coupons/1000000013/stocks \
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    "stock" : {
9      "remark" : "8月工作日有效批次",
10      "coupon_code_mode" : "UPLOAD",
11      "stock_send_rule" : {
12        "max_count" : 10000000,
13        "max_count_per_user" : 1
14      },
15      "single_usage_rule" : {
16        "coupon_available_period" : {
17          "available_begin_time" : "2025-08-01T00:00:00+08:00",
18          "available_end_time" : "2025-08-31T23:59:59+08:00",
19          "available_days" : 30,
20          "weekly_available_period" : {
21            "day_list" : [
22              "MONDAY",
23              "TUESDAY",
24              "WEDNESDAY",
25              "THURSDAY",
26              "FRIDAY"
27            ]
28          }
29        }
30      },
31      "usage_rule_display_info" : {
32        "coupon_usage_method_list" : [
33          "OFFLINE",
34          "MINI_PROGRAM",
35          "PAYMENT_CODE"
36        ],
37        "mini_program_appid" : "wx1234567890",
38        "mini_program_path" : "/pages/index/product",
39        "usage_description" : "工作日可用",
40        "coupon_available_store_info" : {
41          "description" : "所有门店可用，可使用小程序查看门店列表",
42          "mini_program_appid" : "wx1234567890",
43          "mini_program_path" : "/pages/index/store-list"
44        }
45      },
46      "coupon_display_info" : {
47        "code_display_mode" : "QRCODE",
48        "background_color" : "Color010",
49        "entrance_mini_program" : {
50          "appid" : "wx1234567890",
51          "path" : "/pages/index/product",
52          "entrance_wording" : "欢迎选购",
53          "guidance_wording" : "获取更多优惠"
54        },
55        "entrance_official_account" : {
56          "appid" : "wx1234567890"
57        },
58        "entrance_finder" : {
59          "finder_id" : "gh_12345678",
60          "finder_video_id" : "UDFsdf24df34dD456Hdf34",
61          "finder_video_cover_image_url" : "https://wxpaylogo.qpic.cn/wxpaylogo/xxxxx/xxx"
62        }
63      },
64      "store_scope" : "NONE",
65      "notify_config" : {
66        "notify_appid" : "wx4fd12345678"
67      }
68    },
69    "out_request_no" : "12345_20250101_A3489"
70  }'
71

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 CreateStock {
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";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
32    CreateStock client = new CreateStock(
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    CreateStockRequest request = new CreateStockRequest();
41    request.outRequestNo = "12345_20250101_A3489";
42    request.productCouponId = "1000000013";
43    request.stock = new StockForCreate();
44    request.stock.remark = "8月工作日有效批次";
45    request.stock.couponCodeMode = CouponCodeMode.UPLOAD;
46    request.stock.stockSendRule = new StockSendRule();
47    request.stock.stockSendRule.maxCount = 10000000L;
48    request.stock.stockSendRule.maxCountPerUser = 1L;
49    request.stock.singleUsageRule = new SingleUsageRule();
50    request.stock.singleUsageRule.couponAvailablePeriod = new CouponAvailablePeriod();
51    request.stock.singleUsageRule.couponAvailablePeriod.availableBeginTime = "2025-08-01T00:00:00+08:00";
52    request.stock.singleUsageRule.couponAvailablePeriod.availableEndTime = "2025-08-31T23:59:59+08:00";
53    request.stock.singleUsageRule.couponAvailablePeriod.availableDays = 30L;
54    request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod = new FixedWeekPeriod();
55    request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod.dayList = new ArrayList<>();
56    {
57      request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod.dayList.add(WeekEnum.MONDAY);
58      request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod.dayList.add(WeekEnum.TUESDAY);
59      request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod.dayList.add(WeekEnum.WEDNESDAY);
60      request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod.dayList.add(WeekEnum.THURSDAY);
61      request.stock.singleUsageRule.couponAvailablePeriod.weeklyAvailablePeriod.dayList.add(WeekEnum.FRIDAY);
62    };
63    request.stock.usageRuleDisplayInfo = new UsageRuleDisplayInfo();
64    request.stock.usageRuleDisplayInfo.couponUsageMethodList = new ArrayList<>();
65    {
66      request.stock.usageRuleDisplayInfo.couponUsageMethodList.add(CouponUsageMethod.OFFLINE);
67      request.stock.usageRuleDisplayInfo.couponUsageMethodList.add(CouponUsageMethod.MINI_PROGRAM);
68      request.stock.usageRuleDisplayInfo.couponUsageMethodList.add(CouponUsageMethod.PAYMENT_CODE);
69    };
70    request.stock.usageRuleDisplayInfo.miniProgramAppid = "wx1234567890";
71    request.stock.usageRuleDisplayInfo.miniProgramPath = "/pages/index/product";
72    request.stock.usageRuleDisplayInfo.usageDescription = "工作日可用";
73    request.stock.usageRuleDisplayInfo.couponAvailableStoreInfo = new CouponAvailableStoreInfo();
74    request.stock.usageRuleDisplayInfo.couponAvailableStoreInfo.description = "所有门店可用，可使用小程序查看门店列表";
75    request.stock.usageRuleDisplayInfo.couponAvailableStoreInfo.miniProgramAppid = "wx1234567890";
76    request.stock.usageRuleDisplayInfo.couponAvailableStoreInfo.miniProgramPath = "/pages/index/store-list";
77    request.stock.couponDisplayInfo = new CouponDisplayInfo();
78    request.stock.couponDisplayInfo.codeDisplayMode = CouponCodeDisplayMode.QRCODE;
79    request.stock.couponDisplayInfo.backgroundColor = "Color010";
80    request.stock.couponDisplayInfo.entranceMiniProgram = new EntranceMiniProgram();
81    request.stock.couponDisplayInfo.entranceMiniProgram.appid = "wx1234567890";
82    request.stock.couponDisplayInfo.entranceMiniProgram.path = "/pages/index/product";
83    request.stock.couponDisplayInfo.entranceMiniProgram.entranceWording = "欢迎选购";
84    request.stock.couponDisplayInfo.entranceMiniProgram.guidanceWording = "获取更多优惠";
85    request.stock.couponDisplayInfo.entranceOfficialAccount = new EntranceOfficialAccount();
86    request.stock.couponDisplayInfo.entranceOfficialAccount.appid = "wx1234567890";
87    request.stock.couponDisplayInfo.entranceFinder = new EntranceFinder();
88    request.stock.couponDisplayInfo.entranceFinder.finderId = "gh_12345678";
89    request.stock.couponDisplayInfo.entranceFinder.finderVideoId = "UDFsdf24df34dD456Hdf34";
90    request.stock.couponDisplayInfo.entranceFinder.finderVideoCoverImageUrl = "https://wxpaylogo.qpic.cn/wxpaylogo/xxxxx/xxx";
91    request.stock.notifyConfig = new NotifyConfig();
92    request.stock.notifyConfig.notifyAppid = "wx4fd12345678";
93    request.stock.storeScope = StockStoreScope.NONE;
94    try {
95      StockEntity response = client.run(request);
96        // TODO: 请求成功，继续业务逻辑
97        System.out.println(response);
98    } catch (WXPayBrandUtility.ApiException e) {
99        // TODO: 请求失败，根据状态码执行不同的逻辑
100        e.printStackTrace();
101    }
102  }
103
104  public StockEntity run(CreateStockRequest request) {
105    String uri = PATH;
106    uri = uri.replace("{product_coupon_id}", WXPayBrandUtility.urlEncode(request.productCouponId));
107    String reqBody = WXPayBrandUtility.toJson(request);
108
109    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
110    reqBuilder.addHeader("Accept", "application/json");
111    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
112    reqBuilder.addHeader("Authorization", WXPayBrandUtility.buildAuthorization(brand_id, certificateSerialNo,privateKey, METHOD, uri, reqBody));
113    reqBuilder.addHeader("Content-Type", "application/json");
114    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
115    reqBuilder.method(METHOD, requestBody);
116    Request httpRequest = reqBuilder.build();
117
118    // 发送HTTP请求
119    OkHttpClient client = new OkHttpClient.Builder().build();
120    try (Response httpResponse = client.newCall(httpRequest).execute()) {
121      String respBody = WXPayBrandUtility.extractBody(httpResponse);
122      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
123        // 2XX 成功，验证应答签名
124        WXPayBrandUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
125            httpResponse.headers(), respBody);
126
127        // 从HTTP应答报文构建返回数据
128        return WXPayBrandUtility.fromJson(respBody, StockEntity.class);
129      } else {
130        throw new WXPayBrandUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
131      }
132    } catch (IOException e) {
133      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
134    }
135  }
136
137  private final String brand_id;
138  private final String certificateSerialNo;
139  private final PrivateKey privateKey;
140  private final String wechatPayPublicKeyId;
141  private final PublicKey wechatPayPublicKey;
142
143  public CreateStock(String brand_id, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
144    this.brand_id = brand_id;
145    this.certificateSerialNo = certificateSerialNo;
146    this.privateKey = WXPayBrandUtility.loadPrivateKeyFromPath(privateKeyFilePath);
147    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
148    this.wechatPayPublicKey = WXPayBrandUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
149  }
150
151  public static class CreateStockRequest {
152    @SerializedName("out_request_no")
153    public String outRequestNo;
154  
155    @SerializedName("product_coupon_id")
156    @Expose(serialize = false)
157    public String productCouponId;
158  
159    @SerializedName("stock")
160    public StockForCreate stock;
161  }
162  
163  public static class StockEntity {
164    @SerializedName("product_coupon_id")
165    public String productCouponId;
166  
167    @SerializedName("stock_id")
168    public String stockId;
169  
170    @SerializedName("remark")
171    public String remark;
172  
173    @SerializedName("coupon_code_mode")
174    public CouponCodeMode couponCodeMode;
175  
176    @SerializedName("coupon_code_count_info")
177    public CouponCodeCountInfo couponCodeCountInfo;
178  
179    @SerializedName("stock_send_rule")
180    public StockSendRule stockSendRule;
181  
182    @SerializedName("single_usage_rule")
183    public SingleUsageRule singleUsageRule;
184  
185    @SerializedName("usage_rule_display_info")
186    public UsageRuleDisplayInfo usageRuleDisplayInfo;
187  
188    @SerializedName("coupon_display_info")
189    public CouponDisplayInfo couponDisplayInfo;
190  
191    @SerializedName("notify_config")
192    public NotifyConfig notifyConfig;
193  
194    @SerializedName("store_scope")
195    public StockStoreScope storeScope;
196  
197    @SerializedName("sent_count_info")
198    public StockSentCountInfo sentCountInfo;
199  
200    @SerializedName("state")
201    public StockState state;
202  
203    @SerializedName("deactivate_request_no")
204    public String deactivateRequestNo;
205  
206    @SerializedName("deactivate_time")
207    public String deactivateTime;
208  
209    @SerializedName("deactivate_reason")
210    public String deactivateReason;
211  }
212  
213  public static class StockForCreate {
214    @SerializedName("remark")
215    public String remark;
216  
217    @SerializedName("coupon_code_mode")
218    public CouponCodeMode couponCodeMode;
219  
220    @SerializedName("stock_send_rule")
221    public StockSendRule stockSendRule;
222  
223    @SerializedName("single_usage_rule")
224    public SingleUsageRule singleUsageRule;
225  
226    @SerializedName("usage_rule_display_info")
227    public UsageRuleDisplayInfo usageRuleDisplayInfo;
228  
229    @SerializedName("coupon_display_info")
230    public CouponDisplayInfo couponDisplayInfo;
231  
232    @SerializedName("notify_config")
233    public NotifyConfig notifyConfig;
234  
235    @SerializedName("store_scope")
236    public StockStoreScope storeScope;
237  }
238  
239  public enum CouponCodeMode {
240    @SerializedName("WECHATPAY")
241    WECHATPAY,
242    @SerializedName("UPLOAD")
243    UPLOAD,
244    @SerializedName("API_ASSIGN")
245    API_ASSIGN
246  }
247  
248  public static class CouponCodeCountInfo {
249    @SerializedName("total_count")
250    public Long totalCount;
251  
252    @SerializedName("available_count")
253    public Long availableCount;
254  }
255  
256  public static class StockSendRule {
257    @SerializedName("max_count")
258    public Long maxCount;
259  
260    @SerializedName("max_count_per_day")
261    public Long maxCountPerDay;
262  
263    @SerializedName("max_count_per_user")
264    public Long maxCountPerUser;
265  }
266  
267  public static class SingleUsageRule {
268    @SerializedName("coupon_available_period")
269    public CouponAvailablePeriod couponAvailablePeriod;
270  
271    @SerializedName("normal_coupon")
272    public NormalCouponUsageRule normalCoupon;
273  
274    @SerializedName("discount_coupon")
275    public DiscountCouponUsageRule discountCoupon;
276  
277    @SerializedName("exchange_coupon")
278    public ExchangeCouponUsageRule exchangeCoupon;
279  }
280  
281  public static class UsageRuleDisplayInfo {
282    @SerializedName("coupon_usage_method_list")
283    public List<CouponUsageMethod> couponUsageMethodList = new ArrayList<CouponUsageMethod>();
284  
285    @SerializedName("mini_program_appid")
286    public String miniProgramAppid;
287  
288    @SerializedName("mini_program_path")
289    public String miniProgramPath;
290  
291    @SerializedName("app_path")
292    public String appPath;
293  
294    @SerializedName("usage_description")
295    public String usageDescription;
296  
297    @SerializedName("coupon_available_store_info")
298    public CouponAvailableStoreInfo couponAvailableStoreInfo;
299  }
300  
301  public static class CouponDisplayInfo {
302    @SerializedName("code_display_mode")
303    public CouponCodeDisplayMode codeDisplayMode;
304  
305    @SerializedName("background_color")
306    public String backgroundColor;
307  
308    @SerializedName("entrance_mini_program")
309    public EntranceMiniProgram entranceMiniProgram;
310  
311    @SerializedName("entrance_official_account")
312    public EntranceOfficialAccount entranceOfficialAccount;
313  
314    @SerializedName("entrance_finder")
315    public EntranceFinder entranceFinder;
316  }
317  
318  public static class NotifyConfig {
319    @SerializedName("notify_appid")
320    public String notifyAppid;
321  }
322  
323  public enum StockStoreScope {
324    @SerializedName("NONE")
325    NONE,
326    @SerializedName("ALL")
327    ALL,
328    @SerializedName("SPECIFIC")
329    SPECIFIC
330  }
331  
332  public static class StockSentCountInfo {
333    @SerializedName("total_count")
334    public Long totalCount;
335  
336    @SerializedName("today_count")
337    public Long todayCount;
338  }
339  
340  public enum StockState {
341    @SerializedName("AUDITING")
342    AUDITING,
343    @SerializedName("SENDING")
344    SENDING,
345    @SerializedName("PAUSED")
346    PAUSED,
347    @SerializedName("STOPPED")
348    STOPPED,
349    @SerializedName("DEACTIVATED")
350    DEACTIVATED
351  }
352  
353  public static class CouponAvailablePeriod {
354    @SerializedName("available_begin_time")
355    public String availableBeginTime;
356  
357    @SerializedName("available_end_time")
358    public String availableEndTime;
359  
360    @SerializedName("available_days")
361    public Long availableDays;
362  
363    @SerializedName("wait_days_after_receive")
364    public Long waitDaysAfterReceive;
365  
366    @SerializedName("weekly_available_period")
367    public FixedWeekPeriod weeklyAvailablePeriod;
368  
369    @SerializedName("irregular_available_period_list")
370    public List<TimePeriod> irregularAvailablePeriodList;
371  }
372  
373  public static class NormalCouponUsageRule {
374    @SerializedName("threshold")
375    public Long threshold;
376  
377    @SerializedName("discount_amount")
378    public Long discountAmount;
379  }
380  
381  public static class DiscountCouponUsageRule {
382    @SerializedName("threshold")
383    public Long threshold;
384  
385    @SerializedName("percent_off")
386    public Long percentOff;
387  }
388  
389  public static class ExchangeCouponUsageRule {
390    @SerializedName("threshold")
391    public Long threshold;
392  
393    @SerializedName("exchange_price")
394    public Long exchangePrice;
395  }
396  
397  public enum CouponUsageMethod {
398    @SerializedName("OFFLINE")
399    OFFLINE,
400    @SerializedName("MINI_PROGRAM")
401    MINI_PROGRAM,
402    @SerializedName("APP")
403    APP,
404    @SerializedName("PAYMENT_CODE")
405    PAYMENT_CODE
406  }
407  
408  public static class CouponAvailableStoreInfo {
409    @SerializedName("description")
410    public String description;
411  
412    @SerializedName("mini_program_appid")
413    public String miniProgramAppid;
414  
415    @SerializedName("mini_program_path")
416    public String miniProgramPath;
417  }
418  
419  public enum CouponCodeDisplayMode {
420    @SerializedName("INVISIBLE")
421    INVISIBLE,
422    @SerializedName("BARCODE")
423    BARCODE,
424    @SerializedName("QRCODE")
425    QRCODE
426  }
427  
428  public static class EntranceMiniProgram {
429    @SerializedName("appid")
430    public String appid;
431  
432    @SerializedName("path")
433    public String path;
434  
435    @SerializedName("entrance_wording")
436    public String entranceWording;
437  
438    @SerializedName("guidance_wording")
439    public String guidanceWording;
440  }
441  
442  public static class EntranceOfficialAccount {
443    @SerializedName("appid")
444    public String appid;
445  }
446  
447  public static class EntranceFinder {
448    @SerializedName("finder_id")
449    public String finderId;
450  
451    @SerializedName("finder_video_id")
452    public String finderVideoId;
453  
454    @SerializedName("finder_video_cover_image_url")
455    public String finderVideoCoverImageUrl;
456  }
457  
458  public static class FixedWeekPeriod {
459    @SerializedName("day_list")
460    public List<WeekEnum> dayList;
461  
462    @SerializedName("day_period_list")
463    public List<PeriodOfTheDay> dayPeriodList;
464  }
465  
466  public static class TimePeriod {
467    @SerializedName("begin_time")
468    public String beginTime;
469  
470    @SerializedName("end_time")
471    public String endTime;
472  }
473  
474  public enum WeekEnum {
475    @SerializedName("MONDAY")
476    MONDAY,
477    @SerializedName("TUESDAY")
478    TUESDAY,
479    @SerializedName("WEDNESDAY")
480    WEDNESDAY,
481    @SerializedName("THURSDAY")
482    THURSDAY,
483    @SerializedName("FRIDAY")
484    FRIDAY,
485    @SerializedName("SATURDAY")
486    SATURDAY,
487    @SerializedName("SUNDAY")
488    SUNDAY
489  }
490  
491  public static class PeriodOfTheDay {
492    @SerializedName("begin_time")
493    public Long beginTime;
494  
495    @SerializedName("end_time")
496    public Long endTime;
497  }
498  
499}
500

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	"time"
12)
13
14func main() {
15	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
16	config, err := wxpay_brand_utility.CreateBrandConfig(
17		"xxxxxxxx",                   // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
18		"1DDE55AD98Exxxxxxxxxx",      // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
19		"/path/to/apiclient_key.pem", // 品牌API证书私钥文件路径，本地文件路径
20		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
21		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
22	)
23	if err != nil {
24		fmt.Println(err)
25		return
26	}
27
28	request := &CreateStockRequest{
29		OutRequestNo:    wxpay_brand_utility.String("12345_20250101_A3489"),
30		ProductCouponId: wxpay_brand_utility.String("1000000013"),
31		Stock: &StockForCreate{
32			Remark:         wxpay_brand_utility.String("8月工作日有效批次"),
33			CouponCodeMode: COUPONCODEMODE_UPLOAD.Ptr(),
34			StockSendRule: &StockSendRule{
35				MaxCount:        wxpay_brand_utility.Int64(10000000),
36				MaxCountPerUser: wxpay_brand_utility.Int64(1),
37			},
38			SingleUsageRule: &SingleUsageRule{
39				CouponAvailablePeriod: &CouponAvailablePeriod{
40					AvailableBeginTime: wxpay_brand_utility.String("2025-08-01T00:00:00+08:00"),
41					AvailableEndTime:   wxpay_brand_utility.String("2025-08-31T23:59:59+08:00"),
42					AvailableDays:      wxpay_brand_utility.Int64(30),
43					WeeklyAvailablePeriod: &FixedWeekPeriod{
44						DayList: []WeekEnum{
45							WEEKENUM_MONDAY,
46							WEEKENUM_TUESDAY,
47							WEEKENUM_WEDNESDAY,
48							WEEKENUM_THURSDAY,
49							WEEKENUM_FRIDAY,
50						},
51					},
52				},
53			},
54			UsageRuleDisplayInfo: &UsageRuleDisplayInfo{
55				CouponUsageMethodList: []CouponUsageMethod{
56					COUPONUSAGEMETHOD_OFFLINE,
57					COUPONUSAGEMETHOD_MINI_PROGRAM,
58					COUPONUSAGEMETHOD_PAYMENT_CODE,
59				},
60				MiniProgramAppid: wxpay_brand_utility.String("wx1234567890"),
61				MiniProgramPath:  wxpay_brand_utility.String("/pages/index/product"),
62				UsageDescription: wxpay_brand_utility.String("工作日可用"),
63				CouponAvailableStoreInfo: &CouponAvailableStoreInfo{
64					Description:      wxpay_brand_utility.String("所有门店可用，可使用小程序查看门店列表"),
65					MiniProgramAppid: wxpay_brand_utility.String("wx1234567890"),
66					MiniProgramPath:  wxpay_brand_utility.String("/pages/index/store-list"),
67				},
68			},
69			CouponDisplayInfo: &CouponDisplayInfo{
70				CodeDisplayMode: COUPONCODEDISPLAYMODE_QRCODE.Ptr(),
71				BackgroundColor: wxpay_brand_utility.String("Color010"),
72				EntranceMiniProgram: &EntranceMiniProgram{
73					Appid:           wxpay_brand_utility.String("wx1234567890"),
74					Path:            wxpay_brand_utility.String("/pages/index/product"),
75					EntranceWording: wxpay_brand_utility.String("欢迎选购"),
76					GuidanceWording: wxpay_brand_utility.String("获取更多优惠"),
77				},
78				EntranceOfficialAccount: &EntranceOfficialAccount{
79					Appid: wxpay_brand_utility.String("wx1234567890"),
80				},
81				EntranceFinder: &EntranceFinder{
82					FinderId:                 wxpay_brand_utility.String("gh_12345678"),
83					FinderVideoId:            wxpay_brand_utility.String("UDFsdf24df34dD456Hdf34"),
84					FinderVideoCoverImageUrl: wxpay_brand_utility.String("https://wxpaylogo.qpic.cn/wxpaylogo/xxxxx/xxx"),
85				},
86			},
87			NotifyConfig: &NotifyConfig{
88				NotifyAppid: wxpay_brand_utility.String("wx4fd12345678"),
89			},
90			StoreScope: STOCKSTORESCOPE_NONE.Ptr(),
91		},
92	}
93
94	response, err := CreateStock(config, request)
95	if err != nil {
96		fmt.Printf("请求失败: %+v\n", err)
97		// TODO: 请求失败，根据状态码执行不同的处理
98		return
99	}
100
101	// TODO: 请求成功，继续业务逻辑
102	fmt.Printf("请求成功: %+v\n", response)
103}
104
105func CreateStock(config *wxpay_brand_utility.BrandConfig, request *CreateStockRequest) (response *StockEntity, err error) {
106	const (
107		host   = "https://api.mch.weixin.qq.com"
108		method = "POST"
109		path   = "/brand/marketing/product-coupon/product-coupons/{product_coupon_id}/stocks"
110	)
111
112	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
113	if err != nil {
114		return nil, err
115	}
116	reqUrl.Path = strings.Replace(reqUrl.Path, "{product_coupon_id}", url.PathEscape(*request.ProductCouponId), -1)
117	reqBody, err := json.Marshal(request)
118	if err != nil {
119		return nil, err
120	}
121	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
122	if err != nil {
123		return nil, err
124	}
125	httpRequest.Header.Set("Accept", "application/json")
126	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
127	httpRequest.Header.Set("Content-Type", "application/json")
128	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
129	if err != nil {
130		return nil, err
131	}
132	httpRequest.Header.Set("Authorization", authorization)
133
134	client := &http.Client{}
135	httpResponse, err := client.Do(httpRequest)
136	if err != nil {
137		return nil, err
138	}
139	respBody, err := wxpay_brand_utility.ExtractResponseBody(httpResponse)
140	if err != nil {
141		return nil, err
142	}
143	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
144		// 2XX 成功，验证应答签名
145		err = wxpay_brand_utility.ValidateResponse(
146			config.WechatPayPublicKeyId(),
147			config.WechatPayPublicKey(),
148			&httpResponse.Header,
149			respBody,
150		)
151		if err != nil {
152			return nil, err
153		}
154		response := &StockEntity{}
155		if err := json.Unmarshal(respBody, response); err != nil {
156			return nil, err
157		}
158
159		return response, nil
160	} else {
161		return nil, wxpay_brand_utility.NewApiException(
162			httpResponse.StatusCode,
163			httpResponse.Header,
164			respBody,
165		)
166	}
167}
168
169type CreateStockRequest struct {
170	OutRequestNo    *string         `json:"out_request_no,omitempty"`
171	ProductCouponId *string         `json:"product_coupon_id,omitempty"`
172	Stock           *StockForCreate `json:"stock,omitempty"`
173}
174
175func (o *CreateStockRequest) MarshalJSON() ([]byte, error) {
176	type Alias CreateStockRequest
177	a := &struct {
178		ProductCouponId *string `json:"product_coupon_id,omitempty"`
179		*Alias
180	}{
181		// 序列化时移除非 Body 字段
182		ProductCouponId: nil,
183		Alias:           (*Alias)(o),
184	}
185	return json.Marshal(a)
186}
187
188type StockEntity struct {
189	ProductCouponId      *string               `json:"product_coupon_id,omitempty"`
190	StockId              *string               `json:"stock_id,omitempty"`
191	Remark               *string               `json:"remark,omitempty"`
192	CouponCodeMode       *CouponCodeMode       `json:"coupon_code_mode,omitempty"`
193	CouponCodeCountInfo  *CouponCodeCountInfo  `json:"coupon_code_count_info,omitempty"`
194	StockSendRule        *StockSendRule        `json:"stock_send_rule,omitempty"`
195	SingleUsageRule      *SingleUsageRule      `json:"single_usage_rule,omitempty"`
196	UsageRuleDisplayInfo *UsageRuleDisplayInfo `json:"usage_rule_display_info,omitempty"`
197	CouponDisplayInfo    *CouponDisplayInfo    `json:"coupon_display_info,omitempty"`
198	NotifyConfig         *NotifyConfig         `json:"notify_config,omitempty"`
199	StoreScope           *StockStoreScope      `json:"store_scope,omitempty"`
200	SentCountInfo        *StockSentCountInfo   `json:"sent_count_info,omitempty"`
201	State                *StockState           `json:"state,omitempty"`
202	DeactivateRequestNo  *string               `json:"deactivate_request_no,omitempty"`
203	DeactivateTime       *time.Time            `json:"deactivate_time,omitempty"`
204	DeactivateReason     *string               `json:"deactivate_reason,omitempty"`
205}
206
207type StockForCreate struct {
208	Remark               *string               `json:"remark,omitempty"`
209	CouponCodeMode       *CouponCodeMode       `json:"coupon_code_mode,omitempty"`
210	StockSendRule        *StockSendRule        `json:"stock_send_rule,omitempty"`
211	SingleUsageRule      *SingleUsageRule      `json:"single_usage_rule,omitempty"`
212	UsageRuleDisplayInfo *UsageRuleDisplayInfo `json:"usage_rule_display_info,omitempty"`
213	CouponDisplayInfo    *CouponDisplayInfo    `json:"coupon_display_info,omitempty"`
214	NotifyConfig         *NotifyConfig         `json:"notify_config,omitempty"`
215	StoreScope           *StockStoreScope      `json:"store_scope,omitempty"`
216}
217
218type CouponCodeMode string
219
220func (e CouponCodeMode) Ptr() *CouponCodeMode {
221	return &e
222}
223
224const (
225	COUPONCODEMODE_WECHATPAY  CouponCodeMode = "WECHATPAY"
226	COUPONCODEMODE_UPLOAD     CouponCodeMode = "UPLOAD"
227	COUPONCODEMODE_API_ASSIGN CouponCodeMode = "API_ASSIGN"
228)
229
230type CouponCodeCountInfo struct {
231	TotalCount     *int64 `json:"total_count,omitempty"`
232	AvailableCount *int64 `json:"available_count,omitempty"`
233}
234
235type StockSendRule struct {
236	MaxCount        *int64 `json:"max_count,omitempty"`
237	MaxCountPerDay  *int64 `json:"max_count_per_day,omitempty"`
238	MaxCountPerUser *int64 `json:"max_count_per_user,omitempty"`
239}
240
241type SingleUsageRule struct {
242	CouponAvailablePeriod *CouponAvailablePeriod   `json:"coupon_available_period,omitempty"`
243	NormalCoupon          *NormalCouponUsageRule   `json:"normal_coupon,omitempty"`
244	DiscountCoupon        *DiscountCouponUsageRule `json:"discount_coupon,omitempty"`
245	ExchangeCoupon        *ExchangeCouponUsageRule `json:"exchange_coupon,omitempty"`
246}
247
248type UsageRuleDisplayInfo struct {
249	CouponUsageMethodList    []CouponUsageMethod       `json:"coupon_usage_method_list,omitempty"`
250	MiniProgramAppid         *string                   `json:"mini_program_appid,omitempty"`
251	MiniProgramPath          *string                   `json:"mini_program_path,omitempty"`
252	AppPath                  *string                   `json:"app_path,omitempty"`
253	UsageDescription         *string                   `json:"usage_description,omitempty"`
254	CouponAvailableStoreInfo *CouponAvailableStoreInfo `json:"coupon_available_store_info,omitempty"`
255}
256
257type CouponDisplayInfo struct {
258	CodeDisplayMode         *CouponCodeDisplayMode   `json:"code_display_mode,omitempty"`
259	BackgroundColor         *string                  `json:"background_color,omitempty"`
260	EntranceMiniProgram     *EntranceMiniProgram     `json:"entrance_mini_program,omitempty"`
261	EntranceOfficialAccount *EntranceOfficialAccount `json:"entrance_official_account,omitempty"`
262	EntranceFinder          *EntranceFinder          `json:"entrance_finder,omitempty"`
263}
264
265type NotifyConfig struct {
266	NotifyAppid *string `json:"notify_appid,omitempty"`
267}
268
269type StockStoreScope string
270
271func (e StockStoreScope) Ptr() *StockStoreScope {
272	return &e
273}
274
275const (
276	STOCKSTORESCOPE_NONE     StockStoreScope = "NONE"
277	STOCKSTORESCOPE_ALL      StockStoreScope = "ALL"
278	STOCKSTORESCOPE_SPECIFIC StockStoreScope = "SPECIFIC"
279)
280
281type StockSentCountInfo struct {
282	TotalCount *int64 `json:"total_count,omitempty"`
283	TodayCount *int64 `json:"today_count,omitempty"`
284}
285
286type StockState string
287
288func (e StockState) Ptr() *StockState {
289	return &e
290}
291
292const (
293	STOCKSTATE_AUDITING    StockState = "AUDITING"
294	STOCKSTATE_SENDING     StockState = "SENDING"
295	STOCKSTATE_PAUSED      StockState = "PAUSED"
296	STOCKSTATE_STOPPED     StockState = "STOPPED"
297	STOCKSTATE_DEACTIVATED StockState = "DEACTIVATED"
298)
299
300type CouponAvailablePeriod struct {
301	AvailableBeginTime           *string          `json:"available_begin_time,omitempty"`
302	AvailableEndTime             *string          `json:"available_end_time,omitempty"`
303	AvailableDays                *int64           `json:"available_days,omitempty"`
304	WaitDaysAfterReceive         *int64           `json:"wait_days_after_receive,omitempty"`
305	WeeklyAvailablePeriod        *FixedWeekPeriod `json:"weekly_available_period,omitempty"`
306	IrregularAvailablePeriodList []TimePeriod     `json:"irregular_available_period_list,omitempty"`
307}
308
309type NormalCouponUsageRule struct {
310	Threshold      *int64 `json:"threshold,omitempty"`
311	DiscountAmount *int64 `json:"discount_amount,omitempty"`
312}
313
314type DiscountCouponUsageRule struct {
315	Threshold  *int64 `json:"threshold,omitempty"`
316	PercentOff *int64 `json:"percent_off,omitempty"`
317}
318
319type ExchangeCouponUsageRule struct {
320	Threshold     *int64 `json:"threshold,omitempty"`
321	ExchangePrice *int64 `json:"exchange_price,omitempty"`
322}
323
324type CouponUsageMethod string
325
326func (e CouponUsageMethod) Ptr() *CouponUsageMethod {
327	return &e
328}
329
330const (
331	COUPONUSAGEMETHOD_OFFLINE      CouponUsageMethod = "OFFLINE"
332	COUPONUSAGEMETHOD_MINI_PROGRAM CouponUsageMethod = "MINI_PROGRAM"
333	COUPONUSAGEMETHOD_APP          CouponUsageMethod = "APP"
334	COUPONUSAGEMETHOD_PAYMENT_CODE CouponUsageMethod = "PAYMENT_CODE"
335)
336
337type CouponAvailableStoreInfo struct {
338	Description      *string `json:"description,omitempty"`
339	MiniProgramAppid *string `json:"mini_program_appid,omitempty"`
340	MiniProgramPath  *string `json:"mini_program_path,omitempty"`
341}
342
343type CouponCodeDisplayMode string
344
345func (e CouponCodeDisplayMode) Ptr() *CouponCodeDisplayMode {
346	return &e
347}
348
349const (
350	COUPONCODEDISPLAYMODE_INVISIBLE CouponCodeDisplayMode = "INVISIBLE"
351	COUPONCODEDISPLAYMODE_BARCODE   CouponCodeDisplayMode = "BARCODE"
352	COUPONCODEDISPLAYMODE_QRCODE    CouponCodeDisplayMode = "QRCODE"
353)
354
355type EntranceMiniProgram struct {
356	Appid           *string `json:"appid,omitempty"`
357	Path            *string `json:"path,omitempty"`
358	EntranceWording *string `json:"entrance_wording,omitempty"`
359	GuidanceWording *string `json:"guidance_wording,omitempty"`
360}
361
362type EntranceOfficialAccount struct {
363	Appid *string `json:"appid,omitempty"`
364}
365
366type EntranceFinder struct {
367	FinderId                 *string `json:"finder_id,omitempty"`
368	FinderVideoId            *string `json:"finder_video_id,omitempty"`
369	FinderVideoCoverImageUrl *string `json:"finder_video_cover_image_url,omitempty"`
370}
371
372type FixedWeekPeriod struct {
373	DayList       []WeekEnum       `json:"day_list,omitempty"`
374	DayPeriodList []PeriodOfTheDay `json:"day_period_list,omitempty"`
375}
376
377type TimePeriod struct {
378	BeginTime *string `json:"begin_time,omitempty"`
379	EndTime   *string `json:"end_time,omitempty"`
380}
381
382type WeekEnum string
383
384func (e WeekEnum) Ptr() *WeekEnum {
385	return &e
386}
387
388const (
389	WEEKENUM_MONDAY    WeekEnum = "MONDAY"
390	WEEKENUM_TUESDAY   WeekEnum = "TUESDAY"
391	WEEKENUM_WEDNESDAY WeekEnum = "WEDNESDAY"
392	WEEKENUM_THURSDAY  WeekEnum = "THURSDAY"
393	WEEKENUM_FRIDAY    WeekEnum = "FRIDAY"
394	WEEKENUM_SATURDAY  WeekEnum = "SATURDAY"
395	WEEKENUM_SUNDAY    WeekEnum = "SUNDAY"
396)
397
398type PeriodOfTheDay struct {
399	BeginTime *int64 `json:"begin_time,omitempty"`
400	EndTime   *int64 `json:"end_time,omitempty"`
401}
402