创建投放计划

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/marketing/partner/delivery-plan/delivery-plans \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "out_request_no" : "asdf-1234-40016",
8    "brand_id" : "40016",
9    "product_coupon_id" : "701146876221757924829193824428",
10    "stock_id" : "701246876221757924829194755312",
11    "reuse_coupon_config" : false,
12    "plan_name" : "冬季饮料投放",
13    "total_count" : 11000,
14    "user_limit" : 1,
15    "daily_limit" : 1,
16    "delivery_start_time" : "2025-01-01T00:00:00+08:00",
17    "delivery_end_time" : "2025-01-01T00:00:00+08:00",
18    "recommend_word" : "天天有惊喜",
19    "usage_mode" : "SINGLE",
20    "stock_bundle_id" : "123456789"
21  }'
22

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 CreateDeliveryPlan {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/marketing/partner/delivery-plan/delivery-plans";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    CreateDeliveryPlan client = new CreateDeliveryPlan(
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    CreateDeliveryPlanRequest request = new CreateDeliveryPlanRequest();
41    request.outRequestNo = "asdf-1234-40016";
42    request.brandId = "40016";
43    request.productCouponId = "701146876221757924829193824428";
44    request.stockId = "701246876221757924829194755312";
45    request.reuseCouponConfig = false;
46    request.planName = "冬季饮料投放";
47    request.totalCount = 11000L;
48    request.userLimit = 1L;
49    request.dailyLimit = 1L;
50    request.deliveryStartTime = "2025-01-01T00:00:00+08:00";
51    request.deliveryEndTime = "2025-01-01T00:00:00+08:00";
52    request.recommendWord = "天天有惊喜";
53    request.usageMode = ProductUsageMode.SINGLE;
54    request.stockBundleId = "123456789";
55    try {
56      CreateDeliveryPlanReponse 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 CreateDeliveryPlanReponse run(CreateDeliveryPlanRequest request) {
66    String uri = PATH;
67    String reqBody = WXPayUtility.toJson(request);
68
69    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
70    reqBuilder.addHeader("Accept", "application/json");
71    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
72    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
73    reqBuilder.addHeader("Content-Type", "application/json");
74    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
75    reqBuilder.method(METHOD, requestBody);
76    Request httpRequest = reqBuilder.build();
77
78    // 发送HTTP请求
79    OkHttpClient client = new OkHttpClient.Builder().build();
80    try (Response httpResponse = client.newCall(httpRequest).execute()) {
81      String respBody = WXPayUtility.extractBody(httpResponse);
82      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
83        // 2XX 成功，验证应答签名
84        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
85            httpResponse.headers(), respBody);
86
87        // 从HTTP应答报文构建返回数据
88        return WXPayUtility.fromJson(respBody, CreateDeliveryPlanReponse.class);
89      } else {
90        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
91      }
92    } catch (IOException e) {
93      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
94    }
95  }
96
97  private final String mchid;
98  private final String certificateSerialNo;
99  private final PrivateKey privateKey;
100  private final String wechatPayPublicKeyId;
101  private final PublicKey wechatPayPublicKey;
102
103  public CreateDeliveryPlan(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
104    this.mchid = mchid;
105    this.certificateSerialNo = certificateSerialNo;
106    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
107    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
108    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
109  }
110
111  public static class CreateDeliveryPlanRequest {
112    @SerializedName("out_request_no")
113    public String outRequestNo;
114  
115    @SerializedName("brand_id")
116    public String brandId;
117  
118    @SerializedName("product_coupon_id")
119    public String productCouponId;
120  
121    @SerializedName("stock_id")
122    public String stockId;
123  
124    @SerializedName("reuse_coupon_config")
125    public Boolean reuseCouponConfig;
126  
127    @SerializedName("plan_name")
128    public String planName;
129  
130    @SerializedName("total_count")
131    public Long totalCount;
132  
133    @SerializedName("user_limit")
134    public Long userLimit;
135  
136    @SerializedName("daily_limit")
137    public Long dailyLimit;
138  
139    @SerializedName("delivery_start_time")
140    public String deliveryStartTime;
141  
142    @SerializedName("delivery_end_time")
143    public String deliveryEndTime;
144  
145    @SerializedName("recommend_word")
146    public String recommendWord;
147  
148    @SerializedName("usage_mode")
149    public ProductUsageMode usageMode;
150  
151    @SerializedName("stock_bundle_id")
152    public String stockBundleId;
153  }
154  
155  public static class CreateDeliveryPlanReponse {
156    @SerializedName("plan")
157    public DeliveryPlan plan;
158  }
159  
160  public enum ProductUsageMode {
161    @SerializedName("SINGLE")
162    SINGLE,
163    @SerializedName("PROGRESSIVE_BUNDLE")
164    PROGRESSIVE_BUNDLE
165  }
166  
167  public static class DeliveryPlan {
168    @SerializedName("plan_id")
169    public String planId;
170  
171    @SerializedName("plan_name")
172    public String planName;
173  
174    @SerializedName("plan_state")
175    public PlanState planState;
176  
177    @SerializedName("delivery_start_time")
178    public String deliveryStartTime;
179  
180    @SerializedName("delivery_end_time")
181    public String deliveryEndTime;
182  
183    @SerializedName("product_coupon_id")
184    public String productCouponId;
185  
186    @SerializedName("usage_mode")
187    public ProductUsageMode usageMode;
188  
189    @SerializedName("stock_id")
190    public String stockId;
191  
192    @SerializedName("stock_bundle_id")
193    public String stockBundleId;
194  
195    @SerializedName("recommend_word")
196    public String recommendWord;
197  
198    @SerializedName("brand_id")
199    public String brandId;
200  
201    @SerializedName("total_count")
202    public Long totalCount;
203  
204    @SerializedName("user_limit")
205    public Long userLimit;
206  
207    @SerializedName("daily_limit")
208    public Long dailyLimit;
209  
210    @SerializedName("reuse_coupon_config")
211    public Boolean reuseCouponConfig;
212  }
213  
214  public enum PlanState {
215    @SerializedName("CREATED")
216    CREATED,
217    @SerializedName("TERMINATED")
218    TERMINATED,
219    @SerializedName("EXPIRED")
220    EXPIRED,
221    @SerializedName("DELIVERING")
222    DELIVERING,
223    @SerializedName("PAUSED")
224    PAUSED
225  }
226  
227}
228

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 := &CreateDeliveryPlanRequest{
27		OutRequestNo:      wxpay_utility.String("asdf-1234-40016"),
28		BrandId:           wxpay_utility.String("40016"),
29		ProductCouponId:   wxpay_utility.String("701146876221757924829193824428"),
30		StockId:           wxpay_utility.String("701246876221757924829194755312"),
31		ReuseCouponConfig: wxpay_utility.Bool(false),
32		PlanName:          wxpay_utility.String("冬季饮料投放"),
33		TotalCount:        wxpay_utility.Int64(11000),
34		UserLimit:         wxpay_utility.Int64(1),
35		DailyLimit:        wxpay_utility.Int64(1),
36		DeliveryStartTime: wxpay_utility.String("2025-01-01T00:00:00+08:00"),
37		DeliveryEndTime:   wxpay_utility.String("2025-01-01T00:00:00+08:00"),
38		RecommendWord:     wxpay_utility.String("天天有惊喜"),
39		UsageMode:         PRODUCTUSAGEMODE_SINGLE.Ptr(),
40		StockBundleId:     wxpay_utility.String("123456789"),
41	}
42
43	response, err := CreateDeliveryPlan(config, request)
44	if err != nil {
45		fmt.Printf("请求失败: %+v\n", err)
46		// TODO: 请求失败，根据状态码执行不同的处理
47		return
48	}
49
50	// TODO: 请求成功，继续业务逻辑
51	fmt.Printf("请求成功: %+v\n", response)
52}
53
54func CreateDeliveryPlan(config *wxpay_utility.MchConfig, request *CreateDeliveryPlanRequest) (response *CreateDeliveryPlanReponse, err error) {
55	const (
56		host   = "https://api.mch.weixin.qq.com"
57		method = "POST"
58		path   = "/v3/marketing/partner/delivery-plan/delivery-plans"
59	)
60
61	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
62	if err != nil {
63		return nil, err
64	}
65	reqBody, err := json.Marshal(request)
66	if err != nil {
67		return nil, err
68	}
69	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
70	if err != nil {
71		return nil, err
72	}
73	httpRequest.Header.Set("Accept", "application/json")
74	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
75	httpRequest.Header.Set("Content-Type", "application/json")
76	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
77	if err != nil {
78		return nil, err
79	}
80	httpRequest.Header.Set("Authorization", authorization)
81
82	client := &http.Client{}
83	httpResponse, err := client.Do(httpRequest)
84	if err != nil {
85		return nil, err
86	}
87	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
88	if err != nil {
89		return nil, err
90	}
91	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
92		// 2XX 成功，验证应答签名
93		err = wxpay_utility.ValidateResponse(
94			config.WechatPayPublicKeyId(),
95			config.WechatPayPublicKey(),
96			&httpResponse.Header,
97			respBody,
98		)
99		if err != nil {
100			return nil, err
101		}
102		response := &CreateDeliveryPlanReponse{}
103		if err := json.Unmarshal(respBody, response); err != nil {
104			return nil, err
105		}
106
107		return response, nil
108	} else {
109		return nil, wxpay_utility.NewApiException(
110			httpResponse.StatusCode,
111			httpResponse.Header,
112			respBody,
113		)
114	}
115}
116
117type CreateDeliveryPlanRequest struct {
118	OutRequestNo      *string           `json:"out_request_no,omitempty"`
119	BrandId           *string           `json:"brand_id,omitempty"`
120	ProductCouponId   *string           `json:"product_coupon_id,omitempty"`
121	StockId           *string           `json:"stock_id,omitempty"`
122	ReuseCouponConfig *bool             `json:"reuse_coupon_config,omitempty"`
123	PlanName          *string           `json:"plan_name,omitempty"`
124	TotalCount        *int64            `json:"total_count,omitempty"`
125	UserLimit         *int64            `json:"user_limit,omitempty"`
126	DailyLimit        *int64            `json:"daily_limit,omitempty"`
127	DeliveryStartTime *string           `json:"delivery_start_time,omitempty"`
128	DeliveryEndTime   *string           `json:"delivery_end_time,omitempty"`
129	RecommendWord     *string           `json:"recommend_word,omitempty"`
130	UsageMode         *ProductUsageMode `json:"usage_mode,omitempty"`
131	StockBundleId     *string           `json:"stock_bundle_id,omitempty"`
132}
133
134type CreateDeliveryPlanReponse struct {
135	Plan *DeliveryPlan `json:"plan,omitempty"`
136}
137
138type ProductUsageMode string
139
140func (e ProductUsageMode) Ptr() *ProductUsageMode {
141	return &e
142}
143
144const (
145	PRODUCTUSAGEMODE_SINGLE             ProductUsageMode = "SINGLE"
146	PRODUCTUSAGEMODE_PROGRESSIVE_BUNDLE ProductUsageMode = "PROGRESSIVE_BUNDLE"
147)
148
149type DeliveryPlan struct {
150	PlanId            *string           `json:"plan_id,omitempty"`
151	PlanName          *string           `json:"plan_name,omitempty"`
152	PlanState         *PlanState        `json:"plan_state,omitempty"`
153	DeliveryStartTime *string           `json:"delivery_start_time,omitempty"`
154	DeliveryEndTime   *string           `json:"delivery_end_time,omitempty"`
155	ProductCouponId   *string           `json:"product_coupon_id,omitempty"`
156	UsageMode         *ProductUsageMode `json:"usage_mode,omitempty"`
157	StockId           *string           `json:"stock_id,omitempty"`
158	StockBundleId     *string           `json:"stock_bundle_id,omitempty"`
159	RecommendWord     *string           `json:"recommend_word,omitempty"`
160	BrandId           *string           `json:"brand_id,omitempty"`
161	TotalCount        *int64            `json:"total_count,omitempty"`
162	UserLimit         *int64            `json:"user_limit,omitempty"`
163	DailyLimit        *int64            `json:"daily_limit,omitempty"`
164	ReuseCouponConfig *bool             `json:"reuse_coupon_config,omitempty"`
165}
166
167type PlanState string
168
169func (e PlanState) Ptr() *PlanState {
170	return &e
171}
172
173const (
174	PLANSTATE_CREATED    PlanState = "CREATED"
175	PLANSTATE_TERMINATED PlanState = "TERMINATED"
176	PLANSTATE_EXPIRED    PlanState = "EXPIRED"
177	PLANSTATE_DELIVERING PlanState = "DELIVERING"
178	PLANSTATE_PAUSED     PlanState = "PAUSED"
179)
180