修改商品券批次发放预算

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/marketing/partner/product-coupon/product-coupons/1000000013/stocks/1000000013001/update-budget \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "target_max_count" : 200,
8    "update_mode" : "MAX_COUNT",
9    "out_request_no" : "update_budget_34657_20250101_123456",
10    "current_max_count" : 10000000,
11    "brand_id" : "120344"
12  }'
13

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 UpdateStockBudget {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/marketing/partner/product-coupon/product-coupons/{product_coupon_id}/stocks/{stock_id}/update-budget";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    UpdateStockBudget client = new UpdateStockBudget(
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    UpdateStockBudgetRequest request = new UpdateStockBudgetRequest();
41    request.outRequestNo = "update_budget_34657_20250101_123456";
42    request.productCouponId = "1000000013";
43    request.stockId = "1000000013001";
44    request.updateMode = UpdateBudgetMode.MAX_COUNT;
45    request.currentMaxCount = 10000000L;
46    request.targetMaxCount = 200L;
47    request.brandId = "120344";
48    try {
49      StockEntity response = client.run(request);
50        // TODO: 请求成功，继续业务逻辑
51        System.out.println(response);
52    } catch (WXPayUtility.ApiException e) {
53        // TODO: 请求失败，根据状态码执行不同的逻辑
54        e.printStackTrace();
55    }
56  }
57
58  public StockEntity run(UpdateStockBudgetRequest request) {
59    String uri = PATH;
60    uri = uri.replace("{product_coupon_id}", WXPayUtility.urlEncode(request.productCouponId));
61    uri = uri.replace("{stock_id}", WXPayUtility.urlEncode(request.stockId));
62    String reqBody = WXPayUtility.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", WXPayUtility.buildAuthorization(mchid, 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 = WXPayUtility.extractBody(httpResponse);
77      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
78        // 2XX 成功，验证应答签名
79        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
80            httpResponse.headers(), respBody);
81
82        // 从HTTP应答报文构建返回数据
83        return WXPayUtility.fromJson(respBody, StockEntity.class);
84      } else {
85        throw new WXPayUtility.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 mchid;
93  private final String certificateSerialNo;
94  private final PrivateKey privateKey;
95  private final String wechatPayPublicKeyId;
96  private final PublicKey wechatPayPublicKey;
97
98  public UpdateStockBudget(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
99    this.mchid = mchid;
100    this.certificateSerialNo = certificateSerialNo;
101    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
102    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
103    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
104  }
105
106  public static class UpdateStockBudgetRequest {
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("update_mode")
119    public UpdateBudgetMode updateMode;
120  
121    @SerializedName("current_max_count")
122    public Long currentMaxCount;
123  
124    @SerializedName("target_max_count")
125    public Long targetMaxCount;
126  
127    @SerializedName("current_max_count_per_day")
128    public Long currentMaxCountPerDay;
129  
130    @SerializedName("target_max_count_per_day")
131    public Long targetMaxCountPerDay;
132  
133    @SerializedName("brand_id")
134    public String brandId;
135  }
136  
137  public static class StockEntity {
138    @SerializedName("product_coupon_id")
139    public String productCouponId;
140  
141    @SerializedName("stock_id")
142    public String stockId;
143  
144    @SerializedName("remark")
145    public String remark;
146  
147    @SerializedName("coupon_code_mode")
148    public CouponCodeMode couponCodeMode;
149  
150    @SerializedName("coupon_code_count_info")
151    public CouponCodeCountInfo couponCodeCountInfo;
152  
153    @SerializedName("stock_send_rule")
154    public StockSendRule stockSendRule;
155  
156    @SerializedName("single_usage_rule")
157    public SingleUsageRule singleUsageRule;
158  
159    @SerializedName("usage_rule_display_info")
160    public UsageRuleDisplayInfo usageRuleDisplayInfo;
161  
162    @SerializedName("coupon_display_info")
163    public CouponDisplayInfo couponDisplayInfo;
164  
165    @SerializedName("notify_config")
166    public NotifyConfig notifyConfig;
167  
168    @SerializedName("store_scope")
169    public StockStoreScope storeScope;
170  
171    @SerializedName("sent_count_info")
172    public StockSentCountInfo sentCountInfo;
173  
174    @SerializedName("state")
175    public StockState state;
176  
177    @SerializedName("deactivate_request_no")
178    public String deactivateRequestNo;
179  
180    @SerializedName("deactivate_time")
181    public String deactivateTime;
182  
183    @SerializedName("deactivate_reason")
184    public String deactivateReason;
185  
186    @SerializedName("brand_id")
187    public String brandId;
188  }
189  
190  public enum UpdateBudgetMode {
191    @SerializedName("MAX_COUNT")
192    MAX_COUNT,
193    @SerializedName("MAX_COUNT_PER_DAY")
194    MAX_COUNT_PER_DAY
195  }
196  
197  public enum CouponCodeMode {
198    @SerializedName("WECHATPAY")
199    WECHATPAY,
200    @SerializedName("UPLOAD")
201    UPLOAD,
202    @SerializedName("API_ASSIGN")
203    API_ASSIGN
204  }
205  
206  public static class CouponCodeCountInfo {
207    @SerializedName("total_count")
208    public Long totalCount;
209  
210    @SerializedName("available_count")
211    public Long availableCount;
212  }
213  
214  public static class StockSendRule {
215    @SerializedName("max_count")
216    public Long maxCount;
217  
218    @SerializedName("max_count_per_day")
219    public Long maxCountPerDay;
220  
221    @SerializedName("max_count_per_user")
222    public Long maxCountPerUser;
223  }
224  
225  public static class SingleUsageRule {
226    @SerializedName("coupon_available_period")
227    public CouponAvailablePeriod couponAvailablePeriod;
228  
229    @SerializedName("normal_coupon")
230    public NormalCouponUsageRule normalCoupon;
231  
232    @SerializedName("discount_coupon")
233    public DiscountCouponUsageRule discountCoupon;
234  
235    @SerializedName("exchange_coupon")
236    public ExchangeCouponUsageRule exchangeCoupon;
237  }
238  
239  public static class UsageRuleDisplayInfo {
240    @SerializedName("coupon_usage_method_list")
241    public List<CouponUsageMethod> couponUsageMethodList = new ArrayList<CouponUsageMethod>();
242  
243    @SerializedName("mini_program_appid")
244    public String miniProgramAppid;
245  
246    @SerializedName("mini_program_path")
247    public String miniProgramPath;
248  
249    @SerializedName("app_path")
250    public String appPath;
251  
252    @SerializedName("usage_description")
253    public String usageDescription;
254  
255    @SerializedName("coupon_available_store_info")
256    public CouponAvailableStoreInfo couponAvailableStoreInfo;
257  }
258  
259  public static class CouponDisplayInfo {
260    @SerializedName("code_display_mode")
261    public CouponCodeDisplayMode codeDisplayMode;
262  
263    @SerializedName("background_color")
264    public String backgroundColor;
265  
266    @SerializedName("entrance_mini_program")
267    public EntranceMiniProgram entranceMiniProgram;
268  
269    @SerializedName("entrance_official_account")
270    public EntranceOfficialAccount entranceOfficialAccount;
271  
272    @SerializedName("entrance_finder")
273    public EntranceFinder entranceFinder;
274  }
275  
276  public static class NotifyConfig {
277    @SerializedName("notify_appid")
278    public String notifyAppid;
279  }
280  
281  public enum StockStoreScope {
282    @SerializedName("NONE")
283    NONE,
284    @SerializedName("ALL")
285    ALL,
286    @SerializedName("SPECIFIC")
287    SPECIFIC
288  }
289  
290  public static class StockSentCountInfo {
291    @SerializedName("total_count")
292    public Long totalCount;
293  
294    @SerializedName("today_count")
295    public Long todayCount;
296  }
297  
298  public enum StockState {
299    @SerializedName("AUDITING")
300    AUDITING,
301    @SerializedName("SENDING")
302    SENDING,
303    @SerializedName("PAUSED")
304    PAUSED,
305    @SerializedName("STOPPED")
306    STOPPED,
307    @SerializedName("DEACTIVATED")
308    DEACTIVATED
309  }
310  
311  public static class CouponAvailablePeriod {
312    @SerializedName("available_begin_time")
313    public String availableBeginTime;
314  
315    @SerializedName("available_end_time")
316    public String availableEndTime;
317  
318    @SerializedName("available_days")
319    public Long availableDays;
320  
321    @SerializedName("wait_days_after_receive")
322    public Long waitDaysAfterReceive;
323  
324    @SerializedName("weekly_available_period")
325    public FixedWeekPeriod weeklyAvailablePeriod;
326  
327    @SerializedName("irregular_available_period_list")
328    public List<TimePeriod> irregularAvailablePeriodList;
329  }
330  
331  public static class NormalCouponUsageRule {
332    @SerializedName("threshold")
333    public Long threshold;
334  
335    @SerializedName("discount_amount")
336    public Long discountAmount;
337  }
338  
339  public static class DiscountCouponUsageRule {
340    @SerializedName("threshold")
341    public Long threshold;
342  
343    @SerializedName("percent_off")
344    public Long percentOff;
345  }
346  
347  public static class ExchangeCouponUsageRule {
348    @SerializedName("threshold")
349    public Long threshold;
350  
351    @SerializedName("exchange_price")
352    public Long exchangePrice;
353  }
354  
355  public enum CouponUsageMethod {
356    @SerializedName("OFFLINE")
357    OFFLINE,
358    @SerializedName("MINI_PROGRAM")
359    MINI_PROGRAM,
360    @SerializedName("APP")
361    APP,
362    @SerializedName("PAYMENT_CODE")
363    PAYMENT_CODE
364  }
365  
366  public static class CouponAvailableStoreInfo {
367    @SerializedName("description")
368    public String description;
369  
370    @SerializedName("mini_program_appid")
371    public String miniProgramAppid;
372  
373    @SerializedName("mini_program_path")
374    public String miniProgramPath;
375  }
376  
377  public enum CouponCodeDisplayMode {
378    @SerializedName("INVISIBLE")
379    INVISIBLE,
380    @SerializedName("BARCODE")
381    BARCODE,
382    @SerializedName("QRCODE")
383    QRCODE
384  }
385  
386  public static class EntranceMiniProgram {
387    @SerializedName("appid")
388    public String appid;
389  
390    @SerializedName("path")
391    public String path;
392  
393    @SerializedName("entrance_wording")
394    public String entranceWording;
395  
396    @SerializedName("guidance_wording")
397    public String guidanceWording;
398  }
399  
400  public static class EntranceOfficialAccount {
401    @SerializedName("appid")
402    public String appid;
403  }
404  
405  public static class EntranceFinder {
406    @SerializedName("finder_id")
407    public String finderId;
408  
409    @SerializedName("finder_video_id")
410    public String finderVideoId;
411  
412    @SerializedName("finder_video_cover_image_url")
413    public String finderVideoCoverImageUrl;
414  }
415  
416  public static class FixedWeekPeriod {
417    @SerializedName("day_list")
418    public List<WeekEnum> dayList;
419  
420    @SerializedName("day_period_list")
421    public List<PeriodOfTheDay> dayPeriodList;
422  }
423  
424  public static class TimePeriod {
425    @SerializedName("begin_time")
426    public String beginTime;
427  
428    @SerializedName("end_time")
429    public String endTime;
430  }
431  
432  public enum WeekEnum {
433    @SerializedName("MONDAY")
434    MONDAY,
435    @SerializedName("TUESDAY")
436    TUESDAY,
437    @SerializedName("WEDNESDAY")
438    WEDNESDAY,
439    @SerializedName("THURSDAY")
440    THURSDAY,
441    @SerializedName("FRIDAY")
442    FRIDAY,
443    @SerializedName("SATURDAY")
444    SATURDAY,
445    @SerializedName("SUNDAY")
446    SUNDAY
447  }
448  
449  public static class PeriodOfTheDay {
450    @SerializedName("begin_time")
451    public Long beginTime;
452  
453    @SerializedName("end_time")
454    public Long endTime;
455  }
456  
457}
458

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 := &UpdateStockBudgetRequest{
29		OutRequestNo:    wxpay_utility.String("update_budget_34657_20250101_123456"),
30		ProductCouponId: wxpay_utility.String("1000000013"),
31		StockId:         wxpay_utility.String("1000000013001"),
32		UpdateMode:      UPDATEBUDGETMODE_MAX_COUNT.Ptr(),
33		CurrentMaxCount: wxpay_utility.Int64(10000000),
34		TargetMaxCount:  wxpay_utility.Int64(200),
35		BrandId:         wxpay_utility.String("120344"),
36	}
37
38	response, err := UpdateStockBudget(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 UpdateStockBudget(config *wxpay_utility.MchConfig, request *UpdateStockBudgetRequest) (response *StockEntity, err error) {
50	const (
51		host   = "https://api.mch.weixin.qq.com"
52		method = "POST"
53		path   = "/v3/marketing/partner/product-coupon/product-coupons/{product_coupon_id}/stocks/{stock_id}/update-budget"
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, "{product_coupon_id}", url.PathEscape(*request.ProductCouponId), -1)
61	reqUrl.Path = strings.Replace(reqUrl.Path, "{stock_id}", url.PathEscape(*request.StockId), -1)
62	reqBody, err := json.Marshal(request)
63	if err != nil {
64		return nil, err
65	}
66	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
67	if err != nil {
68		return nil, err
69	}
70	httpRequest.Header.Set("Accept", "application/json")
71	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
72	httpRequest.Header.Set("Content-Type", "application/json")
73	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
74	if err != nil {
75		return nil, err
76	}
77	httpRequest.Header.Set("Authorization", authorization)
78
79	client := &http.Client{}
80	httpResponse, err := client.Do(httpRequest)
81	if err != nil {
82		return nil, err
83	}
84	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
85	if err != nil {
86		return nil, err
87	}
88	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
89		// 2XX 成功，验证应答签名
90		err = wxpay_utility.ValidateResponse(
91			config.WechatPayPublicKeyId(),
92			config.WechatPayPublicKey(),
93			&httpResponse.Header,
94			respBody,
95		)
96		if err != nil {
97			return nil, err
98		}
99		response := &StockEntity{}
100		if err := json.Unmarshal(respBody, response); err != nil {
101			return nil, err
102		}
103
104		return response, nil
105	} else {
106		return nil, wxpay_utility.NewApiException(
107			httpResponse.StatusCode,
108			httpResponse.Header,
109			respBody,
110		)
111	}
112}
113
114type UpdateStockBudgetRequest struct {
115	OutRequestNo          *string           `json:"out_request_no,omitempty"`
116	ProductCouponId       *string           `json:"product_coupon_id,omitempty"`
117	StockId               *string           `json:"stock_id,omitempty"`
118	UpdateMode            *UpdateBudgetMode `json:"update_mode,omitempty"`
119	CurrentMaxCount       *int64            `json:"current_max_count,omitempty"`
120	TargetMaxCount        *int64            `json:"target_max_count,omitempty"`
121	CurrentMaxCountPerDay *int64            `json:"current_max_count_per_day,omitempty"`
122	TargetMaxCountPerDay  *int64            `json:"target_max_count_per_day,omitempty"`
123	BrandId               *string           `json:"brand_id,omitempty"`
124}
125
126func (o *UpdateStockBudgetRequest) MarshalJSON() ([]byte, error) {
127	type Alias UpdateStockBudgetRequest
128	a := &struct {
129		ProductCouponId *string `json:"product_coupon_id,omitempty"`
130		StockId         *string `json:"stock_id,omitempty"`
131		*Alias
132	}{
133		// 序列化时移除非 Body 字段
134		ProductCouponId: nil,
135		StockId:         nil,
136		Alias:           (*Alias)(o),
137	}
138	return json.Marshal(a)
139}
140
141type StockEntity struct {
142	ProductCouponId      *string               `json:"product_coupon_id,omitempty"`
143	StockId              *string               `json:"stock_id,omitempty"`
144	Remark               *string               `json:"remark,omitempty"`
145	CouponCodeMode       *CouponCodeMode       `json:"coupon_code_mode,omitempty"`
146	CouponCodeCountInfo  *CouponCodeCountInfo  `json:"coupon_code_count_info,omitempty"`
147	StockSendRule        *StockSendRule        `json:"stock_send_rule,omitempty"`
148	SingleUsageRule      *SingleUsageRule      `json:"single_usage_rule,omitempty"`
149	UsageRuleDisplayInfo *UsageRuleDisplayInfo `json:"usage_rule_display_info,omitempty"`
150	CouponDisplayInfo    *CouponDisplayInfo    `json:"coupon_display_info,omitempty"`
151	NotifyConfig         *NotifyConfig         `json:"notify_config,omitempty"`
152	StoreScope           *StockStoreScope      `json:"store_scope,omitempty"`
153	SentCountInfo        *StockSentCountInfo   `json:"sent_count_info,omitempty"`
154	State                *StockState           `json:"state,omitempty"`
155	DeactivateRequestNo  *string               `json:"deactivate_request_no,omitempty"`
156	DeactivateTime       *time.Time            `json:"deactivate_time,omitempty"`
157	DeactivateReason     *string               `json:"deactivate_reason,omitempty"`
158	BrandId              *string               `json:"brand_id,omitempty"`
159}
160
161type UpdateBudgetMode string
162
163func (e UpdateBudgetMode) Ptr() *UpdateBudgetMode {
164	return &e
165}
166
167const (
168	UPDATEBUDGETMODE_MAX_COUNT         UpdateBudgetMode = "MAX_COUNT"
169	UPDATEBUDGETMODE_MAX_COUNT_PER_DAY UpdateBudgetMode = "MAX_COUNT_PER_DAY"
170)
171
172type CouponCodeMode string
173
174func (e CouponCodeMode) Ptr() *CouponCodeMode {
175	return &e
176}
177
178const (
179	COUPONCODEMODE_WECHATPAY  CouponCodeMode = "WECHATPAY"
180	COUPONCODEMODE_UPLOAD     CouponCodeMode = "UPLOAD"
181	COUPONCODEMODE_API_ASSIGN CouponCodeMode = "API_ASSIGN"
182)
183
184type CouponCodeCountInfo struct {
185	TotalCount     *int64 `json:"total_count,omitempty"`
186	AvailableCount *int64 `json:"available_count,omitempty"`
187}
188
189type StockSendRule struct {
190	MaxCount        *int64 `json:"max_count,omitempty"`
191	MaxCountPerDay  *int64 `json:"max_count_per_day,omitempty"`
192	MaxCountPerUser *int64 `json:"max_count_per_user,omitempty"`
193}
194
195type SingleUsageRule struct {
196	CouponAvailablePeriod *CouponAvailablePeriod   `json:"coupon_available_period,omitempty"`
197	NormalCoupon          *NormalCouponUsageRule   `json:"normal_coupon,omitempty"`
198	DiscountCoupon        *DiscountCouponUsageRule `json:"discount_coupon,omitempty"`
199	ExchangeCoupon        *ExchangeCouponUsageRule `json:"exchange_coupon,omitempty"`
200}
201
202type UsageRuleDisplayInfo struct {
203	CouponUsageMethodList    []CouponUsageMethod       `json:"coupon_usage_method_list,omitempty"`
204	MiniProgramAppid         *string                   `json:"mini_program_appid,omitempty"`
205	MiniProgramPath          *string                   `json:"mini_program_path,omitempty"`
206	AppPath                  *string                   `json:"app_path,omitempty"`
207	UsageDescription         *string                   `json:"usage_description,omitempty"`
208	CouponAvailableStoreInfo *CouponAvailableStoreInfo `json:"coupon_available_store_info,omitempty"`
209}
210
211type CouponDisplayInfo struct {
212	CodeDisplayMode         *CouponCodeDisplayMode   `json:"code_display_mode,omitempty"`
213	BackgroundColor         *string                  `json:"background_color,omitempty"`
214	EntranceMiniProgram     *EntranceMiniProgram     `json:"entrance_mini_program,omitempty"`
215	EntranceOfficialAccount *EntranceOfficialAccount `json:"entrance_official_account,omitempty"`
216	EntranceFinder          *EntranceFinder          `json:"entrance_finder,omitempty"`
217}
218
219type NotifyConfig struct {
220	NotifyAppid *string `json:"notify_appid,omitempty"`
221}
222
223type StockStoreScope string
224
225func (e StockStoreScope) Ptr() *StockStoreScope {
226	return &e
227}
228
229const (
230	STOCKSTORESCOPE_NONE     StockStoreScope = "NONE"
231	STOCKSTORESCOPE_ALL      StockStoreScope = "ALL"
232	STOCKSTORESCOPE_SPECIFIC StockStoreScope = "SPECIFIC"
233)
234
235type StockSentCountInfo struct {
236	TotalCount *int64 `json:"total_count,omitempty"`
237	TodayCount *int64 `json:"today_count,omitempty"`
238}
239
240type StockState string
241
242func (e StockState) Ptr() *StockState {
243	return &e
244}
245
246const (
247	STOCKSTATE_AUDITING    StockState = "AUDITING"
248	STOCKSTATE_SENDING     StockState = "SENDING"
249	STOCKSTATE_PAUSED      StockState = "PAUSED"
250	STOCKSTATE_STOPPED     StockState = "STOPPED"
251	STOCKSTATE_DEACTIVATED StockState = "DEACTIVATED"
252)
253
254type CouponAvailablePeriod struct {
255	AvailableBeginTime           *string          `json:"available_begin_time,omitempty"`
256	AvailableEndTime             *string          `json:"available_end_time,omitempty"`
257	AvailableDays                *int64           `json:"available_days,omitempty"`
258	WaitDaysAfterReceive         *int64           `json:"wait_days_after_receive,omitempty"`
259	WeeklyAvailablePeriod        *FixedWeekPeriod `json:"weekly_available_period,omitempty"`
260	IrregularAvailablePeriodList []TimePeriod     `json:"irregular_available_period_list,omitempty"`
261}
262
263type NormalCouponUsageRule struct {
264	Threshold      *int64 `json:"threshold,omitempty"`
265	DiscountAmount *int64 `json:"discount_amount,omitempty"`
266}
267
268type DiscountCouponUsageRule struct {
269	Threshold  *int64 `json:"threshold,omitempty"`
270	PercentOff *int64 `json:"percent_off,omitempty"`
271}
272
273type ExchangeCouponUsageRule struct {
274	Threshold     *int64 `json:"threshold,omitempty"`
275	ExchangePrice *int64 `json:"exchange_price,omitempty"`
276}
277
278type CouponUsageMethod string
279
280func (e CouponUsageMethod) Ptr() *CouponUsageMethod {
281	return &e
282}
283
284const (
285	COUPONUSAGEMETHOD_OFFLINE      CouponUsageMethod = "OFFLINE"
286	COUPONUSAGEMETHOD_MINI_PROGRAM CouponUsageMethod = "MINI_PROGRAM"
287	COUPONUSAGEMETHOD_APP          CouponUsageMethod = "APP"
288	COUPONUSAGEMETHOD_PAYMENT_CODE CouponUsageMethod = "PAYMENT_CODE"
289)
290
291type CouponAvailableStoreInfo struct {
292	Description      *string `json:"description,omitempty"`
293	MiniProgramAppid *string `json:"mini_program_appid,omitempty"`
294	MiniProgramPath  *string `json:"mini_program_path,omitempty"`
295}
296
297type CouponCodeDisplayMode string
298
299func (e CouponCodeDisplayMode) Ptr() *CouponCodeDisplayMode {
300	return &e
301}
302
303const (
304	COUPONCODEDISPLAYMODE_INVISIBLE CouponCodeDisplayMode = "INVISIBLE"
305	COUPONCODEDISPLAYMODE_BARCODE   CouponCodeDisplayMode = "BARCODE"
306	COUPONCODEDISPLAYMODE_QRCODE    CouponCodeDisplayMode = "QRCODE"
307)
308
309type EntranceMiniProgram struct {
310	Appid           *string `json:"appid,omitempty"`
311	Path            *string `json:"path,omitempty"`
312	EntranceWording *string `json:"entrance_wording,omitempty"`
313	GuidanceWording *string `json:"guidance_wording,omitempty"`
314}
315
316type EntranceOfficialAccount struct {
317	Appid *string `json:"appid,omitempty"`
318}
319
320type EntranceFinder struct {
321	FinderId                 *string `json:"finder_id,omitempty"`
322	FinderVideoId            *string `json:"finder_video_id,omitempty"`
323	FinderVideoCoverImageUrl *string `json:"finder_video_cover_image_url,omitempty"`
324}
325
326type FixedWeekPeriod struct {
327	DayList       []WeekEnum       `json:"day_list,omitempty"`
328	DayPeriodList []PeriodOfTheDay `json:"day_period_list,omitempty"`
329}
330
331type TimePeriod struct {
332	BeginTime *string `json:"begin_time,omitempty"`
333	EndTime   *string `json:"end_time,omitempty"`
334}
335
336type WeekEnum string
337
338func (e WeekEnum) Ptr() *WeekEnum {
339	return &e
340}
341
342const (
343	WEEKENUM_MONDAY    WeekEnum = "MONDAY"
344	WEEKENUM_TUESDAY   WeekEnum = "TUESDAY"
345	WEEKENUM_WEDNESDAY WeekEnum = "WEDNESDAY"
346	WEEKENUM_THURSDAY  WeekEnum = "THURSDAY"
347	WEEKENUM_FRIDAY    WeekEnum = "FRIDAY"
348	WEEKENUM_SATURDAY  WeekEnum = "SATURDAY"
349	WEEKENUM_SUNDAY    WeekEnum = "SUNDAY"
350)
351
352type PeriodOfTheDay struct {
353	BeginTime *int64 `json:"begin_time,omitempty"`
354	EndTime   *int64 `json:"end_time,omitempty"`
355}
356