作废用户会员卡

1curl -X POST \
2  https://api.mch.weixin.qq.com/brand/card-member/user-cards/478515832665/invalidate \
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    "card_id" : "pbLatjvWOibDc5-TBnbUk1pD12o0",
9    "openid" : "obLatjnx9gnqzS4myYGmLZ7LgLBA",
10    "invalid_reason" : "传入的自定义作废原因"
11  }'
12

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 InvalidateUserCard {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/brand/card-member/user-cards/{user_card_code}/invalidate";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
32    InvalidateUserCard client = new InvalidateUserCard(
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    InvalidateUserCardRequest request = new InvalidateUserCardRequest();
41    request.userCardCode = "478515832665";
42    request.cardId = "pbLatjvWOibDc5-TBnbUk1pD12o0";
43    request.openid = "obLatjnx9gnqzS4myYGmLZ7LgLBA";
44    request.invalidReason = "传入的自定义作废原因";
45    try {
46      UserCard response = client.run(request);
47        // TODO: 请求成功，继续业务逻辑
48        System.out.println(response);
49    } catch (WXPayBrandUtility.ApiException e) {
50        // TODO: 请求失败，根据状态码执行不同的逻辑
51        e.printStackTrace();
52    }
53  }
54
55  public UserCard run(InvalidateUserCardRequest request) {
56    String uri = PATH;
57    uri = uri.replace("{user_card_code}", WXPayBrandUtility.urlEncode(request.userCardCode));
58    String reqBody = WXPayBrandUtility.toJson(request);
59
60    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
61    reqBuilder.addHeader("Accept", "application/json");
62    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
63    reqBuilder.addHeader("Authorization", WXPayBrandUtility.buildAuthorization(brand_id, certificateSerialNo,privateKey, METHOD, uri, reqBody));
64    reqBuilder.addHeader("Content-Type", "application/json");
65    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
66    reqBuilder.method(METHOD, requestBody);
67    Request httpRequest = reqBuilder.build();
68
69    // 发送HTTP请求
70    OkHttpClient client = new OkHttpClient.Builder().build();
71    try (Response httpResponse = client.newCall(httpRequest).execute()) {
72      String respBody = WXPayBrandUtility.extractBody(httpResponse);
73      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
74        // 2XX 成功，验证应答签名
75        WXPayBrandUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
76            httpResponse.headers(), respBody);
77
78        // 从HTTP应答报文构建返回数据
79        return WXPayBrandUtility.fromJson(respBody, UserCard.class);
80      } else {
81        throw new WXPayBrandUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
82      }
83    } catch (IOException e) {
84      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
85    }
86  }
87
88  private final String brand_id;
89  private final String certificateSerialNo;
90  private final PrivateKey privateKey;
91  private final String wechatPayPublicKeyId;
92  private final PublicKey wechatPayPublicKey;
93
94  public InvalidateUserCard(String brand_id, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
95    this.brand_id = brand_id;
96    this.certificateSerialNo = certificateSerialNo;
97    this.privateKey = WXPayBrandUtility.loadPrivateKeyFromPath(privateKeyFilePath);
98    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
99    this.wechatPayPublicKey = WXPayBrandUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
100  }
101
102  public static class InvalidateUserCardRequest {
103    @SerializedName("card_id")
104    public String cardId;
105  
106    @SerializedName("user_card_code")
107    @Expose(serialize = false)
108    public String userCardCode;
109  
110    @SerializedName("openid")
111    public String openid;
112  
113    @SerializedName("invalid_reason")
114    public String invalidReason;
115  }
116  
117  public static class UserCard {
118    @SerializedName("user_card_code")
119    public String userCardCode;
120  
121    @SerializedName("card_id")
122    public String cardId;
123  
124    @SerializedName("openid")
125    public String openid;
126  
127    @SerializedName("card_color")
128    public String cardColor;
129  
130    @SerializedName("card_picture_url")
131    public String cardPictureUrl;
132  
133    @SerializedName("brand_id")
134    public String brandId;
135  
136    @SerializedName("card_type")
137    public CardType cardType;
138  
139    @SerializedName("phone_number")
140    public String phoneNumber;
141  
142    @SerializedName("level")
143    public String level;
144  
145    @SerializedName("valid_date_information")
146    public DateInfo validDateInformation;
147  
148    @SerializedName("pickup_time")
149    public String pickupTime;
150  
151    @SerializedName("user_information")
152    public UserInfo userInformation;
153  
154    @SerializedName("attach")
155    public String attach;
156  
157    @SerializedName("user_card_state")
158    public UserCardState userCardState;
159  
160    @SerializedName("invalid_reason")
161    public String invalidReason;
162  
163    @SerializedName("invalid_time")
164    public String invalidTime;
165  
166    @SerializedName("create_time")
167    public String createTime;
168  
169    @SerializedName("modify_time")
170    public String modifyTime;
171  }
172  
173  public enum CardType {
174    @SerializedName("PURCHASE")
175    PURCHASE,
176    @SerializedName("NORMAL")
177    NORMAL,
178    @SerializedName("BALANCE")
179    BALANCE
180  }
181  
182  public static class DateInfo {
183    @SerializedName("type")
184    public DateType type;
185  
186    @SerializedName("available_begin_time")
187    public String availableBeginTime;
188  
189    @SerializedName("available_end_time")
190    public String availableEndTime;
191  
192    @SerializedName("available_day_after_receive")
193    public Long availableDayAfterReceive;
194  }
195  
196  public static class UserInfo {
197    @SerializedName("common_field_list")
198    public List<UserInfoCommonField> commonFieldList;
199  
200    @SerializedName("custom_field_list")
201    public List<UserInfoCustomField> customFieldList;
202  }
203  
204  public enum UserCardState {
205    @SerializedName("UNACTIVATED")
206    UNACTIVATED,
207    @SerializedName("EFFECTIVE")
208    EFFECTIVE,
209    @SerializedName("EXPIRED")
210    EXPIRED,
211    @SerializedName("INVALID")
212    INVALID
213  }
214  
215  public enum DateType {
216    @SerializedName("FIX_TIME_RANGE")
217    FIX_TIME_RANGE,
218    @SerializedName("FIX_TERM")
219    FIX_TERM,
220    @SerializedName("PERMANENT")
221    PERMANENT
222  }
223  
224  public static class UserInfoCommonField {
225    @SerializedName("name")
226    public CommonFieldFlag name;
227  
228    @SerializedName("value")
229    public String value;
230  }
231  
232  public static class UserInfoCustomField {
233    @SerializedName("name")
234    public String name;
235  
236    @SerializedName("user_chosen_values")
237    public List<String> userChosenValues;
238  }
239  
240  public enum CommonFieldFlag {
241    @SerializedName("USER_FORM_FLAG_SEX")
242    USER_FORM_FLAG_SEX,
243    @SerializedName("USER_FORM_FLAG_NAME")
244    USER_FORM_FLAG_NAME,
245    @SerializedName("USER_FORM_FLAG_BIRTHDAY")
246    USER_FORM_FLAG_BIRTHDAY,
247    @SerializedName("USER_FORM_FLAG_ADDRESS")
248    USER_FORM_FLAG_ADDRESS,
249    @SerializedName("USER_FORM_FLAG_EMAIL")
250    USER_FORM_FLAG_EMAIL,
251    @SerializedName("USER_FORM_FLAG_CITY")
252    USER_FORM_FLAG_CITY
253  }
254  
255}
256

