查询商品券指定批次

1curl -X GET \
2  https://api.mch.weixin.qq.com/v3/marketing/partner/product-coupon/product-coupons/200000001/stocks/123456789?brand_id=120344 \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" 
5

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

1package main
2
3import (
4	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
5	"encoding/json"
6	"fmt"
7	"net/http"
8	"net/url"
9	"strings"
10	"time"
11)
12
13func main() {
14	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
15	config, err := wxpay_utility.CreateMchConfig(
16		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
17		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
18		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
19		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
20		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
21	)
22	if err != nil {
23		fmt.Println(err)
24		return
25	}
26
27	request := &GetStockRequest{
28		ProductCouponId: wxpay_utility.String("200000001"),
29		StockId:         wxpay_utility.String("123456789"),
30		BrandId:         wxpay_utility.String("120344"),
31	}
32
33	response, err := GetStock(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 GetStock(config *wxpay_utility.MchConfig, request *GetStockRequest) (response *StockEntity, err error) {
45	const (
46		host   = "https://api.mch.weixin.qq.com"
47		method = "GET"
48		path   = "/v3/marketing/partner/product-coupon/product-coupons/{product_coupon_id}/stocks/{stock_id}"
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	reqUrl.Path = strings.Replace(reqUrl.Path, "{stock_id}", url.PathEscape(*request.StockId), -1)
57	query := reqUrl.Query()
58	if request.BrandId != nil {
59		query.Add("brand_id", *request.BrandId)
60	}
61	reqUrl.RawQuery = query.Encode()
62	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
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	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
69	if err != nil {
70		return nil, err
71	}
72	httpRequest.Header.Set("Authorization", authorization)
73
74	client := &http.Client{}
75	httpResponse, err := client.Do(httpRequest)
76	if err != nil {
77		return nil, err
78	}
79	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
80	if err != nil {
81		return nil, err
82	}
83	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
84		// 2XX 成功，验证应答签名
85		err = wxpay_utility.ValidateResponse(
86			config.WechatPayPublicKeyId(),
87			config.WechatPayPublicKey(),
88			&httpResponse.Header,
89			respBody,
90		)
91		if err != nil {
92			return nil, err
93		}
94		response := &StockEntity{}
95		if err := json.Unmarshal(respBody, response); err != nil {
96			return nil, err
97		}
98
99		return response, nil
100	} else {
101		return nil, wxpay_utility.NewApiException(
102			httpResponse.StatusCode,
103			httpResponse.Header,
104			respBody,
105		)
106	}
107}
108
109type GetStockRequest struct {
110	ProductCouponId *string `json:"product_coupon_id,omitempty"`
111	StockId         *string `json:"stock_id,omitempty"`
112	BrandId         *string `json:"brand_id,omitempty"`
113}
114
115func (o *GetStockRequest) MarshalJSON() ([]byte, error) {
116	type Alias GetStockRequest
117	a := &struct {
118		ProductCouponId *string `json:"product_coupon_id,omitempty"`
119		StockId         *string `json:"stock_id,omitempty"`
120		BrandId         *string `json:"brand_id,omitempty"`
121		*Alias
122	}{
123		// 序列化时移除非 Body 字段
124		ProductCouponId: nil,
125		StockId:         nil,
126		BrandId:         nil,
127		Alias:           (*Alias)(o),
128	}
129	return json.Marshal(a)
130}
131
132type StockEntity struct {
133	ProductCouponId      *string               `json:"product_coupon_id,omitempty"`
134	StockId              *string               `json:"stock_id,omitempty"`
135	Remark               *string               `json:"remark,omitempty"`
136	CouponCodeMode       *CouponCodeMode       `json:"coupon_code_mode,omitempty"`
137	CouponCodeCountInfo  *CouponCodeCountInfo  `json:"coupon_code_count_info,omitempty"`
138	StockSendRule        *StockSendRule        `json:"stock_send_rule,omitempty"`
139	SingleUsageRule      *SingleUsageRule      `json:"single_usage_rule,omitempty"`
140	SequentialUsageRule  *SequentialUsageRule  `json:"sequential_usage_rule,omitempty"`
141	UsageRuleDisplayInfo *UsageRuleDisplayInfo `json:"usage_rule_display_info,omitempty"`
142	CouponDisplayInfo    *CouponDisplayInfo    `json:"coupon_display_info,omitempty"`
143	NotifyConfig         *NotifyConfig         `json:"notify_config,omitempty"`
144	StoreScope           *StockStoreScope      `json:"store_scope,omitempty"`
145	SentCountInfo        *StockSentCountInfo   `json:"sent_count_info,omitempty"`
146	State                *StockState           `json:"state,omitempty"`
147	DeactivateRequestNo  *string               `json:"deactivate_request_no,omitempty"`
148	DeactivateTime       *time.Time            `json:"deactivate_time,omitempty"`
149	DeactivateReason     *string               `json:"deactivate_reason,omitempty"`
150	BrandId              *string               `json:"brand_id,omitempty"`
151}
152
153type CouponCodeMode string
154
155func (e CouponCodeMode) Ptr() *CouponCodeMode {
156	return &e
157}
158
159const (
160	COUPONCODEMODE_WECHATPAY  CouponCodeMode = "WECHATPAY"
161	COUPONCODEMODE_UPLOAD     CouponCodeMode = "UPLOAD"
162	COUPONCODEMODE_API_ASSIGN CouponCodeMode = "API_ASSIGN"
163)
164
165type CouponCodeCountInfo struct {
166	TotalCount     *int64 `json:"total_count,omitempty"`
167	AvailableCount *int64 `json:"available_count,omitempty"`
168}
169
170type StockSendRule struct {
171	MaxCount        *int64 `json:"max_count,omitempty"`
172	MaxCountPerDay  *int64 `json:"max_count_per_day,omitempty"`
173	MaxCountPerUser *int64 `json:"max_count_per_user,omitempty"`
174}
175
176type SingleUsageRule struct {
177	CouponAvailablePeriod *SingleCouponAvailablePeriod `json:"coupon_available_period,omitempty"`
178	NormalCoupon          *NormalCouponUsageRule       `json:"normal_coupon,omitempty"`
179	DiscountCoupon        *DiscountCouponUsageRule     `json:"discount_coupon,omitempty"`
180	ExchangeCoupon        *ExchangeCouponUsageRule     `json:"exchange_coupon,omitempty"`
181}
182
183type SequentialUsageRule struct {
184	CouponAvailablePeriod *SequentialCouponAvailablePeriod `json:"coupon_available_period,omitempty"`
185	NormalCouponList      []NormalCouponUsageRule          `json:"normal_coupon_list,omitempty"`
186	DiscountCouponList    []DiscountCouponUsageRule        `json:"discount_coupon_list,omitempty"`
187	ExchangeCouponList    []ExchangeCouponUsageRule        `json:"exchange_coupon_list,omitempty"`
188	SpecialFirst          *bool                            `json:"special_first,omitempty"`
189}
190
191type UsageRuleDisplayInfo struct {
192	CouponUsageMethodList    []CouponUsageMethod       `json:"coupon_usage_method_list,omitempty"`
193	MiniProgramAppid         *string                   `json:"mini_program_appid,omitempty"`
194	MiniProgramPath          *string                   `json:"mini_program_path,omitempty"`
195	AppPath                  *string                   `json:"app_path,omitempty"`
196	UsageDescription         *string                   `json:"usage_description,omitempty"`
197	CouponAvailableStoreInfo *CouponAvailableStoreInfo `json:"coupon_available_store_info,omitempty"`
198}
199
200type CouponDisplayInfo struct {
201	CodeDisplayMode         *CouponCodeDisplayMode   `json:"code_display_mode,omitempty"`
202	BackgroundColor         *string                  `json:"background_color,omitempty"`
203	EntranceMiniProgram     *EntranceMiniProgram     `json:"entrance_mini_program,omitempty"`
204	EntranceOfficialAccount *EntranceOfficialAccount `json:"entrance_official_account,omitempty"`
205	EntranceFinder          *EntranceFinder          `json:"entrance_finder,omitempty"`
206}
207
208type NotifyConfig struct {
209	NotifyAppid *string `json:"notify_appid,omitempty"`
210}
211
212type StockStoreScope string
213
214func (e StockStoreScope) Ptr() *StockStoreScope {
215	return &e
216}
217
218const (
219	STOCKSTORESCOPE_NONE     StockStoreScope = "NONE"
220	STOCKSTORESCOPE_ALL      StockStoreScope = "ALL"
221	STOCKSTORESCOPE_SPECIFIC StockStoreScope = "SPECIFIC"
222)
223
224type StockSentCountInfo struct {
225	TotalCount *int64 `json:"total_count,omitempty"`
226	TodayCount *int64 `json:"today_count,omitempty"`
227}
228
229type StockState string
230
231func (e StockState) Ptr() *StockState {
232	return &e
233}
234
235const (
236	STOCKSTATE_AUDITING    StockState = "AUDITING"
237	STOCKSTATE_SENDING     StockState = "SENDING"
238	STOCKSTATE_PAUSED      StockState = "PAUSED"
239	STOCKSTATE_STOPPED     StockState = "STOPPED"
240	STOCKSTATE_DEACTIVATED StockState = "DEACTIVATED"
241)
242
243type SingleCouponAvailablePeriod struct {
244	AvailableBeginTime           *string          `json:"available_begin_time,omitempty"`
245	AvailableEndTime             *string          `json:"available_end_time,omitempty"`
246	AvailableDays                *int64           `json:"available_days,omitempty"`
247	WaitDaysAfterReceive         *int64           `json:"wait_days_after_receive,omitempty"`
248	WeeklyAvailablePeriod        *FixedWeekPeriod `json:"weekly_available_period,omitempty"`
249	IrregularAvailablePeriodList []TimePeriod     `json:"irregular_available_period_list,omitempty"`
250}
251
252type NormalCouponUsageRule struct {
253	Threshold      *int64 `json:"threshold,omitempty"`
254	DiscountAmount *int64 `json:"discount_amount,omitempty"`
255}
256
257type DiscountCouponUsageRule struct {
258	Threshold  *int64 `json:"threshold,omitempty"`
259	PercentOff *int64 `json:"percent_off,omitempty"`
260}
261
262type ExchangeCouponUsageRule struct {
263	Threshold     *int64 `json:"threshold,omitempty"`
264	ExchangePrice *int64 `json:"exchange_price,omitempty"`
265}
266
267type SequentialCouponAvailablePeriod struct {
268	AvailableBeginTime           *string          `json:"available_begin_time,omitempty"`
269	AvailableEndTime             *string          `json:"available_end_time,omitempty"`
270	WaitDaysAfterReceive         *int64           `json:"wait_days_after_receive,omitempty"`
271	WeeklyAvailablePeriod        *FixedWeekPeriod `json:"weekly_available_period,omitempty"`
272	IrregularAvailablePeriodList []TimePeriod     `json:"irregular_available_period_list,omitempty"`
273}
274
275type CouponUsageMethod string
276
277func (e CouponUsageMethod) Ptr() *CouponUsageMethod {
278	return &e
279}
280
281const (
282	COUPONUSAGEMETHOD_OFFLINE      CouponUsageMethod = "OFFLINE"
283	COUPONUSAGEMETHOD_MINI_PROGRAM CouponUsageMethod = "MINI_PROGRAM"
284	COUPONUSAGEMETHOD_APP          CouponUsageMethod = "APP"
285	COUPONUSAGEMETHOD_PAYMENT_CODE CouponUsageMethod = "PAYMENT_CODE"
286)
287
288type CouponAvailableStoreInfo struct {
289	Description      *string `json:"description,omitempty"`
290	MiniProgramAppid *string `json:"mini_program_appid,omitempty"`
291	MiniProgramPath  *string `json:"mini_program_path,omitempty"`
292}
293
294type CouponCodeDisplayMode string
295
296func (e CouponCodeDisplayMode) Ptr() *CouponCodeDisplayMode {
297	return &e
298}
299
300const (
301	COUPONCODEDISPLAYMODE_INVISIBLE CouponCodeDisplayMode = "INVISIBLE"
302	COUPONCODEDISPLAYMODE_BARCODE   CouponCodeDisplayMode = "BARCODE"
303	COUPONCODEDISPLAYMODE_QRCODE    CouponCodeDisplayMode = "QRCODE"
304)
305
306type EntranceMiniProgram struct {
307	Appid           *string `json:"appid,omitempty"`
308	Path            *string `json:"path,omitempty"`
309	EntranceWording *string `json:"entrance_wording,omitempty"`
310	GuidanceWording *string `json:"guidance_wording,omitempty"`
311}
312
313type EntranceOfficialAccount struct {
314	Appid *string `json:"appid,omitempty"`
315}
316
317type EntranceFinder struct {
318	FinderId                 *string `json:"finder_id,omitempty"`
319	FinderVideoId            *string `json:"finder_video_id,omitempty"`
320	FinderVideoCoverImageUrl *string `json:"finder_video_cover_image_url,omitempty"`
321}
322
323type FixedWeekPeriod struct {
324	DayList       []WeekEnum       `json:"day_list,omitempty"`
325	DayPeriodList []PeriodOfTheDay `json:"day_period_list,omitempty"`
326}
327
328type TimePeriod struct {
329	BeginTime *string `json:"begin_time,omitempty"`
330	EndTime   *string `json:"end_time,omitempty"`
331}
332
333type WeekEnum string
334
335func (e WeekEnum) Ptr() *WeekEnum {
336	return &e
337}
338
339const (
340	WEEKENUM_MONDAY    WeekEnum = "MONDAY"
341	WEEKENUM_TUESDAY   WeekEnum = "TUESDAY"
342	WEEKENUM_WEDNESDAY WeekEnum = "WEDNESDAY"
343	WEEKENUM_THURSDAY  WeekEnum = "THURSDAY"
344	WEEKENUM_FRIDAY    WeekEnum = "FRIDAY"
345	WEEKENUM_SATURDAY  WeekEnum = "SATURDAY"
346	WEEKENUM_SUNDAY    WeekEnum = "SUNDAY"
347)
348
349type PeriodOfTheDay struct {
350	BeginTime *int64 `json:"begin_time,omitempty"`
351	EndTime   *int64 `json:"end_time,omitempty"`
352}
353