更新品牌门店

1curl -X PATCH \
2  https://api.mch.weixin.qq.com/v3/brand/partner/store/brandstores/1234567890123456 \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "brand_id" : "123456789",
8    "store_basics" : {
9      "store_reference_id" : "MDL001",
10      "branch_name" : "海岸城店"
11    },
12    "store_address" : {
13      "address_code" : "440305",
14      "address_detail" : "深南大道10000号腾讯大厦1楼",
15      "address_complements" : "地铁A口右侧100米",
16      "longitude" : "112.63484",
17      "latitude" : "37.75464"
18    },
19    "store_business" : {
20      "service_phone" : "0755-86013388|0755-86013399",
21      "business_hours" : "周一至周五 09:00-20:00|周六至周日 10:00-次日22:00"
22    }
23  }'
24

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 UpdateBrandStore {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "PATCH";
28  private static String PATH = "/v3/brand/partner/store/brandstores/{store_id}";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    UpdateBrandStore client = new UpdateBrandStore(
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    UpdateBrandStoreRequest request = new UpdateBrandStoreRequest();
41    request.storeId = "1234567890123456";
42    request.brandId = "123456789";
43    request.storeBasics = new StoreBase();
44    request.storeBasics.storeReferenceId = "MDL001";
45    request.storeBasics.branchName = "海岸城店";
46    request.storeAddress = new StoreLocation();
47    request.storeAddress.addressCode = "440305";
48    request.storeAddress.addressDetail = "深南大道10000号腾讯大厦1楼";
49    request.storeAddress.addressComplements = "地铁A口右侧100米";
50    request.storeAddress.longitude = "112.63484";
51    request.storeAddress.latitude = "37.75464";
52    request.storeBusiness = new StoreBusiness();
53    request.storeBusiness.servicePhone = "0755-86013388|0755-86013399";
54    request.storeBusiness.businessHours = "周一至周五 09:00-20:00|周六至周日 10:00-次日22:00";
55    try {
56      BrandStoresEntity response = client.run(request);
57        // TODO: 请求成功，继续业务逻辑
58        System.out.println(response);
59    } catch (WXPayUtility.ApiException e) {
60        // TODO: 请求失败，根据状态码执行不同的逻辑
61        e.printStackTrace();
62    }
63  }
64
65  public BrandStoresEntity run(UpdateBrandStoreRequest request) {
66    String uri = PATH;
67    uri = uri.replace("{store_id}", WXPayUtility.urlEncode(request.storeId));
68    String reqBody = WXPayUtility.toJson(request);
69
70    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
71    reqBuilder.addHeader("Accept", "application/json");
72    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
73    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
74    reqBuilder.addHeader("Content-Type", "application/json");
75    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
76    reqBuilder.method(METHOD, requestBody);
77    Request httpRequest = reqBuilder.build();
78
79    // 发送HTTP请求
80    OkHttpClient client = new OkHttpClient.Builder().build();
81    try (Response httpResponse = client.newCall(httpRequest).execute()) {
82      String respBody = WXPayUtility.extractBody(httpResponse);
83      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
84        // 2XX 成功，验证应答签名
85        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
86            httpResponse.headers(), respBody);
87
88        // 从HTTP应答报文构建返回数据
89        return WXPayUtility.fromJson(respBody, BrandStoresEntity.class);
90      } else {
91        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
92      }
93    } catch (IOException e) {
94      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
95    }
96  }
97
98  private final String mchid;
99  private final String certificateSerialNo;
100  private final PrivateKey privateKey;
101  private final String wechatPayPublicKeyId;
102  private final PublicKey wechatPayPublicKey;
103
104  public UpdateBrandStore(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
105    this.mchid = mchid;
106    this.certificateSerialNo = certificateSerialNo;
107    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
108    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
109    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
110  }
111
112  public static class UpdateBrandStoreRequest {
113    @SerializedName("brand_id")
114    public String brandId;
115  
116    @SerializedName("store_id")
117    @Expose(serialize = false)
118    public String storeId;
119  
120    @SerializedName("store_basics")
121    public StoreBase storeBasics;
122  
123    @SerializedName("store_address")
124    public StoreLocation storeAddress;
125  
126    @SerializedName("store_business")
127    public StoreBusiness storeBusiness;
128  }
129  
130  public static class BrandStoresEntity {
131    @SerializedName("brand_id")
132    public String brandId;
133  
134    @SerializedName("store_id")
135    public String storeId;
136  
137    @SerializedName("store_state")
138    public StoreState storeState;
139  
140    @SerializedName("audit_state")
141    public AuditState auditState;
142  
143    @SerializedName("review_reject_reason")
144    public String reviewRejectReason;
145  
146    @SerializedName("store_basics")
147    public StoreBase storeBasics;
148  
149    @SerializedName("store_address")
150    public StoreLocation storeAddress;
151  
152    @SerializedName("store_business")
153    public StoreBusiness storeBusiness;
154  
155    @SerializedName("store_recipient")
156    public List<StoreRecipient> storeRecipient;
157  }
158  
159  public static class StoreBase {
160    @SerializedName("store_reference_id")
161    public String storeReferenceId;
162  
163    @SerializedName("branch_name")
164    public String branchName;
165  }
166  
167  public static class StoreLocation {
168    @SerializedName("address_code")
169    public String addressCode;
170  
171    @SerializedName("address_detail")
172    public String addressDetail;
173  
174    @SerializedName("address_complements")
175    public String addressComplements;
176  
177    @SerializedName("longitude")
178    public String longitude;
179  
180    @SerializedName("latitude")
181    public String latitude;
182  }
183  
184  public static class StoreBusiness {
185    @SerializedName("service_phone")
186    public String servicePhone;
187  
188    @SerializedName("business_hours")
189    public String businessHours;
190  }
191  
192  public enum StoreState {
193    @SerializedName("OPEN")
194    OPEN,
195    @SerializedName("CREATING")
196    CREATING,
197    @SerializedName("CLOSED")
198    CLOSED
199  }
200  
201  public enum AuditState {
202    @SerializedName("SUCCESS")
203    SUCCESS,
204    @SerializedName("PROCESSING")
205    PROCESSING,
206    @SerializedName("REJECTED")
207    REJECTED
208  }
209  
210  public static class StoreRecipient {
211    @SerializedName("mchid")
212    public String mchid;
213  
214    @SerializedName("company_name")
215    public String companyName;
216  
217    @SerializedName("recipient_state")
218    public RecipientState recipientState;
219  }
220  
221  public enum RecipientState {
222    @SerializedName("CONFIRMED")
223    CONFIRMED,
224    @SerializedName("ADMIN_REJECTED")
225    ADMIN_REJECTED,
226    @SerializedName("CONFIRMING")
227    CONFIRMING,
228    @SerializedName("TIMEOUT_REJECTED")
229    TIMEOUT_REJECTED
230  }
231  
232}
233

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)
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 := &UpdateBrandStoreRequest{
28		StoreId: wxpay_utility.String("1234567890123456"),
29		BrandId: wxpay_utility.String("123456789"),
30		StoreBasics: &StoreBase{
31			StoreReferenceId: wxpay_utility.String("MDL001"),
32			BranchName:       wxpay_utility.String("海岸城店"),
33		},
34		StoreAddress: &StoreLocation{
35			AddressCode:        wxpay_utility.String("440305"),
36			AddressDetail:      wxpay_utility.String("深南大道10000号腾讯大厦1楼"),
37			AddressComplements: wxpay_utility.String("地铁A口右侧100米"),
38			Longitude:          wxpay_utility.String("112.63484"),
39			Latitude:           wxpay_utility.String("37.75464"),
40		},
41		StoreBusiness: &StoreBusiness{
42			ServicePhone:  wxpay_utility.String("0755-86013388|0755-86013399"),
43			BusinessHours: wxpay_utility.String("周一至周五 09:00-20:00|周六至周日 10:00-次日22:00"),
44		},
45	}
46
47	response, err := UpdateBrandStore(config, request)
48	if err != nil {
49		fmt.Printf("请求失败: %+v\n", err)
50		// TODO: 请求失败，根据状态码执行不同的处理
51		return
52	}
53
54	// TODO: 请求成功，继续业务逻辑
55	fmt.Printf("请求成功: %+v\n", response)
56}
57
58func UpdateBrandStore(config *wxpay_utility.MchConfig, request *UpdateBrandStoreRequest) (response *BrandStoresEntity, err error) {
59	const (
60		host   = "https://api.mch.weixin.qq.com"
61		method = "PATCH"
62		path   = "/v3/brand/partner/store/brandstores/{store_id}"
63	)
64
65	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
66	if err != nil {
67		return nil, err
68	}
69	reqUrl.Path = strings.Replace(reqUrl.Path, "{store_id}", url.PathEscape(*request.StoreId), -1)
70	reqBody, err := json.Marshal(request)
71	if err != nil {
72		return nil, err
73	}
74	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
75	if err != nil {
76		return nil, err
77	}
78	httpRequest.Header.Set("Accept", "application/json")
79	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
80	httpRequest.Header.Set("Content-Type", "application/json")
81	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
82	if err != nil {
83		return nil, err
84	}
85	httpRequest.Header.Set("Authorization", authorization)
86
87	client := &http.Client{}
88	httpResponse, err := client.Do(httpRequest)
89	if err != nil {
90		return nil, err
91	}
92	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
93	if err != nil {
94		return nil, err
95	}
96	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
97		// 2XX 成功，验证应答签名
98		err = wxpay_utility.ValidateResponse(
99			config.WechatPayPublicKeyId(),
100			config.WechatPayPublicKey(),
101			&httpResponse.Header,
102			respBody,
103		)
104		if err != nil {
105			return nil, err
106		}
107		response := &BrandStoresEntity{}
108		if err := json.Unmarshal(respBody, response); err != nil {
109			return nil, err
110		}
111
112		return response, nil
113	} else {
114		return nil, wxpay_utility.NewApiException(
115			httpResponse.StatusCode,
116			httpResponse.Header,
117			respBody,
118		)
119	}
120}
121
122type UpdateBrandStoreRequest struct {
123	BrandId       *string        `json:"brand_id,omitempty"`
124	StoreId       *string        `json:"store_id,omitempty"`
125	StoreBasics   *StoreBase     `json:"store_basics,omitempty"`
126	StoreAddress  *StoreLocation `json:"store_address,omitempty"`
127	StoreBusiness *StoreBusiness `json:"store_business,omitempty"`
128}
129
130func (o *UpdateBrandStoreRequest) MarshalJSON() ([]byte, error) {
131	type Alias UpdateBrandStoreRequest
132	a := &struct {
133		StoreId *string `json:"store_id,omitempty"`
134		*Alias
135	}{
136		// 序列化时移除非 Body 字段
137		StoreId: nil,
138		Alias:   (*Alias)(o),
139	}
140	return json.Marshal(a)
141}
142
143type BrandStoresEntity struct {
144	BrandId            *string          `json:"brand_id,omitempty"`
145	StoreId            *string          `json:"store_id,omitempty"`
146	StoreState         *StoreState      `json:"store_state,omitempty"`
147	AuditState         *AuditState      `json:"audit_state,omitempty"`
148	ReviewRejectReason *string          `json:"review_reject_reason,omitempty"`
149	StoreBasics        *StoreBase       `json:"store_basics,omitempty"`
150	StoreAddress       *StoreLocation   `json:"store_address,omitempty"`
151	StoreBusiness      *StoreBusiness   `json:"store_business,omitempty"`
152	StoreRecipient     []StoreRecipient `json:"store_recipient,omitempty"`
153}
154
155type StoreBase struct {
156	StoreReferenceId *string `json:"store_reference_id,omitempty"`
157	BranchName       *string `json:"branch_name,omitempty"`
158}
159
160type StoreLocation struct {
161	AddressCode        *string `json:"address_code,omitempty"`
162	AddressDetail      *string `json:"address_detail,omitempty"`
163	AddressComplements *string `json:"address_complements,omitempty"`
164	Longitude          *string `json:"longitude,omitempty"`
165	Latitude           *string `json:"latitude,omitempty"`
166}
167
168type StoreBusiness struct {
169	ServicePhone  *string `json:"service_phone,omitempty"`
170	BusinessHours *string `json:"business_hours,omitempty"`
171}
172
173type StoreState string
174
175func (e StoreState) Ptr() *StoreState {
176	return &e
177}
178
179const (
180	STORESTATE_OPEN     StoreState = "OPEN"
181	STORESTATE_CREATING StoreState = "CREATING"
182	STORESTATE_CLOSED   StoreState = "CLOSED"
183)
184
185type AuditState string
186
187func (e AuditState) Ptr() *AuditState {
188	return &e
189}
190
191const (
192	AUDITSTATE_SUCCESS    AuditState = "SUCCESS"
193	AUDITSTATE_PROCESSING AuditState = "PROCESSING"
194	AUDITSTATE_REJECTED   AuditState = "REJECTED"
195)
196
197type StoreRecipient struct {
198	Mchid          *string         `json:"mchid,omitempty"`
199	CompanyName    *string         `json:"company_name,omitempty"`
200	RecipientState *RecipientState `json:"recipient_state,omitempty"`
201}
202
203type RecipientState string
204
205func (e RecipientState) Ptr() *RecipientState {
206	return &e
207}
208
209const (
210	RECIPIENTSTATE_CONFIRMED        RecipientState = "CONFIRMED"
211	RECIPIENTSTATE_ADMIN_REJECTED   RecipientState = "ADMIN_REJECTED"
212	RECIPIENTSTATE_CONFIRMING       RecipientState = "CONFIRMING"
213	RECIPIENTSTATE_TIMEOUT_REJECTED RecipientState = "TIMEOUT_REJECTED"
214)
215