提交入驻申请

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/brand/applyments \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Wechatpay-Serial: 5157F09EFDC096DE15EBE81A47057A7232F1B8E1"  \
6  -H "Content-Type: application/json" \
7  -d '{
8    "business_code" : "1900013511_10000",
9    "admin_info" : {
10      "admin_name" : "U2FsdGVkX1+3vZQv5+9JhTq3Xy6LdKjP0o9iYx5W7vRtNqY3sDfGhJkLmNbVcXz4Qw1UbP6oE8iC=",
11      "id_doc_type" : "IDENTIFICATION_TYPE_MAINLAND_ID_CARD",
12      "id_card_number" : "AOZdYGISxo4y44/UgZ69bdu9X+tfMUJ9dl+LetjM45/zMbrYu+wWZ8gn4CTdo+D/m9MrPg+V4sm73oxqdQu/hj7aWyDl4GQtPXVdaztB9jVbVZh3QFzV+BEmytMNQp9dt1uWJktlfdDdLR3AMWyMB377xd+m9bSr/ioDTzagEcGe+vLYiKrzcroQv3OR0p3ppFYoQ3IfYeU/04S4t9rNFL+kyblK2FCCqQ11NdbbHoCrJc7NV4oASq6ZFonjTtgjjgKsadIKHXtb3JZKGZjduGdtkRJJp0/0eow96uY1Pk7Rq79Jtt7+I8juwEc4P4TG5xzchG/5IL9DBd+Z0zZXkw=="
13    },
14    "subject_info" : {
15      "subject_type" : "SUBJECT_TYPE_ENTERPRISE",
16      "subject_name" : "xx有限公司",
17      "unified_social_credit_code" : "91310101MA1FPX1234"
18    },
19    "brand_basic_info" : {
20      "brand_name" : "爱马哥",
21      "brand_logo" : "U2FsdGVkX1+8n2qLk9jP4vRtY6Wx1Zc3DqF7sH0mNpBvY2Tq5X9gLkE4wRz1oU6IcJ8mVfA0sBd="
22    },
23    "trademark" : {
24      "trademark_exists" : "TRADEMARK_EXISTS",
25      "trademark_registration_certificate" : {
26        "certificate" : "jTpGmxUX3FBWVQ5NJTZvvDujqhThn4ReFxikqJ5YW6zFQ",
27        "name" : "爱马哥",
28        "number" : "12345678",
29        "valid_begin_time" : "2025-09-08",
30        "valid_end_time" : "2035-09-08",
31        "international_class" : "25",
32        "holder" : "腾讯科技有限公司",
33        "license" : "jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ",
34        "authorization_begin_time" : "2025-09-08",
35        "authorization_end_time" : "2035-09-08"
36      },
37      "logo_trademark_registration_certificate" : {
38        "certificate" : "jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ",
39        "name" : "爱马哥",
40        "number" : "21312344",
41        "valid_begin_time" : "2025-09-08",
42        "valid_end_time" : "2035-09-08",
43        "international_class" : "25",
44        "holder" : "腾讯科技有限公司",
45        "license" : "jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ",
46        "authorization_begin_time" : "2025-09-08",
47        "authorization_end_time" : "2035-09-08"
48      },
49      "no_trademark_addition_prove" : "jTpGmxUX3FBWVQ5NJTZvvDujqhThn4ReFxikqJ5YW6zFQ"
50    }
51  }'
52

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 SubmitApplyment {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/brand/applyments";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    SubmitApplyment client = new SubmitApplyment(
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    SubmitApplyRequest request = new SubmitApplyRequest();
41    request.businessCode = "1900013511_10000";
42    request.adminInfo = new AdminInfo();
43    request.adminInfo.adminName = client.encrypt("admin_name");
44    request.adminInfo.idDocType = IdentificationType.IDENTIFICATION_TYPE_MAINLAND_ID_CARD;
45    request.adminInfo.idCardNumber = client.encrypt("id_card_number");
46    request.subjectInfo = new SubjectInfo();
47    request.subjectInfo.subjectType = SubjectType.SUBJECT_TYPE_ENTERPRISE;
48    request.subjectInfo.subjectName = "xx有限公司";
49    request.subjectInfo.unifiedSocialCreditCode = "91310101MA1FPX1234";
50    request.brandBasicInfo = new BrandBasicInfo();
51    request.brandBasicInfo.brandName = "爱马哥";
52    request.brandBasicInfo.brandLogo = "U2FsdGVkX1+8n2qLk9jP4vRtY6Wx1Zc3DqF7sH0mNpBvY2Tq5X9gLkE4wRz1oU6IcJ8mVfA0sBd=";
53    request.trademark = new Trademark();
54    request.trademark.trademarkExists = TrademarkState.TRADEMARK_EXISTS;
55    request.trademark.trademarkRegistrationCertificate = new TrademarkRegCert();
56    request.trademark.trademarkRegistrationCertificate.certificate = "jTpGmxUX3FBWVQ5NJTZvvDujqhThn4ReFxikqJ5YW6zFQ";
57    request.trademark.trademarkRegistrationCertificate.name = "爱马哥";
58    request.trademark.trademarkRegistrationCertificate.number = "12345678";
59    request.trademark.trademarkRegistrationCertificate.validBeginTime = "2025-09-08";
60    request.trademark.trademarkRegistrationCertificate.validEndTime = "2035-09-08";
61    request.trademark.trademarkRegistrationCertificate.internationalClass = "25";
62    request.trademark.trademarkRegistrationCertificate.holder = "腾讯科技有限公司";
63    request.trademark.trademarkRegistrationCertificate.license = "jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ";
64    request.trademark.trademarkRegistrationCertificate.authorizationBeginTime = "2025-09-08";
65    request.trademark.trademarkRegistrationCertificate.authorizationEndTime = "2035-09-08";
66    request.trademark.logoTrademarkRegistrationCertificate = new LogoTrademarkRegCert();
67    request.trademark.logoTrademarkRegistrationCertificate.certificate = "jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ";
68    request.trademark.logoTrademarkRegistrationCertificate.name = "爱马哥";
69    request.trademark.logoTrademarkRegistrationCertificate.number = "21312344";
70    request.trademark.logoTrademarkRegistrationCertificate.validBeginTime = "2025-09-08";
71    request.trademark.logoTrademarkRegistrationCertificate.validEndTime = "2035-09-08";
72    request.trademark.logoTrademarkRegistrationCertificate.internationalClass = "25";
73    request.trademark.logoTrademarkRegistrationCertificate.holder = "腾讯科技有限公司";
74    request.trademark.logoTrademarkRegistrationCertificate.license = "jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ";
75    request.trademark.logoTrademarkRegistrationCertificate.authorizationBeginTime = "2025-09-08";
76    request.trademark.logoTrademarkRegistrationCertificate.authorizationEndTime = "2035-09-08";
77    request.trademark.noTrademarkAdditionProve = "jTpGmxUX3FBWVQ5NJTZvvDujqhThn4ReFxikqJ5YW6zFQ";
78    try {
79      SubmitApplyResponse response = client.run(request);
80        // TODO: 请求成功，继续业务逻辑
81        System.out.println(response);
82    } catch (WXPayUtility.ApiException e) {
83        // TODO: 请求失败，根据状态码执行不同的逻辑
84        e.printStackTrace();
85    }
86  }
87
88  public SubmitApplyResponse run(SubmitApplyRequest request) {
89    String uri = PATH;
90    String reqBody = WXPayUtility.toJson(request);
91
92    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
93    reqBuilder.addHeader("Accept", "application/json");
94    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
95    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
96    reqBuilder.addHeader("Content-Type", "application/json");
97    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
98    reqBuilder.method(METHOD, requestBody);
99    Request httpRequest = reqBuilder.build();
100
101    // 发送HTTP请求
102    OkHttpClient client = new OkHttpClient.Builder().build();
103    try (Response httpResponse = client.newCall(httpRequest).execute()) {
104      String respBody = WXPayUtility.extractBody(httpResponse);
105      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
106        // 2XX 成功，验证应答签名
107        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
108            httpResponse.headers(), respBody);
109
110        // 从HTTP应答报文构建返回数据
111        return WXPayUtility.fromJson(respBody, SubmitApplyResponse.class);
112      } else {
113        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
114      }
115    } catch (IOException e) {
116      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
117    }
118  }
119
120  private final String mchid;
121  private final String certificateSerialNo;
122  private final PrivateKey privateKey;
123  private final String wechatPayPublicKeyId;
124  private final PublicKey wechatPayPublicKey;
125
126  public SubmitApplyment(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
127    this.mchid = mchid;
128    this.certificateSerialNo = certificateSerialNo;
129    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
130    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
131    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
132  }
133
134  public String encrypt(String plainText) {
135    return WXPayUtility.encrypt(this.wechatPayPublicKey, plainText);
136  }
137
138  public static class SubmitApplyRequest {
139    @SerializedName("business_code")
140    public String businessCode;
141  
142    @SerializedName("admin_info")
143    public AdminInfo adminInfo;
144  
145    @SerializedName("subject_info")
146    public SubjectInfo subjectInfo;
147  
148    @SerializedName("brand_basic_info")
149    public BrandBasicInfo brandBasicInfo;
150  
151    @SerializedName("trademark")
152    public Trademark trademark;
153  }
154  
155  public static class SubmitApplyResponse {
156    @SerializedName("applyment_id")
157    public String applymentId;
158  
159    @SerializedName("business_code")
160    public String businessCode;
161  }
162  
163  public static class AdminInfo {
164    @SerializedName("admin_name")
165    public String adminName;
166  
167    @SerializedName("id_doc_type")
168    public IdentificationType idDocType;
169  
170    @SerializedName("id_card_number")
171    public String idCardNumber;
172  }
173  
174  public static class SubjectInfo {
175    @SerializedName("subject_type")
176    public SubjectType subjectType;
177  
178    @SerializedName("subject_name")
179    public String subjectName;
180  
181    @SerializedName("unified_social_credit_code")
182    public String unifiedSocialCreditCode;
183  }
184  
185  public static class BrandBasicInfo {
186    @SerializedName("brand_name")
187    public String brandName;
188  
189    @SerializedName("brand_logo")
190    public String brandLogo;
191  }
192  
193  public static class Trademark {
194    @SerializedName("trademark_exists")
195    public TrademarkState trademarkExists;
196  
197    @SerializedName("trademark_registration_certificate")
198    public TrademarkRegCert trademarkRegistrationCertificate;
199  
200    @SerializedName("logo_trademark_registration_certificate")
201    public LogoTrademarkRegCert logoTrademarkRegistrationCertificate;
202  
203    @SerializedName("no_trademark_addition_prove")
204    public String noTrademarkAdditionProve;
205  }
206  
207  public enum IdentificationType {
208    @SerializedName("IDENTIFICATION_TYPE_MAINLAND_ID_CARD")
209    IDENTIFICATION_TYPE_MAINLAND_ID_CARD,
210    @SerializedName("IDENTIFICATION_TYPE_HONGKONG")
211    IDENTIFICATION_TYPE_HONGKONG,
212    @SerializedName("IDENTIFICATION_TYPE_MACAO")
213    IDENTIFICATION_TYPE_MACAO,
214    @SerializedName("IDENTIFICATION_TYPE_TAIWAN")
215    IDENTIFICATION_TYPE_TAIWAN,
216    @SerializedName("IDENTIFICATION_TYPE_HONGKONG_MACAO_RESIDENT")
217    IDENTIFICATION_TYPE_HONGKONG_MACAO_RESIDENT,
218    @SerializedName("IDENTIFICATION_TYPE_TAIWAN_RESIDENT")
219    IDENTIFICATION_TYPE_TAIWAN_RESIDENT
220  }
221  
222  public enum SubjectType {
223    @SerializedName("SUBJECT_TYPE_ENTERPRISE")
224    SUBJECT_TYPE_ENTERPRISE,
225    @SerializedName("SUBJECT_TYPE_INDIVIDUAL")
226    SUBJECT_TYPE_INDIVIDUAL
227  }
228  
229  public enum TrademarkState {
230    @SerializedName("TRADEMARK_EXISTS")
231    TRADEMARK_EXISTS,
232    @SerializedName("TRADEMARK_NONE")
233    TRADEMARK_NONE
234  }
235  
236  public static class TrademarkRegCert {
237    @SerializedName("certificate")
238    public String certificate;
239  
240    @SerializedName("name")
241    public String name;
242  
243    @SerializedName("number")
244    public String number;
245  
246    @SerializedName("valid_begin_time")
247    public String validBeginTime;
248  
249    @SerializedName("valid_end_time")
250    public String validEndTime;
251  
252    @SerializedName("international_class")
253    public String internationalClass;
254  
255    @SerializedName("holder")
256    public String holder;
257  
258    @SerializedName("license")
259    public String license;
260  
261    @SerializedName("authorization_begin_time")
262    public String authorizationBeginTime;
263  
264    @SerializedName("authorization_end_time")
265    public String authorizationEndTime;
266  }
267  
268  public static class LogoTrademarkRegCert {
269    @SerializedName("certificate")
270    public String certificate;
271  
272    @SerializedName("name")
273    public String name;
274  
275    @SerializedName("number")
276    public String number;
277  
278    @SerializedName("valid_begin_time")
279    public String validBeginTime;
280  
281    @SerializedName("valid_end_time")
282    public String validEndTime;
283  
284    @SerializedName("international_class")
285    public String internationalClass;
286  
287    @SerializedName("holder")
288    public String holder;
289  
290    @SerializedName("license")
291    public String license;
292  
293    @SerializedName("authorization_begin_time")
294    public String authorizationBeginTime;
295  
296    @SerializedName("authorization_end_time")
297    public String authorizationEndTime;
298  }
299  
300}
301

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)
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 := &SubmitApplyRequest{
27		BusinessCode: wxpay_utility.String("1900013511_10000"),
28		AdminInfo: &AdminInfo{
29			AdminName:    wxpay_utility.String("U2FsdGVkX1+3vZQv5+9JhTq3Xy6LdKjP0o9iYx5W7vRtNqY3sDfGhJkLmNbVcXz4Qw1UbP6oE8iC="), /*请传入wxpay_utility.EncryptOAEPWithPublicKey 加密结果*/
30			IdDocType:    IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_MAINLAND_ID_CARD.Ptr(),
31			IdCardNumber: wxpay_utility.String("AOZdYGISxo4y44/UgZ69bdu9X+tfMUJ9dl+LetjM45/zMbrYu+wWZ8gn4CTdo+D/m9MrPg+V4sm73oxqdQu/hj7aWyDl4GQtPXVdaztB9jVbVZh3QFzV+BEmytMNQp9dt1uWJktlfdDdLR3AMWyMB377xd+m9bSr/ioDTzagEcGe+vLYiKrzcroQv3OR0p3ppFYoQ3IfYeU/04S4t9rNFL+kyblK2FCCqQ11NdbbHoCrJc7NV4oASq6ZFonjTtgjjgKsadIKHXtb3JZKGZjduGdtkRJJp0/0eow96uY1Pk7Rq79Jtt7+I8juwEc4P4TG5xzchG/5IL9DBd+Z0zZXkw=="), /*请传入wxpay_utility.EncryptOAEPWithPublicKey 加密结果*/
32		},
33		SubjectInfo: &SubjectInfo{
34			SubjectType:             SUBJECTTYPE_SUBJECT_TYPE_ENTERPRISE.Ptr(),
35			SubjectName:             wxpay_utility.String("xx有限公司"),
36			UnifiedSocialCreditCode: wxpay_utility.String("91310101MA1FPX1234"),
37		},
38		BrandBasicInfo: &BrandBasicInfo{
39			BrandName: wxpay_utility.String("爱马哥"),
40			BrandLogo: wxpay_utility.String("U2FsdGVkX1+8n2qLk9jP4vRtY6Wx1Zc3DqF7sH0mNpBvY2Tq5X9gLkE4wRz1oU6IcJ8mVfA0sBd="),
41		},
42		Trademark: &Trademark{
43			TrademarkExists: TRADEMARKSTATE_TRADEMARK_EXISTS.Ptr(),
44			TrademarkRegistrationCertificate: &TrademarkRegCert{
45				Certificate:            wxpay_utility.String("jTpGmxUX3FBWVQ5NJTZvvDujqhThn4ReFxikqJ5YW6zFQ"),
46				Name:                   wxpay_utility.String("爱马哥"),
47				Number:                 wxpay_utility.String("12345678"),
48				ValidBeginTime:         wxpay_utility.String("2025-09-08"),
49				ValidEndTime:           wxpay_utility.String("2035-09-08"),
50				InternationalClass:     wxpay_utility.String("25"),
51				Holder:                 wxpay_utility.String("腾讯科技有限公司"),
52				License:                wxpay_utility.String("jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ"),
53				AuthorizationBeginTime: wxpay_utility.String("2025-09-08"),
54				AuthorizationEndTime:   wxpay_utility.String("2035-09-08"),
55			},
56			LogoTrademarkRegistrationCertificate: &LogoTrademarkRegCert{
57				Certificate:            wxpay_utility.String("jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ"),
58				Name:                   wxpay_utility.String("爱马哥"),
59				Number:                 wxpay_utility.String("21312344"),
60				ValidBeginTime:         wxpay_utility.String("2025-09-08"),
61				ValidEndTime:           wxpay_utility.String("2035-09-08"),
62				InternationalClass:     wxpay_utility.String("25"),
63				Holder:                 wxpay_utility.String("腾讯科技有限公司"),
64				License:                wxpay_utility.String("jTpGmxUXqRTvDujqhThn4ReFxikqJ5YW6zFQ"),
65				AuthorizationBeginTime: wxpay_utility.String("2025-09-08"),
66				AuthorizationEndTime:   wxpay_utility.String("2035-09-08"),
67			},
68			NoTrademarkAdditionProve: wxpay_utility.String("jTpGmxUX3FBWVQ5NJTZvvDujqhThn4ReFxikqJ5YW6zFQ"),
69		},
70	}
71
72	response, err := SubmitApplyment(config, request)
73	if err != nil {
74		fmt.Printf("请求失败: %+v\n", err)
75		// TODO: 请求失败，根据状态码执行不同的处理
76		return
77	}
78
79	// TODO: 请求成功，继续业务逻辑
80	fmt.Printf("请求成功: %+v\n", response)
81}
82
83func SubmitApplyment(config *wxpay_utility.MchConfig, request *SubmitApplyRequest) (response *SubmitApplyResponse, err error) {
84	const (
85		host   = "https://api.mch.weixin.qq.com"
86		method = "POST"
87		path   = "/v3/brand/applyments"
88	)
89
90	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
91	if err != nil {
92		return nil, err
93	}
94	reqBody, err := json.Marshal(request)
95	if err != nil {
96		return nil, err
97	}
98	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
99	if err != nil {
100		return nil, err
101	}
102	httpRequest.Header.Set("Accept", "application/json")
103	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
104	httpRequest.Header.Set("Content-Type", "application/json")
105	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
106	if err != nil {
107		return nil, err
108	}
109	httpRequest.Header.Set("Authorization", authorization)
110
111	client := &http.Client{}
112	httpResponse, err := client.Do(httpRequest)
113	if err != nil {
114		return nil, err
115	}
116	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
117	if err != nil {
118		return nil, err
119	}
120	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
121		// 2XX 成功，验证应答签名
122		err = wxpay_utility.ValidateResponse(
123			config.WechatPayPublicKeyId(),
124			config.WechatPayPublicKey(),
125			&httpResponse.Header,
126			respBody,
127		)
128		if err != nil {
129			return nil, err
130		}
131		response := &SubmitApplyResponse{}
132		if err := json.Unmarshal(respBody, response); err != nil {
133			return nil, err
134		}
135
136		return response, nil
137	} else {
138		return nil, wxpay_utility.NewApiException(
139			httpResponse.StatusCode,
140			httpResponse.Header,
141			respBody,
142		)
143	}
144}
145
146type SubmitApplyRequest struct {
147	BusinessCode   *string         `json:"business_code,omitempty"`
148	AdminInfo      *AdminInfo      `json:"admin_info,omitempty"`
149	SubjectInfo    *SubjectInfo    `json:"subject_info,omitempty"`
150	BrandBasicInfo *BrandBasicInfo `json:"brand_basic_info,omitempty"`
151	Trademark      *Trademark      `json:"trademark,omitempty"`
152}
153
154type SubmitApplyResponse struct {
155	ApplymentId  *string `json:"applyment_id,omitempty"`
156	BusinessCode *string `json:"business_code,omitempty"`
157}
158
159type AdminInfo struct {
160	AdminName    *string             `json:"admin_name,omitempty"`
161	IdDocType    *IdentificationType `json:"id_doc_type,omitempty"`
162	IdCardNumber *string             `json:"id_card_number,omitempty"`
163}
164
165type SubjectInfo struct {
166	SubjectType             *SubjectType `json:"subject_type,omitempty"`
167	SubjectName             *string      `json:"subject_name,omitempty"`
168	UnifiedSocialCreditCode *string      `json:"unified_social_credit_code,omitempty"`
169}
170
171type BrandBasicInfo struct {
172	BrandName *string `json:"brand_name,omitempty"`
173	BrandLogo *string `json:"brand_logo,omitempty"`
174}
175
176type Trademark struct {
177	TrademarkExists                      *TrademarkState       `json:"trademark_exists,omitempty"`
178	TrademarkRegistrationCertificate     *TrademarkRegCert     `json:"trademark_registration_certificate,omitempty"`
179	LogoTrademarkRegistrationCertificate *LogoTrademarkRegCert `json:"logo_trademark_registration_certificate,omitempty"`
180	NoTrademarkAdditionProve             *string               `json:"no_trademark_addition_prove,omitempty"`
181}
182
183type IdentificationType string
184
185func (e IdentificationType) Ptr() *IdentificationType {
186	return &e
187}
188
189const (
190	IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_MAINLAND_ID_CARD        IdentificationType = "IDENTIFICATION_TYPE_MAINLAND_ID_CARD"
191	IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_HONGKONG                IdentificationType = "IDENTIFICATION_TYPE_HONGKONG"
192	IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_MACAO                   IdentificationType = "IDENTIFICATION_TYPE_MACAO"
193	IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_TAIWAN                  IdentificationType = "IDENTIFICATION_TYPE_TAIWAN"
194	IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_HONGKONG_MACAO_RESIDENT IdentificationType = "IDENTIFICATION_TYPE_HONGKONG_MACAO_RESIDENT"
195	IDENTIFICATIONTYPE_IDENTIFICATION_TYPE_TAIWAN_RESIDENT         IdentificationType = "IDENTIFICATION_TYPE_TAIWAN_RESIDENT"
196)
197
198type SubjectType string
199
200func (e SubjectType) Ptr() *SubjectType {
201	return &e
202}
203
204const (
205	SUBJECTTYPE_SUBJECT_TYPE_ENTERPRISE SubjectType = "SUBJECT_TYPE_ENTERPRISE"
206	SUBJECTTYPE_SUBJECT_TYPE_INDIVIDUAL SubjectType = "SUBJECT_TYPE_INDIVIDUAL"
207)
208
209type TrademarkState string
210
211func (e TrademarkState) Ptr() *TrademarkState {
212	return &e
213}
214
215const (
216	TRADEMARKSTATE_TRADEMARK_EXISTS TrademarkState = "TRADEMARK_EXISTS"
217	TRADEMARKSTATE_TRADEMARK_NONE   TrademarkState = "TRADEMARK_NONE"
218)
219
220type TrademarkRegCert struct {
221	Certificate            *string `json:"certificate,omitempty"`
222	Name                   *string `json:"name,omitempty"`
223	Number                 *string `json:"number,omitempty"`
224	ValidBeginTime         *string `json:"valid_begin_time,omitempty"`
225	ValidEndTime           *string `json:"valid_end_time,omitempty"`
226	InternationalClass     *string `json:"international_class,omitempty"`
227	Holder                 *string `json:"holder,omitempty"`
228	License                *string `json:"license,omitempty"`
229	AuthorizationBeginTime *string `json:"authorization_begin_time,omitempty"`
230	AuthorizationEndTime   *string `json:"authorization_end_time,omitempty"`
231}
232
233type LogoTrademarkRegCert struct {
234	Certificate            *string `json:"certificate,omitempty"`
235	Name                   *string `json:"name,omitempty"`
236	Number                 *string `json:"number,omitempty"`
237	ValidBeginTime         *string `json:"valid_begin_time,omitempty"`
238	ValidEndTime           *string `json:"valid_end_time,omitempty"`
239	InternationalClass     *string `json:"international_class,omitempty"`
240	Holder                 *string `json:"holder,omitempty"`
241	License                *string `json:"license,omitempty"`
242	AuthorizationBeginTime *string `json:"authorization_begin_time,omitempty"`
243	AuthorizationEndTime   *string `json:"authorization_end_time,omitempty"`
244}
245