作废用户会员卡

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	"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 := &InvalidateUserCardRequest{
29		UserCardCode:  wxpay_brand_utility.String("478515832665"),
30		CardId:        wxpay_brand_utility.String("pbLatjvWOibDc5-TBnbUk1pD12o0"),
31		Openid:        wxpay_brand_utility.String("obLatjnx9gnqzS4myYGmLZ7LgLBA"),
32		InvalidReason: wxpay_brand_utility.String("传入的自定义作废原因"),
33	}
34
35	response, err := InvalidateUserCard(config, request)
36	if err != nil {
37		fmt.Printf("请求失败: %+v\n", err)
38		// TODO: 请求失败，根据状态码执行不同的处理
39		return
40	}
41
42	// TODO: 请求成功，继续业务逻辑
43	fmt.Printf("请求成功: %+v\n", response)
44}
45
46func InvalidateUserCard(config *wxpay_brand_utility.BrandConfig, request *InvalidateUserCardRequest) (response *UserCard, err error) {
47	const (
48		host   = "https://api.mch.weixin.qq.com"
49		method = "POST"
50		path   = "/brand/card-member/user-cards/{user_card_code}/invalidate"
51	)
52
53	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
54	if err != nil {
55		return nil, err
56	}
57	reqUrl.Path = strings.Replace(reqUrl.Path, "{user_card_code}", url.PathEscape(*request.UserCardCode), -1)
58	reqBody, err := json.Marshal(request)
59	if err != nil {
60		return nil, err
61	}
62	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
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	httpRequest.Header.Set("Content-Type", "application/json")
69	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
70	if err != nil {
71		return nil, err
72	}
73	httpRequest.Header.Set("Authorization", authorization)
74
75	client := &http.Client{}
76	httpResponse, err := client.Do(httpRequest)
77	if err != nil {
78		return nil, err
79	}
80	respBody, err := wxpay_brand_utility.ExtractResponseBody(httpResponse)
81	if err != nil {
82		return nil, err
83	}
84	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
85		// 2XX 成功，验证应答签名
86		err = wxpay_brand_utility.ValidateResponse(
87			config.WechatPayPublicKeyId(),
88			config.WechatPayPublicKey(),
89			&httpResponse.Header,
90			respBody,
91		)
92		if err != nil {
93			return nil, err
94		}
95		response := &UserCard{}
96		if err := json.Unmarshal(respBody, response); err != nil {
97			return nil, err
98		}
99
100		return response, nil
101	} else {
102		return nil, wxpay_brand_utility.NewApiException(
103			httpResponse.StatusCode,
104			httpResponse.Header,
105			respBody,
106		)
107	}
108}
109
110type InvalidateUserCardRequest struct {
111	CardId        *string `json:"card_id,omitempty"`
112	UserCardCode  *string `json:"user_card_code,omitempty"`
113	Openid        *string `json:"openid,omitempty"`
114	InvalidReason *string `json:"invalid_reason,omitempty"`
115}
116
117func (o *InvalidateUserCardRequest) MarshalJSON() ([]byte, error) {
118	type Alias InvalidateUserCardRequest
119	a := &struct {
120		UserCardCode *string `json:"user_card_code,omitempty"`
121		*Alias
122	}{
123		// 序列化时移除非 Body 字段
124		UserCardCode: nil,
125		Alias:        (*Alias)(o),
126	}
127	return json.Marshal(a)
128}
129
130type UserCard struct {
131	UserCardCode         *string        `json:"user_card_code,omitempty"`
132	CardId               *string        `json:"card_id,omitempty"`
133	Openid               *string        `json:"openid,omitempty"`
134	CardColor            *string        `json:"card_color,omitempty"`
135	CardPictureUrl       *string        `json:"card_picture_url,omitempty"`
136	BrandId              *string        `json:"brand_id,omitempty"`
137	CardType             *CardType      `json:"card_type,omitempty"`
138	PhoneNumber          *string        `json:"phone_number,omitempty"`
139	Level                *string        `json:"level,omitempty"`
140	ValidDateInformation *DateInfo      `json:"valid_date_information,omitempty"`
141	PickupTime           *string        `json:"pickup_time,omitempty"`
142	UserInformation      *UserInfo      `json:"user_information,omitempty"`
143	Attach               *string        `json:"attach,omitempty"`
144	UserCardState        *UserCardState `json:"user_card_state,omitempty"`
145	InvalidReason        *string        `json:"invalid_reason,omitempty"`
146	InvalidTime          *string        `json:"invalid_time,omitempty"`
147	CreateTime           *time.Time     `json:"create_time,omitempty"`
148	ModifyTime           *time.Time     `json:"modify_time,omitempty"`
149}
150
151type CardType string
152
153func (e CardType) Ptr() *CardType {
154	return &e
155}
156
157const (
158	CARDTYPE_PURCHASE CardType = "PURCHASE"
159	CARDTYPE_NORMAL   CardType = "NORMAL"
160	CARDTYPE_BALANCE  CardType = "BALANCE"
161)
162
163type DateInfo struct {
164	Type                     *DateType  `json:"type,omitempty"`
165	AvailableBeginTime       *time.Time `json:"available_begin_time,omitempty"`
166	AvailableEndTime         *time.Time `json:"available_end_time,omitempty"`
167	AvailableDayAfterReceive *int64     `json:"available_day_after_receive,omitempty"`
168}
169
170type UserInfo struct {
171	CommonFieldList []UserInfoCommonField `json:"common_field_list,omitempty"`
172	CustomFieldList []UserInfoCustomField `json:"custom_field_list,omitempty"`
173}
174
175type UserCardState string
176
177func (e UserCardState) Ptr() *UserCardState {
178	return &e
179}
180
181const (
182	USERCARDSTATE_UNACTIVATED UserCardState = "UNACTIVATED"
183	USERCARDSTATE_EFFECTIVE   UserCardState = "EFFECTIVE"
184	USERCARDSTATE_EXPIRED     UserCardState = "EXPIRED"
185	USERCARDSTATE_INVALID     UserCardState = "INVALID"
186)
187
188type DateType string
189
190func (e DateType) Ptr() *DateType {
191	return &e
192}
193
194const (
195	DATETYPE_FIX_TIME_RANGE DateType = "FIX_TIME_RANGE"
196	DATETYPE_FIX_TERM       DateType = "FIX_TERM"
197	DATETYPE_PERMANENT      DateType = "PERMANENT"
198)
199
200type UserInfoCommonField struct {
201	Name  *CommonFieldFlag `json:"name,omitempty"`
202	Value *string          `json:"value,omitempty"`
203}
204
205type UserInfoCustomField struct {
206	Name             *string  `json:"name,omitempty"`
207	UserChosenValues []string `json:"user_chosen_values,omitempty"`
208}
209
210type CommonFieldFlag string
211
212func (e CommonFieldFlag) Ptr() *CommonFieldFlag {
213	return &e
214}
215
216const (
217	COMMONFIELDFLAG_USER_FORM_FLAG_SEX      CommonFieldFlag = "USER_FORM_FLAG_SEX"
218	COMMONFIELDFLAG_USER_FORM_FLAG_NAME     CommonFieldFlag = "USER_FORM_FLAG_NAME"
219	COMMONFIELDFLAG_USER_FORM_FLAG_BIRTHDAY CommonFieldFlag = "USER_FORM_FLAG_BIRTHDAY"
220	COMMONFIELDFLAG_USER_FORM_FLAG_ADDRESS  CommonFieldFlag = "USER_FORM_FLAG_ADDRESS"
221	COMMONFIELDFLAG_USER_FORM_FLAG_EMAIL    CommonFieldFlag = "USER_FORM_FLAG_EMAIL"
222	COMMONFIELDFLAG_USER_FORM_FLAG_CITY     CommonFieldFlag = "USER_FORM_FLAG_CITY"
223)
224