初始化上传

1curl -X POST \
2  https://api.mch.weixin.qq.com/brand/marketing/user-package/uploads \
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    "user_package_file_info" : {
9      "filename" : "active_user.csv",
10      "digest" : "addca90a6a290b9642dbaccffdf01e8c22aa348940b2e96754169ba08c19e5db",
11      "package_type" : "USER_PACKAGE_TYPE_EXPOSURE",
12      "data_type" : "USER_PACKAGE_DATA_TYPE_PHONE",
13      "description" : "熟客人群-1",
14      "file_size" : 256000
15    }
16  }'
17

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 InitiateUpload {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/brand/marketing/user-package/uploads";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
32    InitiateUpload client = new InitiateUpload(
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    InitiateUploadRequest request = new InitiateUploadRequest();
41    request.userPackageFileInfo = new UserPackageFileInfo();
42    request.userPackageFileInfo.filename = "active_user.csv";
43    request.userPackageFileInfo.digest = "addca90a6a290b9642dbaccffdf01e8c22aa348940b2e96754169ba08c19e5db";
44    request.userPackageFileInfo.packageType = UserPackageType.USER_PACKAGE_TYPE_EXPOSURE;
45    request.userPackageFileInfo.dataType = UserPackageDataType.USER_PACKAGE_DATA_TYPE_PHONE;
46    request.userPackageFileInfo.description = "熟客人群-1";
47    request.userPackageFileInfo.fileSize = 256000L;
48    try {
49      InitiateUploadResponse response = client.run(request);
50        // TODO: 请求成功，继续业务逻辑
51        System.out.println(response);
52    } catch (WXPayBrandUtility.ApiException e) {
53        // TODO: 请求失败，根据状态码执行不同的逻辑
54        e.printStackTrace();
55    }
56  }
57
58  public InitiateUploadResponse run(InitiateUploadRequest request) {
59    String uri = PATH;
60    String reqBody = WXPayBrandUtility.toJson(request);
61
62    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
63    reqBuilder.addHeader("Accept", "application/json");
64    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
65    reqBuilder.addHeader("Authorization", WXPayBrandUtility.buildAuthorization(brand_id, certificateSerialNo,privateKey, METHOD, uri, reqBody));
66    reqBuilder.addHeader("Content-Type", "application/json");
67    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
68    reqBuilder.method(METHOD, requestBody);
69    Request httpRequest = reqBuilder.build();
70
71    // 发送HTTP请求
72    OkHttpClient client = new OkHttpClient.Builder().build();
73    try (Response httpResponse = client.newCall(httpRequest).execute()) {
74      String respBody = WXPayBrandUtility.extractBody(httpResponse);
75      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
76        // 2XX 成功，验证应答签名
77        WXPayBrandUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
78            httpResponse.headers(), respBody);
79
80        // 从HTTP应答报文构建返回数据
81        return WXPayBrandUtility.fromJson(respBody, InitiateUploadResponse.class);
82      } else {
83        throw new WXPayBrandUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
84      }
85    } catch (IOException e) {
86      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
87    }
88  }
89
90  private final String brand_id;
91  private final String certificateSerialNo;
92  private final PrivateKey privateKey;
93  private final String wechatPayPublicKeyId;
94  private final PublicKey wechatPayPublicKey;
95
96  public InitiateUpload(String brand_id, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
97    this.brand_id = brand_id;
98    this.certificateSerialNo = certificateSerialNo;
99    this.privateKey = WXPayBrandUtility.loadPrivateKeyFromPath(privateKeyFilePath);
100    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
101    this.wechatPayPublicKey = WXPayBrandUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
102  }
103
104  public static class InitiateUploadRequest {
105    @SerializedName("user_package_file_info")
106    public UserPackageFileInfo userPackageFileInfo;
107  }
108  
109  public static class InitiateUploadResponse {
110    @SerializedName("return_message")
111    public String returnMessage;
112  
113    @SerializedName("upload_id")
114    public String uploadId;
115  
116    @SerializedName("file_part_size")
117    public Long filePartSize;
118  
119    @SerializedName("file_part_count")
120    public Long filePartCount;
121  }
122  
123  public static class UserPackageFileInfo {
124    @SerializedName("filename")
125    public String filename;
126  
127    @SerializedName("digest")
128    public String digest;
129  
130    @SerializedName("package_type")
131    public UserPackageType packageType;
132  
133    @SerializedName("data_type")
134    public UserPackageDataType dataType;
135  
136    @SerializedName("description")
137    public String description;
138  
139    @SerializedName("file_size")
140    public Long fileSize;
141  }
142  
143  public enum UserPackageType {
144    @SerializedName("USER_PACKAGE_TYPE_EXPOSURE")
145    USER_PACKAGE_TYPE_EXPOSURE,
146    @SerializedName("USER_PACKAGE_TYPE_RISK")
147    USER_PACKAGE_TYPE_RISK
148  }
149  
150  public enum UserPackageDataType {
151    @SerializedName("USER_PACKAGE_DATA_TYPE_PHONE")
152    USER_PACKAGE_DATA_TYPE_PHONE,
153    @SerializedName("USER_PACKAGE_DATA_TYPE_OPENID")
154    USER_PACKAGE_DATA_TYPE_OPENID
155  }
156  
157}
158

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)
11
12func main() {
13	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
14	config, err := wxpay_brand_utility.CreateBrandConfig(
15		"xxxxxxxx",                   // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
16		"1DDE55AD98Exxxxxxxxxx",      // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
17		"/path/to/apiclient_key.pem", // 品牌API证书私钥文件路径，本地文件路径
18		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
19		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
20	)
21	if err != nil {
22		fmt.Println(err)
23		return
24	}
25
26	request := &InitiateUploadRequest{
27		UserPackageFileInfo: &UserPackageFileInfo{
28			Filename:    wxpay_brand_utility.String("active_user.csv"),
29			Digest:      wxpay_brand_utility.String("addca90a6a290b9642dbaccffdf01e8c22aa348940b2e96754169ba08c19e5db"),
30			PackageType: USERPACKAGETYPE_USER_PACKAGE_TYPE_EXPOSURE.Ptr(),
31			DataType:    USERPACKAGEDATATYPE_USER_PACKAGE_DATA_TYPE_PHONE.Ptr(),
32			Description: wxpay_brand_utility.String("熟客人群-1"),
33			FileSize:    wxpay_brand_utility.Int64(256000),
34		},
35	}
36
37	response, err := InitiateUpload(config, request)
38	if err != nil {
39		fmt.Printf("请求失败: %+v\n", err)
40		// TODO: 请求失败，根据状态码执行不同的处理
41		return
42	}
43
44	// TODO: 请求成功，继续业务逻辑
45	fmt.Printf("请求成功: %+v\n", response)
46}
47
48func InitiateUpload(config *wxpay_brand_utility.BrandConfig, request *InitiateUploadRequest) (response *InitiateUploadResponse, err error) {
49	const (
50		host   = "https://api.mch.weixin.qq.com"
51		method = "POST"
52		path   = "/brand/marketing/user-package/uploads"
53	)
54
55	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
56	if err != nil {
57		return nil, err
58	}
59	reqBody, err := json.Marshal(request)
60	if err != nil {
61		return nil, err
62	}
63	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
64	if err != nil {
65		return nil, err
66	}
67	httpRequest.Header.Set("Accept", "application/json")
68	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
69	httpRequest.Header.Set("Content-Type", "application/json")
70	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
71	if err != nil {
72		return nil, err
73	}
74	httpRequest.Header.Set("Authorization", authorization)
75
76	client := &http.Client{}
77	httpResponse, err := client.Do(httpRequest)
78	if err != nil {
79		return nil, err
80	}
81	respBody, err := wxpay_brand_utility.ExtractResponseBody(httpResponse)
82	if err != nil {
83		return nil, err
84	}
85	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
86		// 2XX 成功，验证应答签名
87		err = wxpay_brand_utility.ValidateResponse(
88			config.WechatPayPublicKeyId(),
89			config.WechatPayPublicKey(),
90			&httpResponse.Header,
91			respBody,
92		)
93		if err != nil {
94			return nil, err
95		}
96		response := &InitiateUploadResponse{}
97		if err := json.Unmarshal(respBody, response); err != nil {
98			return nil, err
99		}
100
101		return response, nil
102	} else {
103		return nil, wxpay_brand_utility.NewApiException(
104			httpResponse.StatusCode,
105			httpResponse.Header,
106			respBody,
107		)
108	}
109}
110
111type InitiateUploadRequest struct {
112	UserPackageFileInfo *UserPackageFileInfo `json:"user_package_file_info,omitempty"`
113}
114
115type InitiateUploadResponse struct {
116	ReturnMessage *string `json:"return_message,omitempty"`
117	UploadId      *string `json:"upload_id,omitempty"`
118	FilePartSize  *int64  `json:"file_part_size,omitempty"`
119	FilePartCount *int64  `json:"file_part_count,omitempty"`
120}
121
122type UserPackageFileInfo struct {
123	Filename    *string              `json:"filename,omitempty"`
124	Digest      *string              `json:"digest,omitempty"`
125	PackageType *UserPackageType     `json:"package_type,omitempty"`
126	DataType    *UserPackageDataType `json:"data_type,omitempty"`
127	Description *string              `json:"description,omitempty"`
128	FileSize    *int64               `json:"file_size,omitempty"`
129}
130
131type UserPackageType string
132
133func (e UserPackageType) Ptr() *UserPackageType {
134	return &e
135}
136
137const (
138	USERPACKAGETYPE_USER_PACKAGE_TYPE_EXPOSURE UserPackageType = "USER_PACKAGE_TYPE_EXPOSURE"
139	USERPACKAGETYPE_USER_PACKAGE_TYPE_RISK     UserPackageType = "USER_PACKAGE_TYPE_RISK"
140)
141
142type UserPackageDataType string
143
144func (e UserPackageDataType) Ptr() *UserPackageDataType {
145	return &e
146}
147
148const (
149	USERPACKAGEDATATYPE_USER_PACKAGE_DATA_TYPE_PHONE  UserPackageDataType = "USER_PACKAGE_DATA_TYPE_PHONE"
150	USERPACKAGEDATATYPE_USER_PACKAGE_DATA_TYPE_OPENID UserPackageDataType = "USER_PACKAGE_DATA_TYPE_OPENID"
151)
152