1package main
2
3import (
4	"bytes"
5	"demo/wxpay_brand_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/brand/4015826866
6	"encoding/json"
7	"fmt"
8	"net/http"
9	"net/url"
10	"strings"
11)
12
13func main() {
14	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
15	config, err := wxpay_brand_utility.CreateBrandConfig(
16		"xxxxxxxx",                   // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
17		"1DDE55AD98Exxxxxxxxxx",      // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
18		"/path/to/apiclient_key.pem", // 品牌API证书私钥文件路径，本地文件路径
19		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
20		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
21	)
22	if err != nil {
23		fmt.Println(err)
24		return
25	}
26
27	request := &InvalidateUserCardRequest{
28		UserCardCode:  wxpay_brand_utility.String("478515832665"),
29		CardId:        wxpay_brand_utility.String("pbLatjvWOibDc5-TBnbUk1pD12o0"),
30		Openid:        wxpay_brand_utility.String("obLatjnx9gnqzS4myYGmLZ7LgLBA"),
31		InvalidReason: wxpay_brand_utility.String("传入的自定义作废原因"),
32	}
33
34	response, err := InvalidateUserCard(config, request)
35	if err != nil {
36		fmt.Printf("请求失败: %+v\n", err)
37		// TODO: 请求失败，根据状态码执行不同的处理
38		return
39	}
40
41	// TODO: 请求成功，继续业务逻辑
42	fmt.Printf("请求成功: %+v\n", response)
43}
44
45func InvalidateUserCard(config *wxpay_brand_utility.BrandConfig, request *InvalidateUserCardRequest) (response *UserCard, err error) {
46	const (
47		host   = "https://api.mch.weixin.qq.com"
48		method = "POST"
49		path   = "/brand/card-member/user-cards/{user_card_code}/invalidate"
50	)
51
52	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
53	if err != nil {
54		return nil, err
55	}
56	reqUrl.Path = strings.Replace(reqUrl.Path, "{user_card_code}", url.PathEscape(*request.UserCardCode), -1)
57	reqBody, err := json.Marshal(request)
58	if err != nil {
59		return nil, err
60	}
61	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
62	if err != nil {
63		return nil, err
64	}
65	httpRequest.Header.Set("Accept", "application/json")
66	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
67	httpRequest.Header.Set("Content-Type", "application/json")
68	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
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_brand_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_brand_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 := &UserCard{}
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_brand_utility.NewApiException(
102			httpResponse.StatusCode,
103			httpResponse.Header,
104			respBody,
105		)
106	}
107}
108
109type InvalidateUserCardRequest struct {
110	CardId        *string `json:"card_id,omitempty"`
111	UserCardCode  *string `json:"user_card_code,omitempty"`
112	Openid        *string `json:"openid,omitempty"`
113	InvalidReason *string `json:"invalid_reason,omitempty"`
114}
115
116func (o *InvalidateUserCardRequest) MarshalJSON() ([]byte, error) {
117	type Alias InvalidateUserCardRequest
118	a := &struct {
119		UserCardCode *string `json:"user_card_code,omitempty"`
120		*Alias
121	}{
122		// 序列化时移除非 Body 字段
123		UserCardCode: nil,
124		Alias:        (*Alias)(o),
125	}
126	return json.Marshal(a)
127}
128
129type UserCard struct {
130	UserCardCode         *string        `json:"user_card_code,omitempty"`
131	CardId               *string        `json:"card_id,omitempty"`
132	Openid               *string        `json:"openid,omitempty"`
133	CardColor            *string        `json:"card_color,omitempty"`
134	CardPictureUrl       *string        `json:"card_picture_url,omitempty"`
135	BrandId              *string        `json:"brand_id,omitempty"`
136	CardType             *CardType      `json:"card_type,omitempty"`
137	PhoneNumber          *string        `json:"phone_number,omitempty"`
138	Level                *string        `json:"level,omitempty"`
139	ValidDateInformation *DateInfo      `json:"valid_date_information,omitempty"`
140	PickupTime           *string        `json:"pickup_time,omitempty"`
141	UserInformation      *UserInfo      `json:"user_information,omitempty"`
142	Attach               *string        `json:"attach,omitempty"`
143	UserCardState        *UserCardState `json:"user_card_state,omitempty"`
144	InvalidReason        *string        `json:"invalid_reason,omitempty"`
145	InvalidTime          *string        `json:"invalid_time,omitempty"`
146	CreateTime           *string        `json:"create_time,omitempty"`
147	ModifyTime           *string        `json:"modify_time,omitempty"`
148}
149
150type CardType string
151
152func (e CardType) Ptr() *CardType {
153	return &e
154}
155
156const (
157	CARDTYPE_PURCHASE CardType = "PURCHASE"
158	CARDTYPE_NORMAL   CardType = "NORMAL"
159	CARDTYPE_BALANCE  CardType = "BALANCE"
160)
161
162type DateInfo struct {
163	Type                     *DateType `json:"type,omitempty"`
164	AvailableBeginTime       *string   `json:"available_begin_time,omitempty"`
165	AvailableEndTime         *string   `json:"available_end_time,omitempty"`
166	AvailableDayAfterReceive *int64    `json:"available_day_after_receive,omitempty"`
167}
168
169type UserInfo struct {
170	CommonFieldList []UserInfoCommonField `json:"common_field_list,omitempty"`
171	CustomFieldList []UserInfoCustomField `json:"custom_field_list,omitempty"`
172}
173
174type UserCardState string
175
176func (e UserCardState) Ptr() *UserCardState {
177	return &e
178}
179
180const (
181	USERCARDSTATE_UNACTIVATED UserCardState = "UNACTIVATED"
182	USERCARDSTATE_EFFECTIVE   UserCardState = "EFFECTIVE"
183	USERCARDSTATE_EXPIRED     UserCardState = "EXPIRED"
184	USERCARDSTATE_INVALID     UserCardState = "INVALID"
185)
186
187type DateType string
188
189func (e DateType) Ptr() *DateType {
190	return &e
191}
192
193const (
194	DATETYPE_FIX_TIME_RANGE DateType = "FIX_TIME_RANGE"
195	DATETYPE_FIX_TERM       DateType = "FIX_TERM"
196	DATETYPE_PERMANENT      DateType = "PERMANENT"
197)
198
199type UserInfoCommonField struct {
200	Name  *CommonFieldFlag `json:"name,omitempty"`
201	Value *string          `json:"value,omitempty"`
202}
203
204type UserInfoCustomField struct {
205	Name             *string  `json:"name,omitempty"`
206	UserChosenValues []string `json:"user_chosen_values,omitempty"`
207}
208
209type CommonFieldFlag string
210
211func (e CommonFieldFlag) Ptr() *CommonFieldFlag {
212	return &e
213}
214
215const (
216	COMMONFIELDFLAG_USER_FORM_FLAG_SEX      CommonFieldFlag = "USER_FORM_FLAG_SEX"
217	COMMONFIELDFLAG_USER_FORM_FLAG_NAME     CommonFieldFlag = "USER_FORM_FLAG_NAME"
218	COMMONFIELDFLAG_USER_FORM_FLAG_BIRTHDAY CommonFieldFlag = "USER_FORM_FLAG_BIRTHDAY"
219	COMMONFIELDFLAG_USER_FORM_FLAG_ADDRESS  CommonFieldFlag = "USER_FORM_FLAG_ADDRESS"
220	COMMONFIELDFLAG_USER_FORM_FLAG_EMAIL    CommonFieldFlag = "USER_FORM_FLAG_EMAIL"
221	COMMONFIELDFLAG_USER_FORM_FLAG_CITY     CommonFieldFlag = "USER_FORM_FLAG_CITY"
222)
223