根据商户号查用户的券

1curl -X GET \
2  https://api.mch.weixin.qq.com/v3/marketing/favor/users/openid_example/coupons?appid=appid_example&stock_id=9865000&status=USED&business_type=MULTIUSE&creator_mchid=9865002&available_mchid=9865000&offset=0&limit=20 \
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 ListCouponsByFilter {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "GET";
28  private static String PATH = "/v3/marketing/favor/users/{openid}/coupons";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    ListCouponsByFilter client = new ListCouponsByFilter(
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    ListCouponsByFilterRequest request = new ListCouponsByFilterRequest();
41    request.openid = "openid_example";
42    request.appid = "appid_example";
43    request.stockId = "9865000";
44    request.status = "USED";
45    request.businessType = BusinessType.MULTIUSE;
46    request.creatorMchid = "9865002";
47    request.availableMchid = "9865000";
48    request.offset = 0L;
49    request.limit = 20L;
50    try {
51      CouponCollection response = client.run(request);
52        // TODO: 请求成功，继续业务逻辑
53        System.out.println(response);
54    } catch (WXPayUtility.ApiException e) {
55        // TODO: 请求失败，根据状态码执行不同的逻辑
56        e.printStackTrace();
57    }
58  }
59
60  public CouponCollection run(ListCouponsByFilterRequest request) {
61    String uri = PATH;
62    uri = uri.replace("{openid}", WXPayUtility.urlEncode(request.openid));
63    Map<String, Object> args = new HashMap<>();
64    args.put("appid", request.appid);
65    args.put("stock_id", request.stockId);
66    args.put("status", request.status);
67    args.put("business_type", request.businessType);
68    args.put("creator_mchid", request.creatorMchid);
69    args.put("available_mchid", request.availableMchid);
70    args.put("offset", request.offset);
71    args.put("limit", request.limit);
72    String queryString = WXPayUtility.urlEncode(args);
73    if (!queryString.isEmpty()) {
74        uri = uri + "?" + queryString;
75    }
76
77    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
78    reqBuilder.addHeader("Accept", "application/json");
79    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
80    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo, privateKey, METHOD, uri, null));
81    reqBuilder.method(METHOD, null);
82    Request httpRequest = reqBuilder.build();
83
84    // 发送HTTP请求
85    OkHttpClient client = new OkHttpClient.Builder().build();
86    try (Response httpResponse = client.newCall(httpRequest).execute()) {
87      String respBody = WXPayUtility.extractBody(httpResponse);
88      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
89        // 2XX 成功，验证应答签名
90        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
91            httpResponse.headers(), respBody);
92
93        // 从HTTP应答报文构建返回数据
94        return WXPayUtility.fromJson(respBody, CouponCollection.class);
95      } else {
96        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
97      }
98    } catch (IOException e) {
99      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
100    }
101  }
102
103  private final String mchid;
104  private final String certificateSerialNo;
105  private final PrivateKey privateKey;
106  private final String wechatPayPublicKeyId;
107  private final PublicKey wechatPayPublicKey;
108
109  public ListCouponsByFilter(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
110    this.mchid = mchid;
111    this.certificateSerialNo = certificateSerialNo;
112    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
113    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
114    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
115  }
116
117  public static class ListCouponsByFilterRequest {
118    @SerializedName("openid")
119    @Expose(serialize = false)
120    public String openid;
121  
122    @SerializedName("appid")
123    @Expose(serialize = false)
124    public String appid;
125  
126    @SerializedName("stock_id")
127    @Expose(serialize = false)
128    public String stockId;
129  
130    @SerializedName("status")
131    @Expose(serialize = false)
132    public String status;
133  
134    @SerializedName("creator_mchid")
135    @Expose(serialize = false)
136    public String creatorMchid;
137  
138    @SerializedName("available_mchid")
139    @Expose(serialize = false)
140    public String availableMchid;
141  
142    @SerializedName("offset")
143    @Expose(serialize = false)
144    public Long offset;
145  
146    @SerializedName("limit")
147    @Expose(serialize = false)
148    public Long limit;
149  
150    @SerializedName("business_type")
151    @Expose(serialize = false)
152    public BusinessType businessType;
153  }
154  
155  public static class CouponCollection {
156    @SerializedName("data")
157    public List<Coupon> data;
158  
159    @SerializedName("total_count")
160    public Long totalCount;
161  
162    @SerializedName("limit")
163    public Long limit;
164  
165    @SerializedName("offset")
166    public Long offset;
167  }
168  
169  public enum BusinessType {
170    @SerializedName("MULTIUSE")
171    MULTIUSE
172  }
173  
174  public static class Coupon {
175    @SerializedName("stock_creator_mchid")
176    public String stockCreatorMchid;
177  
178    @SerializedName("stock_id")
179    public String stockId;
180  
181    @SerializedName("coupon_id")
182    public String couponId;
183  
184    @SerializedName("cut_to_message")
185    public CutTypeMsg cutToMessage;
186  
187    @SerializedName("coupon_name")
188    public String couponName;
189  
190    @SerializedName("status")
191    public String status;
192  
193    @SerializedName("description")
194    public String description;
195  
196    @SerializedName("create_time")
197    public String createTime;
198  
199    @SerializedName("coupon_type")
200    public String couponType;
201  
202    @SerializedName("no_cash")
203    public Boolean noCash;
204  
205    @SerializedName("available_begin_time")
206    public String availableBeginTime;
207  
208    @SerializedName("available_end_time")
209    public String availableEndTime;
210  
211    @SerializedName("singleitem")
212    public Boolean singleitem;
213  
214    @SerializedName("normal_coupon_information")
215    public FixedValueStockMsg normalCouponInformation;
216  
217    @SerializedName("out_request_no")
218    public String outRequestNo;
219  
220    @SerializedName("available_balance")
221    public Long availableBalance;
222  
223    @SerializedName("business_type")
224    public BusinessType businessType;
225  
226    @SerializedName("discount_msg")
227    public DiscountMsg discountMsg;
228  }
229  
230  public static class CutTypeMsg {
231    @SerializedName("single_price_max")
232    public Long singlePriceMax;
233  
234    @SerializedName("cut_to_price")
235    public Long cutToPrice;
236  }
237  
238  public static class FixedValueStockMsg {
239    @SerializedName("coupon_amount")
240    public Long couponAmount;
241  
242    @SerializedName("transaction_minimum")
243    public Long transactionMinimum;
244  }
245  
246  public static class DiscountMsg {
247    @SerializedName("discount_amount_max")
248    public Long discountAmountMax;
249  
250    @SerializedName("discount_percent")
251    public Long discountPercent;
252  
253    @SerializedName("transaction_minimum")
254    public Long transactionMinimum;
255  }
256  
257}
258

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)
11
12func main() {
13	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
14	config, err := wxpay_utility.CreateMchConfig(
15		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
16		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
17		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
18		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
19		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
20	)
21	if err != nil {
22		fmt.Println(err)
23		return
24	}
25
26	request := &ListCouponsByFilterRequest{
27		Openid:         wxpay_utility.String("Openid_example"),
28		Appid:          wxpay_utility.String("Appid_example"),
29		StockId:        wxpay_utility.String("9865000"),
30		Status:         wxpay_utility.String("USED"),
31		BusinessType:   BUSINESSTYPE_MULTIUSE.Ptr(),
32		CreatorMchid:   wxpay_utility.String("9865002"),
33		AvailableMchid: wxpay_utility.String("9865000"),
34		Offset:         wxpay_utility.Int64(0),
35		Limit:          wxpay_utility.Int64(20),
36	}
37
38	response, err := ListCouponsByFilter(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 ListCouponsByFilter(config *wxpay_utility.MchConfig, request *ListCouponsByFilterRequest) (response *CouponCollection, err error) {
50	const (
51		host   = "https://api.mch.weixin.qq.com"
52		method = "GET"
53		path   = "/v3/marketing/favor/users/{openid}/coupons"
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, "{openid}", url.PathEscape(*request.Openid), -1)
61	query := reqUrl.Query()
62	if request.Appid != nil {
63		query.Add("appid", *request.Appid)
64	}
65	if request.StockId != nil {
66		query.Add("stock_id", *request.StockId)
67	}
68	if request.Status != nil {
69		query.Add("status", *request.Status)
70	}
71	if request.BusinessType != nil {
72		query.Add("business_type", fmt.Sprintf("%v", *request.BusinessType))
73	}
74	if request.CreatorMchid != nil {
75		query.Add("creator_mchid", *request.CreatorMchid)
76	}
77	if request.AvailableMchid != nil {
78		query.Add("available_mchid", *request.AvailableMchid)
79	}
80	if request.Offset != nil {
81		query.Add("offset", fmt.Sprintf("%v", *request.Offset))
82	}
83	if request.Limit != nil {
84		query.Add("limit", fmt.Sprintf("%v", *request.Limit))
85	}
86	reqUrl.RawQuery = query.Encode()
87	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
88	if err != nil {
89		return nil, err
90	}
91	httpRequest.Header.Set("Accept", "application/json")
92	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
93	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
94	if err != nil {
95		return nil, err
96	}
97	httpRequest.Header.Set("Authorization", authorization)
98
99	client := &http.Client{}
100	httpResponse, err := client.Do(httpRequest)
101	if err != nil {
102		return nil, err
103	}
104	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
105	if err != nil {
106		return nil, err
107	}
108	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
109		// 2XX 成功，验证应答签名
110		err = wxpay_utility.ValidateResponse(
111			config.WechatPayPublicKeyId(),
112			config.WechatPayPublicKey(),
113			&httpResponse.Header,
114			respBody,
115		)
116		if err != nil {
117			return nil, err
118		}
119		response := &CouponCollection{}
120		if err := json.Unmarshal(respBody, response); err != nil {
121			return nil, err
122		}
123
124		return response, nil
125	} else {
126		return nil, wxpay_utility.NewApiException(
127			httpResponse.StatusCode,
128			httpResponse.Header,
129			respBody,
130		)
131	}
132}
133
134type ListCouponsByFilterRequest struct {
135	Openid         *string       `json:"openid,omitempty"`
136	Appid          *string       `json:"appid,omitempty"`
137	StockId        *string       `json:"stock_id,omitempty"`
138	Status         *string       `json:"status,omitempty"`
139	CreatorMchid   *string       `json:"creator_mchid,omitempty"`
140	AvailableMchid *string       `json:"available_mchid,omitempty"`
141	Offset         *int64        `json:"offset,omitempty"`
142	Limit          *int64        `json:"limit,omitempty"`
143	BusinessType   *BusinessType `json:"business_type,omitempty"`
144}
145
146func (o *ListCouponsByFilterRequest) MarshalJSON() ([]byte, error) {
147	type Alias ListCouponsByFilterRequest
148	a := &struct {
149		Openid         *string       `json:"openid,omitempty"`
150		Appid          *string       `json:"appid,omitempty"`
151		StockId        *string       `json:"stock_id,omitempty"`
152		Status         *string       `json:"status,omitempty"`
153		CreatorMchid   *string       `json:"creator_mchid,omitempty"`
154		AvailableMchid *string       `json:"available_mchid,omitempty"`
155		Offset         *int64        `json:"offset,omitempty"`
156		Limit          *int64        `json:"limit,omitempty"`
157		BusinessType   *BusinessType `json:"business_type,omitempty"`
158		*Alias
159	}{
160		// 序列化时移除非 Body 字段
161		Openid:         nil,
162		Appid:          nil,
163		StockId:        nil,
164		Status:         nil,
165		CreatorMchid:   nil,
166		AvailableMchid: nil,
167		Offset:         nil,
168		Limit:          nil,
169		BusinessType:   nil,
170		Alias:          (*Alias)(o),
171	}
172	return json.Marshal(a)
173}
174
175type CouponCollection struct {
176	Data       []Coupon `json:"data,omitempty"`
177	TotalCount *int64   `json:"total_count,omitempty"`
178	Limit      *int64   `json:"limit,omitempty"`
179	Offset     *int64   `json:"offset,omitempty"`
180}
181
182type BusinessType string
183
184func (e BusinessType) Ptr() *BusinessType {
185	return &e
186}
187
188const (
189	BUSINESSTYPE_MULTIUSE BusinessType = "MULTIUSE"
190)
191
192type Coupon struct {
193	StockCreatorMchid       *string             `json:"stock_creator_mchid,omitempty"`
194	StockId                 *string             `json:"stock_id,omitempty"`
195	CouponId                *string             `json:"coupon_id,omitempty"`
196	CutToMessage            *CutTypeMsg         `json:"cut_to_message,omitempty"`
197	CouponName              *string             `json:"coupon_name,omitempty"`
198	Status                  *string             `json:"status,omitempty"`
199	Description             *string             `json:"description,omitempty"`
200	CreateTime              *string             `json:"create_time,omitempty"`
201	CouponType              *string             `json:"coupon_type,omitempty"`
202	NoCash                  *bool               `json:"no_cash,omitempty"`
203	AvailableBeginTime      *string             `json:"available_begin_time,omitempty"`
204	AvailableEndTime        *string             `json:"available_end_time,omitempty"`
205	Singleitem              *bool               `json:"singleitem,omitempty"`
206	NormalCouponInformation *FixedValueStockMsg `json:"normal_coupon_information,omitempty"`
207	OutRequestNo            *string             `json:"out_request_no,omitempty"`
208	AvailableBalance        *int64              `json:"available_balance,omitempty"`
209	BusinessType            *BusinessType       `json:"business_type,omitempty"`
210	DiscountMsg             *DiscountMsg        `json:"discount_msg,omitempty"`
211}
212
213type CutTypeMsg struct {
214	SinglePriceMax *int64 `json:"single_price_max,omitempty"`
215	CutToPrice     *int64 `json:"cut_to_price,omitempty"`
216}
217
218type FixedValueStockMsg struct {
219	CouponAmount       *int64 `json:"coupon_amount,omitempty"`
220	TransactionMinimum *int64 `json:"transaction_minimum,omitempty"`
221}
222
223type DiscountMsg struct {
224	DiscountAmountMax  *int64 `json:"discount_amount_max,omitempty"`
225	DiscountPercent    *int64 `json:"discount_percent,omitempty"`
226	TransactionMinimum *int64 `json:"transaction_minimum,omitempty"`
227}
228