申请退款

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/refund/domestic/refunds \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "sub_mchid" : "1900000109",
8    "transaction_id" : "1217752501201407033233368018",
9    "out_trade_no" : "1217752501201407033233368018",
10    "out_refund_no" : "1217752501201407033233368018",
11    "reason" : "商品已售完",
12    "notify_url" : "https://weixin.qq.com",
13    "funds_account" : "AVAILABLE",
14    "amount" : {
15      "refund" : 888,
16      "from" : [
17        {
18          "account" : "AVAILABLE",
19          "amount" : 444
20        }
21      ],
22      "total" : 888,
23      "currency" : "CNY"
24    },
25    "goods_detail" : [
26      {
27        "merchant_goods_id" : "1217752501201407033233368018",
28        "wechatpay_goods_id" : "1001",
29        "goods_name" : "iPhone6s 16G",
30        "unit_price" : 528800,
31        "refund_amount" : 528800,
32        "refund_quantity" : 1
33      }
34    ],
35    "refund_account" : "REFUND_SOURCE_SUB_MERCHANT"
36  }'
37

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 Create {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/refund/domestic/refunds";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    Create client = new Create(
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    CreateRequest request = new CreateRequest();
41    request.subMchid = "1900000109";
42    request.transactionId = "1217752501201407033233368018";
43    request.outTradeNo = "1217752501201407033233368018";
44    request.outRefundNo = "1217752501201407033233368018";
45    request.reason = "商品已售完";
46    request.notifyUrl = "https://weixin.qq.com";
47    request.fundsAccount = ReqFundsAccount.AVAILABLE;
48    request.amount = new AmountReq();
49    request.amount.refund = 888L;
50    request.amount.from = new ArrayList<>();
51    {
52      FundsFromItem fromItem = new FundsFromItem();
53      fromItem.account = Account.AVAILABLE;
54      fromItem.amount = 444L;
55      request.amount.from.add(fromItem);
56    };
57    request.amount.total = 888L;
58    request.amount.currency = "CNY";
59    request.goodsDetail = new ArrayList<>();
60    {
61      GoodsDetail goodsDetailItem = new GoodsDetail();
62      goodsDetailItem.merchantGoodsId = "1217752501201407033233368018";
63      goodsDetailItem.wechatpayGoodsId = "1001";
64      goodsDetailItem.goodsName = "iPhone6s 16G";
65      goodsDetailItem.unitPrice = 528800L;
66      goodsDetailItem.refundAmount = 528800L;
67      goodsDetailItem.refundQuantity = 1L;
68      request.goodsDetail.add(goodsDetailItem);
69    };
70    request.refundAccount = RefundAccount.REFUND_SOURCE_SUB_MERCHANT;
71    try {
72      Refund response = client.run(request);
73        // TODO: 请求成功，继续业务逻辑
74        System.out.println(response);
75    } catch (WXPayUtility.ApiException e) {
76        // TODO: 请求失败，根据状态码执行不同的逻辑
77        e.printStackTrace();
78    }
79  }
80
81  public Refund run(CreateRequest request) {
82    String uri = PATH;
83    String reqBody = WXPayUtility.toJson(request);
84
85    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
86    reqBuilder.addHeader("Accept", "application/json");
87    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
88    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
89    reqBuilder.addHeader("Content-Type", "application/json");
90    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
91    reqBuilder.method(METHOD, requestBody);
92    Request httpRequest = reqBuilder.build();
93
94    // 发送HTTP请求
95    OkHttpClient client = new OkHttpClient.Builder().build();
96    try (Response httpResponse = client.newCall(httpRequest).execute()) {
97      String respBody = WXPayUtility.extractBody(httpResponse);
98      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
99        // 2XX 成功，验证应答签名
100        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
101            httpResponse.headers(), respBody);
102
103        // 从HTTP应答报文构建返回数据
104        return WXPayUtility.fromJson(respBody, Refund.class);
105      } else {
106        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
107      }
108    } catch (IOException e) {
109      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
110    }
111  }
112
113  private final String mchid;
114  private final String certificateSerialNo;
115  private final PrivateKey privateKey;
116  private final String wechatPayPublicKeyId;
117  private final PublicKey wechatPayPublicKey;
118
119  public Create(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
120    this.mchid = mchid;
121    this.certificateSerialNo = certificateSerialNo;
122    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
123    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
124    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
125  }
126
127  public static class CreateRequest {
128    @SerializedName("sub_mchid")
129    public String subMchid;
130  
131    @SerializedName("transaction_id")
132    public String transactionId;
133  
134    @SerializedName("out_trade_no")
135    public String outTradeNo;
136  
137    @SerializedName("out_refund_no")
138    public String outRefundNo;
139  
140    @SerializedName("reason")
141    public String reason;
142  
143    @SerializedName("notify_url")
144    public String notifyUrl;
145  
146    @SerializedName("funds_account")
147    public ReqFundsAccount fundsAccount;
148  
149    @SerializedName("amount")
150    public AmountReq amount;
151  
152    @SerializedName("goods_detail")
153    public List<GoodsDetail> goodsDetail;
154  
155    @SerializedName("refund_account")
156    public RefundAccount refundAccount;
157  }
158  
159  public static class Refund {
160    @SerializedName("refund_id")
161    public String refundId;
162  
163    @SerializedName("out_refund_no")
164    public String outRefundNo;
165  
166    @SerializedName("transaction_id")
167    public String transactionId;
168  
169    @SerializedName("out_trade_no")
170    public String outTradeNo;
171  
172    @SerializedName("channel")
173    public Channel channel;
174  
175    @SerializedName("user_received_account")
176    public String userReceivedAccount;
177  
178    @SerializedName("success_time")
179    public String successTime;
180  
181    @SerializedName("create_time")
182    public String createTime;
183  
184    @SerializedName("status")
185    public Status status;
186  
187    @SerializedName("funds_account")
188    public FundsAccount fundsAccount;
189  
190    @SerializedName("amount")
191    public Amount amount;
192  
193    @SerializedName("promotion_detail")
194    public List<Promotion> promotionDetail;
195  
196    @SerializedName("refund_account")
197    public RefundAccount refundAccount;
198  }
199  
200  public enum ReqFundsAccount {
201    @SerializedName("AVAILABLE")
202    AVAILABLE,
203    @SerializedName("UNSETTLED")
204    UNSETTLED
205  }
206  
207  public static class AmountReq {
208    @SerializedName("refund")
209    public Long refund;
210  
211    @SerializedName("from")
212    public List<FundsFromItem> from;
213  
214    @SerializedName("total")
215    public Long total;
216  
217    @SerializedName("currency")
218    public String currency;
219  }
220  
221  public static class GoodsDetail {
222    @SerializedName("merchant_goods_id")
223    public String merchantGoodsId;
224  
225    @SerializedName("wechatpay_goods_id")
226    public String wechatpayGoodsId;
227  
228    @SerializedName("goods_name")
229    public String goodsName;
230  
231    @SerializedName("unit_price")
232    public Long unitPrice;
233  
234    @SerializedName("refund_amount")
235    public Long refundAmount;
236  
237    @SerializedName("refund_quantity")
238    public Long refundQuantity;
239  }
240  
241  public enum RefundAccount {
242    @SerializedName("REFUND_SOURCE_PARTNER_ADVANCE")
243    REFUND_SOURCE_PARTNER_ADVANCE,
244    @SerializedName("REFUND_SOURCE_SUB_MERCHANT")
245    REFUND_SOURCE_SUB_MERCHANT,
246    @SerializedName("REFUND_SOURCE_SUB_MERCHANT_ADVANCE")
247    REFUND_SOURCE_SUB_MERCHANT_ADVANCE
248  }
249  
250  public enum Channel {
251    @SerializedName("ORIGINAL")
252    ORIGINAL,
253    @SerializedName("BALANCE")
254    BALANCE,
255    @SerializedName("OTHER_BALANCE")
256    OTHER_BALANCE,
257    @SerializedName("OTHER_BANKCARD")
258    OTHER_BANKCARD
259  }
260  
261  public enum Status {
262    @SerializedName("SUCCESS")
263    SUCCESS,
264    @SerializedName("CLOSED")
265    CLOSED,
266    @SerializedName("PROCESSING")
267    PROCESSING,
268    @SerializedName("ABNORMAL")
269    ABNORMAL
270  }
271  
272  public enum FundsAccount {
273    @SerializedName("UNSETTLED")
274    UNSETTLED,
275    @SerializedName("AVAILABLE")
276    AVAILABLE,
277    @SerializedName("UNAVAILABLE")
278    UNAVAILABLE,
279    @SerializedName("OPERATION")
280    OPERATION,
281    @SerializedName("BASIC")
282    BASIC,
283    @SerializedName("ECNY_BASIC")
284    ECNY_BASIC
285  }
286  
287  public static class Amount {
288    @SerializedName("total")
289    public Long total;
290  
291    @SerializedName("refund")
292    public Long refund;
293  
294    @SerializedName("from")
295    public List<FundsFromItem> from;
296  
297    @SerializedName("payer_total")
298    public Long payerTotal;
299  
300    @SerializedName("payer_refund")
301    public Long payerRefund;
302  
303    @SerializedName("settlement_refund")
304    public Long settlementRefund;
305  
306    @SerializedName("settlement_total")
307    public Long settlementTotal;
308  
309    @SerializedName("discount_refund")
310    public Long discountRefund;
311  
312    @SerializedName("currency")
313    public String currency;
314  
315    @SerializedName("refund_fee")
316    public Long refundFee;
317  
318    @SerializedName("advance")
319    public Long advance;
320  }
321  
322  public static class Promotion {
323    @SerializedName("promotion_id")
324    public String promotionId;
325  
326    @SerializedName("scope")
327    public PromotionScope scope;
328  
329    @SerializedName("type")
330    public PromotionType type;
331  
332    @SerializedName("amount")
333    public Long amount;
334  
335    @SerializedName("refund_amount")
336    public Long refundAmount;
337  
338    @SerializedName("goods_detail")
339    public List<GoodsDetail> goodsDetail;
340  }
341  
342  public static class FundsFromItem {
343    @SerializedName("account")
344    public Account account;
345  
346    @SerializedName("amount")
347    public Long amount;
348  }
349  
350  public enum PromotionScope {
351    @SerializedName("GLOBAL")
352    GLOBAL,
353    @SerializedName("SINGLE")
354    SINGLE
355  }
356  
357  public enum PromotionType {
358    @SerializedName("COUPON")
359    COUPON,
360    @SerializedName("DISCOUNT")
361    DISCOUNT
362  }
363  
364  public enum Account {
365    @SerializedName("AVAILABLE")
366    AVAILABLE,
367    @SerializedName("UNAVAILABLE")
368    UNAVAILABLE
369  }
370  
371}
372

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	"time"
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 := &CreateRequest{
28		SubMchid:      wxpay_utility.String("1900000109"),
29		TransactionId: wxpay_utility.String("1217752501201407033233368018"),
30		OutTradeNo:    wxpay_utility.String("1217752501201407033233368018"),
31		OutRefundNo:   wxpay_utility.String("1217752501201407033233368018"),
32		Reason:        wxpay_utility.String("商品已售完"),
33		NotifyUrl:     wxpay_utility.String("https://weixin.qq.com"),
34		FundsAccount:  REQFUNDSACCOUNT_AVAILABLE.Ptr(),
35		Amount: &AmountReq{
36			Refund: wxpay_utility.Int64(888),
37			From: []FundsFromItem{FundsFromItem{
38				Account: ACCOUNT_AVAILABLE.Ptr(),
39				Amount:  wxpay_utility.Int64(444),
40			}},
41			Total:    wxpay_utility.Int64(888),
42			Currency: wxpay_utility.String("CNY"),
43		},
44		GoodsDetail: []GoodsDetail{GoodsDetail{
45			MerchantGoodsId:  wxpay_utility.String("1217752501201407033233368018"),
46			WechatpayGoodsId: wxpay_utility.String("1001"),
47			GoodsName:        wxpay_utility.String("iPhone6s 16G"),
48			UnitPrice:        wxpay_utility.Int64(528800),
49			RefundAmount:     wxpay_utility.Int64(528800),
50			RefundQuantity:   wxpay_utility.Int64(1),
51		}},
52		RefundAccount: REFUNDACCOUNT_REFUND_SOURCE_SUB_MERCHANT.Ptr(),
53	}
54
55	response, err := Create(config, request)
56	if err != nil {
57		fmt.Printf("请求失败: %+v\n", err)
58		// TODO: 请求失败，根据状态码执行不同的处理
59		return
60	}
61
62	// TODO: 请求成功，继续业务逻辑
63	fmt.Printf("请求成功: %+v\n", response)
64}
65
66func Create(config *wxpay_utility.MchConfig, request *CreateRequest) (response *Refund, err error) {
67	const (
68		host   = "https://api.mch.weixin.qq.com"
69		method = "POST"
70		path   = "/v3/refund/domestic/refunds"
71	)
72
73	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
74	if err != nil {
75		return nil, err
76	}
77	reqBody, err := json.Marshal(request)
78	if err != nil {
79		return nil, err
80	}
81	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
82	if err != nil {
83		return nil, err
84	}
85	httpRequest.Header.Set("Accept", "application/json")
86	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
87	httpRequest.Header.Set("Content-Type", "application/json")
88	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
89	if err != nil {
90		return nil, err
91	}
92	httpRequest.Header.Set("Authorization", authorization)
93
94	client := &http.Client{}
95	httpResponse, err := client.Do(httpRequest)
96	if err != nil {
97		return nil, err
98	}
99	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
100	if err != nil {
101		return nil, err
102	}
103	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
104		// 2XX 成功，验证应答签名
105		err = wxpay_utility.ValidateResponse(
106			config.WechatPayPublicKeyId(),
107			config.WechatPayPublicKey(),
108			&httpResponse.Header,
109			respBody,
110		)
111		if err != nil {
112			return nil, err
113		}
114		response := &Refund{}
115		if err := json.Unmarshal(respBody, response); err != nil {
116			return nil, err
117		}
118
119		return response, nil
120	} else {
121		return nil, wxpay_utility.NewApiException(
122			httpResponse.StatusCode,
123			httpResponse.Header,
124			respBody,
125		)
126	}
127}
128
129type CreateRequest struct {
130	SubMchid      *string          `json:"sub_mchid,omitempty"`
131	TransactionId *string          `json:"transaction_id,omitempty"`
132	OutTradeNo    *string          `json:"out_trade_no,omitempty"`
133	OutRefundNo   *string          `json:"out_refund_no,omitempty"`
134	Reason        *string          `json:"reason,omitempty"`
135	NotifyUrl     *string          `json:"notify_url,omitempty"`
136	FundsAccount  *ReqFundsAccount `json:"funds_account,omitempty"`
137	Amount        *AmountReq       `json:"amount,omitempty"`
138	GoodsDetail   []GoodsDetail    `json:"goods_detail,omitempty"`
139	RefundAccount *RefundAccount   `json:"refund_account,omitempty"`
140}
141
142type Refund struct {
143	RefundId            *string        `json:"refund_id,omitempty"`
144	OutRefundNo         *string        `json:"out_refund_no,omitempty"`
145	TransactionId       *string        `json:"transaction_id,omitempty"`
146	OutTradeNo          *string        `json:"out_trade_no,omitempty"`
147	Channel             *Channel       `json:"channel,omitempty"`
148	UserReceivedAccount *string        `json:"user_received_account,omitempty"`
149	SuccessTime         *time.Time     `json:"success_time,omitempty"`
150	CreateTime          *time.Time     `json:"create_time,omitempty"`
151	Status              *Status        `json:"status,omitempty"`
152	FundsAccount        *FundsAccount  `json:"funds_account,omitempty"`
153	Amount              *Amount        `json:"amount,omitempty"`
154	PromotionDetail     []Promotion    `json:"promotion_detail,omitempty"`
155	RefundAccount       *RefundAccount `json:"refund_account,omitempty"`
156}
157
158type ReqFundsAccount string
159
160func (e ReqFundsAccount) Ptr() *ReqFundsAccount {
161	return &e
162}
163
164const (
165	REQFUNDSACCOUNT_AVAILABLE ReqFundsAccount = "AVAILABLE"
166	REQFUNDSACCOUNT_UNSETTLED ReqFundsAccount = "UNSETTLED"
167)
168
169type AmountReq struct {
170	Refund   *int64          `json:"refund,omitempty"`
171	From     []FundsFromItem `json:"from,omitempty"`
172	Total    *int64          `json:"total,omitempty"`
173	Currency *string         `json:"currency,omitempty"`
174}
175
176type GoodsDetail struct {
177	MerchantGoodsId  *string `json:"merchant_goods_id,omitempty"`
178	WechatpayGoodsId *string `json:"wechatpay_goods_id,omitempty"`
179	GoodsName        *string `json:"goods_name,omitempty"`
180	UnitPrice        *int64  `json:"unit_price,omitempty"`
181	RefundAmount     *int64  `json:"refund_amount,omitempty"`
182	RefundQuantity   *int64  `json:"refund_quantity,omitempty"`
183}
184
185type RefundAccount string
186
187func (e RefundAccount) Ptr() *RefundAccount {
188	return &e
189}
190
191const (
192	REFUNDACCOUNT_REFUND_SOURCE_PARTNER_ADVANCE      RefundAccount = "REFUND_SOURCE_PARTNER_ADVANCE"
193	REFUNDACCOUNT_REFUND_SOURCE_SUB_MERCHANT         RefundAccount = "REFUND_SOURCE_SUB_MERCHANT"
194	REFUNDACCOUNT_REFUND_SOURCE_SUB_MERCHANT_ADVANCE RefundAccount = "REFUND_SOURCE_SUB_MERCHANT_ADVANCE"
195)
196
197type Channel string
198
199func (e Channel) Ptr() *Channel {
200	return &e
201}
202
203const (
204	CHANNEL_ORIGINAL       Channel = "ORIGINAL"
205	CHANNEL_BALANCE        Channel = "BALANCE"
206	CHANNEL_OTHER_BALANCE  Channel = "OTHER_BALANCE"
207	CHANNEL_OTHER_BANKCARD Channel = "OTHER_BANKCARD"
208)
209
210type Status string
211
212func (e Status) Ptr() *Status {
213	return &e
214}
215
216const (
217	STATUS_SUCCESS    Status = "SUCCESS"
218	STATUS_CLOSED     Status = "CLOSED"
219	STATUS_PROCESSING Status = "PROCESSING"
220	STATUS_ABNORMAL   Status = "ABNORMAL"
221)
222
223type FundsAccount string
224
225func (e FundsAccount) Ptr() *FundsAccount {
226	return &e
227}
228
229const (
230	FUNDSACCOUNT_UNSETTLED   FundsAccount = "UNSETTLED"
231	FUNDSACCOUNT_AVAILABLE   FundsAccount = "AVAILABLE"
232	FUNDSACCOUNT_UNAVAILABLE FundsAccount = "UNAVAILABLE"
233	FUNDSACCOUNT_OPERATION   FundsAccount = "OPERATION"
234	FUNDSACCOUNT_BASIC       FundsAccount = "BASIC"
235	FUNDSACCOUNT_ECNY_BASIC  FundsAccount = "ECNY_BASIC"
236)
237
238type Amount struct {
239	Total            *int64          `json:"total,omitempty"`
240	Refund           *int64          `json:"refund,omitempty"`
241	From             []FundsFromItem `json:"from,omitempty"`
242	PayerTotal       *int64          `json:"payer_total,omitempty"`
243	PayerRefund      *int64          `json:"payer_refund,omitempty"`
244	SettlementRefund *int64          `json:"settlement_refund,omitempty"`
245	SettlementTotal  *int64          `json:"settlement_total,omitempty"`
246	DiscountRefund   *int64          `json:"discount_refund,omitempty"`
247	Currency         *string         `json:"currency,omitempty"`
248	RefundFee        *int64          `json:"refund_fee,omitempty"`
249	Advance          *int64          `json:"advance,omitempty"`
250}
251
252type Promotion struct {
253	PromotionId  *string         `json:"promotion_id,omitempty"`
254	Scope        *PromotionScope `json:"scope,omitempty"`
255	Type         *PromotionType  `json:"type,omitempty"`
256	Amount       *int64          `json:"amount,omitempty"`
257	RefundAmount *int64          `json:"refund_amount,omitempty"`
258	GoodsDetail  []GoodsDetail   `json:"goods_detail,omitempty"`
259}
260
261type FundsFromItem struct {
262	Account *Account `json:"account,omitempty"`
263	Amount  *int64   `json:"amount,omitempty"`
264}
265
266type PromotionScope string
267
268func (e PromotionScope) Ptr() *PromotionScope {
269	return &e
270}
271
272const (
273	PROMOTIONSCOPE_GLOBAL PromotionScope = "GLOBAL"
274	PROMOTIONSCOPE_SINGLE PromotionScope = "SINGLE"
275)
276
277type PromotionType string
278
279func (e PromotionType) Ptr() *PromotionType {
280	return &e
281}
282
283const (
284	PROMOTIONTYPE_COUPON   PromotionType = "COUPON"
285	PROMOTIONTYPE_DISCOUNT PromotionType = "DISCOUNT"
286)
287
288type Account string
289
290func (e Account) Ptr() *Account {
291	return &e
292}
293
294const (
295	ACCOUNT_AVAILABLE   Account = "AVAILABLE"
296	ACCOUNT_UNAVAILABLE Account = "UNAVAILABLE"
297)
298