更新品牌门店

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

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"),
43			BusinessHours: wxpay_utility.String("周一至周五 09:00-20: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
93	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
94	if err != nil {
95		return nil, err
96	}
97
98	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
99		// 2XX 成功，验证应答签名
100		err = wxpay_utility.ValidateResponse(
101			config.WechatPayPublicKeyId(),
102			config.WechatPayPublicKey(),
103			&httpResponse.Header,
104			respBody,
105		)
106		if err != nil {
107			return nil, err
108		}
109
110		response := &BrandStoresEntity{}
111		if err := json.Unmarshal(respBody, response); err != nil {
112			return nil, err
113		}
114
115		return response, nil
116	} else {
117		return nil, wxpay_utility.NewApiException(
118			httpResponse.StatusCode,
119			httpResponse.Header,
120			respBody,
121		)
122	}
123}
124
125type UpdateBrandStoreRequest struct {
126	BrandId       *string        `json:"brand_id,omitempty"`
127	StoreId       *string        `json:"store_id,omitempty"`
128	StoreBasics   *StoreBase     `json:"store_basics,omitempty"`
129	StoreAddress  *StoreLocation `json:"store_address,omitempty"`
130	StoreBusiness *StoreBusiness `json:"store_business,omitempty"`
131}
132
133func (o *UpdateBrandStoreRequest) MarshalJSON() ([]byte, error) {
134	type Alias UpdateBrandStoreRequest
135	a := &struct {
136		StoreId *string `json:"store_id,omitempty"`
137		*Alias
138	}{
139		// 序列化时移除非 Body 字段
140		StoreId: nil,
141		Alias:   (*Alias)(o),
142	}
143	return json.Marshal(a)
144}
145
146type BrandStoresEntity struct {
147	BrandId            *string          `json:"brand_id,omitempty"`
148	StoreId            *string          `json:"store_id,omitempty"`
149	StoreState         *StoreState      `json:"store_state,omitempty"`
150	AuditState         *AuditState      `json:"audit_state,omitempty"`
151	ReviewRejectReason *string          `json:"review_reject_reason,omitempty"`
152	StoreBasics        *StoreBase       `json:"store_basics,omitempty"`
153	StoreAddress       *StoreLocation   `json:"store_address,omitempty"`
154	StoreBusiness      *StoreBusiness   `json:"store_business,omitempty"`
155	StoreRecipient     []StoreRecipient `json:"store_recipient,omitempty"`
156}
157
158type StoreBase struct {
159	StoreReferenceId *string `json:"store_reference_id,omitempty"`
160	BranchName       *string `json:"branch_name,omitempty"`
161}
162
163type StoreLocation struct {
164	AddressCode        *string `json:"address_code,omitempty"`
165	AddressDetail      *string `json:"address_detail,omitempty"`
166	AddressComplements *string `json:"address_complements,omitempty"`
167	Longitude          *string `json:"longitude,omitempty"`
168	Latitude           *string `json:"latitude,omitempty"`
169}
170
171type StoreBusiness struct {
172	ServicePhone  *string `json:"service_phone,omitempty"`
173	BusinessHours *string `json:"business_hours,omitempty"`
174}
175
176type StoreState string
177
178func (e StoreState) Ptr() *StoreState {
179	return &e
180}
181
182const (
183	STORESTATE_OPEN     StoreState = "OPEN"
184	STORESTATE_CREATING StoreState = "CREATING"
185	STORESTATE_CLOSED   StoreState = "CLOSED"
186)
187
188type AuditState string
189
190func (e AuditState) Ptr() *AuditState {
191	return &e
192}
193
194const (
195	AUDITSTATE_SUCCESS    AuditState = "SUCCESS"
196	AUDITSTATE_PROCESSING AuditState = "PROCESSING"
197	AUDITSTATE_REJECTED   AuditState = "REJECTED"
198)
199
200type StoreRecipient struct {
201	Mchid          *string         `json:"mchid,omitempty"`
202	CompanyName    *string         `json:"company_name,omitempty"`
203	RecipientState *RecipientState `json:"recipient_state,omitempty"`
204}
205
206type RecipientState string
207
208func (e RecipientState) Ptr() *RecipientState {
209	return &e
210}
211
212const (
213	RECIPIENTSTATE_CONFIRMED        RecipientState = "CONFIRMED"
214	RECIPIENTSTATE_ADMIN_REJECTED   RecipientState = "ADMIN_REJECTED"
215	RECIPIENTSTATE_CONFIRMING       RecipientState = "CONFIRMING"
216	RECIPIENTSTATE_TIMEOUT_REJECTED RecipientState = "TIMEOUT_REJECTED"
217)
218

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",
21      "business_hours" : "周一至周五 09:00-20:00"
22    }
23  }'
24