创建投放计划

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    "plan_name" : "冬季饮料投放",
12    "total_count" : 1,
13    "user_limit" : 1,
14    "daily_limit" : 1,
15    "delivery_start_time" : "2025-01-01T00:00:00+08:00",
16    "delivery_end_time" : "2025-01-01T00:00:00+08:00",
17    "recommend_word" : "天天有惊喜"
18  }'
19

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.planName = "冬季饮料投放";
46    request.totalCount = 1L;
47    request.userLimit = 1L;
48    request.dailyLimit = 1L;
49    request.deliveryStartTime = "2025-01-01T00:00:00+08:00";
50    request.deliveryEndTime = "2025-01-01T00:00:00+08:00";
51    request.recommendWord = "天天有惊喜";
52    try {
53      CreateDeliveryPlanReponse response = client.run(request);
54        // TODO: 请求成功，继续业务逻辑
55        System.out.println(response);
56    } catch (WXPayUtility.ApiException e) {
57        // TODO: 请求失败，根据状态码执行不同的逻辑
58        e.printStackTrace();
59    }
60  }
61
62  public CreateDeliveryPlanReponse run(CreateDeliveryPlanRequest request) {
63    String uri = PATH;
64    String reqBody = WXPayUtility.toJson(request);
65
66    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
67    reqBuilder.addHeader("Accept", "application/json");
68    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
69    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
70    reqBuilder.addHeader("Content-Type", "application/json");
71    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
72    reqBuilder.method(METHOD, requestBody);
73    Request httpRequest = reqBuilder.build();
74
75    // 发送HTTP请求
76    OkHttpClient client = new OkHttpClient.Builder().build();
77    try (Response httpResponse = client.newCall(httpRequest).execute()) {
78      String respBody = WXPayUtility.extractBody(httpResponse);
79      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
80        // 2XX 成功，验证应答签名
81        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
82            httpResponse.headers(), respBody);
83
84        // 从HTTP应答报文构建返回数据
85        return WXPayUtility.fromJson(respBody, CreateDeliveryPlanReponse.class);
86      } else {
87        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
88      }
89    } catch (IOException e) {
90      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
91    }
92  }
93
94  private final String mchid;
95  private final String certificateSerialNo;
96  private final PrivateKey privateKey;
97  private final String wechatPayPublicKeyId;
98  private final PublicKey wechatPayPublicKey;
99
100  public CreateDeliveryPlan(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
101    this.mchid = mchid;
102    this.certificateSerialNo = certificateSerialNo;
103    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
104    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
105    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
106  }
107
108  public static class CreateDeliveryPlanRequest {
109    @SerializedName("out_request_no")
110    public String outRequestNo;
111  
112    @SerializedName("brand_id")
113    public String brandId;
114  
115    @SerializedName("product_coupon_id")
116    public String productCouponId;
117  
118    @SerializedName("stock_id")
119    public String stockId;
120  
121    @SerializedName("plan_name")
122    public String planName;
123  
124    @SerializedName("total_count")
125    public Long totalCount;
126  
127    @SerializedName("user_limit")
128    public Long userLimit;
129  
130    @SerializedName("daily_limit")
131    public Long dailyLimit;
132  
133    @SerializedName("delivery_start_time")
134    public String deliveryStartTime;
135  
136    @SerializedName("delivery_end_time")
137    public String deliveryEndTime;
138  
139    @SerializedName("recommend_word")
140    public String recommendWord;
141  }
142  
143  public static class CreateDeliveryPlanReponse {
144    @SerializedName("plan")
145    public DeliveryPlan plan;
146  }
147  
148  public static class DeliveryPlan {
149    @SerializedName("plan_id")
150    public String planId;
151  
152    @SerializedName("plan_name")
153    public String planName;
154  
155    @SerializedName("plan_state")
156    public PlanState planState;
157  
158    @SerializedName("delivery_start_time")
159    public String deliveryStartTime;
160  
161    @SerializedName("delivery_end_time")
162    public String deliveryEndTime;
163  
164    @SerializedName("stock_id")
165    public String stockId;
166  
167    @SerializedName("product_coupon_id")
168    public String productCouponId;
169  
170    @SerializedName("recommend_word")
171    public String recommendWord;
172  
173    @SerializedName("brand_id")
174    public Long brandId;
175  
176    @SerializedName("total_count")
177    public Long totalCount;
178  
179    @SerializedName("user_limit")
180    public Long userLimit;
181  
182    @SerializedName("daily_limit")
183    public Long dailyLimit;
184  }
185  
186  public enum PlanState {
187    @SerializedName("PLAN_CREATING")
188    PLAN_CREATING,
189    @SerializedName("PLAN_CREATED")
190    PLAN_CREATED,
191    @SerializedName("PLAN_TERMINATING")
192    PLAN_TERMINATING,
193    @SerializedName("PLAN_TERMINATED")
194    PLAN_TERMINATED,
195    @SerializedName("PLAN_EXPIRED")
196    PLAN_EXPIRED,
197    @SerializedName("PLAN_DELIVERING")
198    PLAN_DELIVERING,
199    @SerializedName("PLAN_PAUSED")
200    PLAN_PAUSED
201  }
202  
203}
204

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