提交停车场进件申请

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/parking/reminders/application \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "parking_lot" : {
8      "parking_lot_name" : "腾讯大厦停车场",
9      "out_parking_lot_id" : "lot_sz_tencent_001",
10      "parking_lot_address" : "广东省深圳市南山区科技中一道10000号",
11      "longitude" : "113.934528",
12      "latitude" : "22.540503",
13      "parking_lot_type" : "PARKING_LOT_TYPE_UNKNOWN",
14      "phone_number" : "0755-86013388",
15      "parking_sign_url" : "https://example.com/parking_sign.jpg",
16      "notification_text_list" : [
17        "example_notification_text_list"
18      ],
19      "payment_mini_prog_appid" : "wx1234567890abcdef",
20      "payment_path" : "/pages/pay/index?park_uuid=xxx",
21      "parking_order_mini_prog_appid" : "wx1234567890abcdef",
22      "parking_order_path" : "/pages/order/index",
23      "charging_rule" : {
24        "rule_type" : "CHARGING_RULE_UNKNOWN",
25        "fee_limit_type" : "FEE_LIMIT_UNKNOWN",
26        "daily_limit_type" : "DAILY_LIMIT_UNKNOWN",
27        "time_rounding_type" : "TIME_ROUND_UNKNOWN",
28        "free_entry_duration" : 1,
29        "free_exit_duration" : 1,
30        "fixed_interval_rule" : [
31          {
32            "day_type" : "DAY_TYPE_UNKNOWN",
33            "start_time" : "08:00",
34            "end_time" : "22:00",
35            "vehicle_type" : "VEHICLE_TYPE_UNKNOWN",
36            "plate_type" : "PLATE_TYPE_UNKNOWN",
37            "first_duration" : 1,
38            "first_amount" : 1,
39            "interval_duration" : 1,
40            "interval_amount" : 1,
41            "interval_max_amount" : 1,
42            "max_fee_per_day" : 1,
43            "free_period_charging_mode" : "FREE_PERIOD_CHARGING_UNKNOWN",
44            "free_period_calculation_mode" : "FREE_PERIOD_CAL_UNKNOWN",
45            "is_green_vehicle_free_parking" : false,
46            "first_duration_mode" : "FIRST_DURATION_MODE_UNKNOWN"
47          }
48        ],
49        "duration_segment_rule" : [
50          {
51            "day_type" : "DAY_TYPE_UNKNOWN",
52            "start_time" : "08:00",
53            "end_time" : "22:00",
54            "vehicle_type" : "VEHICLE_TYPE_UNKNOWN",
55            "plate_type" : "PLATE_TYPE_UNKNOWN",
56            "charge_mode" : "UNKNOWN",
57            "duration_from" : 1,
58            "duration_to" : 1,
59            "fixed_amount" : 1,
60            "interval_min" : 1,
61            "interval_amount" : 1,
62            "interval_max_amount" : 1,
63            "max_fee_per_day" : 1
64          }
65        ],
66        "pre_entry_rule" : [
67          {
68            "day_type" : "DAY_TYPE_UNKNOWN",
69            "start_time" : "08:00",
70            "end_time" : "22:00",
71            "vehicle_type" : "VEHICLE_TYPE_UNKNOWN",
72            "plate_type" : "PLATE_TYPE_UNKNOWN",
73            "amount" : 1,
74            "max_fee_per_day" : 1
75          }
76        ],
77        "holiday_mode" : "HOLIDAY_MODE_UNKNOWN",
78        "aggregate_limit_mode" : "AGGREGATE_LIMIT_MODE_UNKNOWN",
79        "first_charge_time_mode" : "FIRST_CHARGE_TIME_MODE_UNKNOWN"
80      }
81    }
82  }'
83

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 SubmitApplication {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/parking/reminders/application";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    SubmitApplication client = new SubmitApplication(
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    SubmitApplicationRequest request = new SubmitApplicationRequest();
41    request.parkingLot = new ParkingLot();
42    request.parkingLot.parkingLotName = "腾讯大厦停车场";
43    request.parkingLot.outParkingLotId = "lot_sz_tencent_001";
44    request.parkingLot.parkingLotAddress = "广东省深圳市南山区科技中一道10000号";
45    request.parkingLot.longitude = "113.934528";
46    request.parkingLot.latitude = "22.540503";
47    request.parkingLot.parkingLotType = ParkingLotType.PARKING_LOT_TYPE_UNKNOWN;
48    request.parkingLot.phoneNumber = "0755-86013388";
49    request.parkingLot.parkingSignUrl = "https://example.com/parking_sign.jpg";
50    request.parkingLot.notificationTextList = new ArrayList<>();
51    {
52      request.parkingLot.notificationTextList.add("example_notificationTextList");
53    };
54    request.parkingLot.paymentMiniProgAppid = "wx1234567890abcdef";
55    request.parkingLot.paymentPath = "/pages/pay/index?park_uuid=xxx";
56    request.parkingLot.parkingOrderMiniProgAppid = "wx1234567890abcdef";
57    request.parkingLot.parkingOrderPath = "/pages/order/index";
58    request.parkingLot.chargingRule = new ChargingRule();
59    request.parkingLot.chargingRule.ruleType = ChargingRuleType.CHARGING_RULE_UNKNOWN;
60    request.parkingLot.chargingRule.feeLimitType = FeeLimitType.FEE_LIMIT_UNKNOWN;
61    request.parkingLot.chargingRule.dailyLimitType = DailyLimitType.DAILY_LIMIT_UNKNOWN;
62    request.parkingLot.chargingRule.timeRoundingType = TimeRoundingType.TIME_ROUND_UNKNOWN;
63    request.parkingLot.chargingRule.freeEntryDuration = 1L;
64    request.parkingLot.chargingRule.freeExitDuration = 1L;
65    request.parkingLot.chargingRule.fixedIntervalRule = new ArrayList<>();
66    {
67      FixedIntervalRule fixedIntervalRuleItem = new FixedIntervalRule();
68      fixedIntervalRuleItem.dayType = DayType.DAY_TYPE_UNKNOWN;
69      fixedIntervalRuleItem.startTime = "08:00";
70      fixedIntervalRuleItem.endTime = "22:00";
71      fixedIntervalRuleItem.vehicleType = VehicleType.VEHICLE_TYPE_UNKNOWN;
72      fixedIntervalRuleItem.plateType = PlateType.PLATE_TYPE_UNKNOWN;
73      fixedIntervalRuleItem.firstDuration = 1L;
74      fixedIntervalRuleItem.firstAmount = 1L;
75      fixedIntervalRuleItem.intervalDuration = 1L;
76      fixedIntervalRuleItem.intervalAmount = 1L;
77      fixedIntervalRuleItem.intervalMaxAmount = 1L;
78      fixedIntervalRuleItem.maxFeePerDay = 1L;
79      fixedIntervalRuleItem.freePeriodChargingMode = FreePeriodChargingMode.FREE_PERIOD_CHARGING_UNKNOWN;
80      fixedIntervalRuleItem.freePeriodCalculationMode = FreePeriodCalculationMode.FREE_PERIOD_CAL_UNKNOWN;
81      fixedIntervalRuleItem.isGreenVehicleFreeParking = false;
82      fixedIntervalRuleItem.firstDurationMode = FirstDurationMode.FIRST_DURATION_MODE_UNKNOWN;
83      request.parkingLot.chargingRule.fixedIntervalRule.add(fixedIntervalRuleItem);
84    };
85    request.parkingLot.chargingRule.durationSegmentRule = new ArrayList<>();
86    {
87      DurationSegmentRule durationSegmentRuleItem = new DurationSegmentRule();
88      durationSegmentRuleItem.dayType = DayType.DAY_TYPE_UNKNOWN;
89      durationSegmentRuleItem.startTime = "08:00";
90      durationSegmentRuleItem.endTime = "22:00";
91      durationSegmentRuleItem.vehicleType = VehicleType.VEHICLE_TYPE_UNKNOWN;
92      durationSegmentRuleItem.plateType = PlateType.PLATE_TYPE_UNKNOWN;
93      durationSegmentRuleItem.chargeMode = ChargeMode.UNKNOWN;
94      durationSegmentRuleItem.durationFrom = 1L;
95      durationSegmentRuleItem.durationTo = 1L;
96      durationSegmentRuleItem.fixedAmount = 1L;
97      durationSegmentRuleItem.intervalMin = 1L;
98      durationSegmentRuleItem.intervalAmount = 1L;
99      durationSegmentRuleItem.intervalMaxAmount = 1L;
100      durationSegmentRuleItem.maxFeePerDay = 1L;
101      request.parkingLot.chargingRule.durationSegmentRule.add(durationSegmentRuleItem);
102    };
103    request.parkingLot.chargingRule.preEntryRule = new ArrayList<>();
104    {
105      PreEntryRule preEntryRuleItem = new PreEntryRule();
106      preEntryRuleItem.dayType = DayType.DAY_TYPE_UNKNOWN;
107      preEntryRuleItem.startTime = "08:00";
108      preEntryRuleItem.endTime = "22:00";
109      preEntryRuleItem.vehicleType = VehicleType.VEHICLE_TYPE_UNKNOWN;
110      preEntryRuleItem.plateType = PlateType.PLATE_TYPE_UNKNOWN;
111      preEntryRuleItem.amount = 1L;
112      preEntryRuleItem.maxFeePerDay = 1L;
113      request.parkingLot.chargingRule.preEntryRule.add(preEntryRuleItem);
114    };
115    request.parkingLot.chargingRule.holidayMode = HolidayMode.HOLIDAY_MODE_UNKNOWN;
116    request.parkingLot.chargingRule.aggregateLimitMode = AggregateLimitMode.AGGREGATE_LIMIT_MODE_UNKNOWN;
117    request.parkingLot.chargingRule.firstChargeTimeMode = FirstChargeTimeMode.FIRST_CHARGE_TIME_MODE_UNKNOWN;
118    try {
119      SubmitApplicationResponse response = client.run(request);
120        // TODO: 请求成功，继续业务逻辑
121        System.out.println(response);
122    } catch (WXPayUtility.ApiException e) {
123        // TODO: 请求失败，根据状态码执行不同的逻辑
124        e.printStackTrace();
125    }
126  }
127
128  public SubmitApplicationResponse run(SubmitApplicationRequest request) {
129    String uri = PATH;
130    String reqBody = WXPayUtility.toJson(request);
131
132    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
133    reqBuilder.addHeader("Accept", "application/json");
134    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
135    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
136    reqBuilder.addHeader("Content-Type", "application/json");
137    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
138    reqBuilder.method(METHOD, requestBody);
139    Request httpRequest = reqBuilder.build();
140
141    // 发送HTTP请求
142    OkHttpClient client = new OkHttpClient.Builder().build();
143    try (Response httpResponse = client.newCall(httpRequest).execute()) {
144      String respBody = WXPayUtility.extractBody(httpResponse);
145      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
146        // 2XX 成功，验证应答签名
147        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
148            httpResponse.headers(), respBody);
149
150        // 从HTTP应答报文构建返回数据
151        return WXPayUtility.fromJson(respBody, SubmitApplicationResponse.class);
152      } else {
153        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
154      }
155    } catch (IOException e) {
156      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
157    }
158  }
159
160  private final String mchid;
161  private final String certificateSerialNo;
162  private final PrivateKey privateKey;
163  private final String wechatPayPublicKeyId;
164  private final PublicKey wechatPayPublicKey;
165
166  public SubmitApplication(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
167    this.mchid = mchid;
168    this.certificateSerialNo = certificateSerialNo;
169    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
170    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
171    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
172  }
173
174  public static class SubmitApplicationRequest {
175    @SerializedName("parking_lot")
176    public ParkingLot parkingLot;
177  }
178  
179  public static class SubmitApplicationResponse {
180    @SerializedName("code")
181    public String code;
182  
183    @SerializedName("message")
184    public String message;
185  
186    @SerializedName("parking_lot_audit_no")
187    public String parkingLotAuditNo;
188  }
189  
190  public static class ParkingLot {
191    @SerializedName("parking_lot_name")
192    public String parkingLotName;
193  
194    @SerializedName("out_parking_lot_id")
195    public String outParkingLotId;
196  
197    @SerializedName("parking_lot_address")
198    public String parkingLotAddress;
199  
200    @SerializedName("longitude")
201    public String longitude;
202  
203    @SerializedName("latitude")
204    public String latitude;
205  
206    @SerializedName("parking_lot_type")
207    public ParkingLotType parkingLotType;
208  
209    @SerializedName("phone_number")
210    public String phoneNumber;
211  
212    @SerializedName("parking_sign_url")
213    public String parkingSignUrl;
214  
215    @SerializedName("notification_text_list")
216    public List<String> notificationTextList;
217  
218    @SerializedName("payment_mini_prog_appid")
219    public String paymentMiniProgAppid;
220  
221    @SerializedName("payment_path")
222    public String paymentPath;
223  
224    @SerializedName("parking_order_mini_prog_appid")
225    public String parkingOrderMiniProgAppid;
226  
227    @SerializedName("parking_order_path")
228    public String parkingOrderPath;
229  
230    @SerializedName("charging_rule")
231    public ChargingRule chargingRule;
232  }
233  
234  public enum ParkingLotType {
235    @SerializedName("PARKING_LOT_TYPE_UNKNOWN")
236    PARKING_LOT_TYPE_UNKNOWN,
237    @SerializedName("PARKING_LOT_TYPE_BUSINESS_DISTRICT")
238    PARKING_LOT_TYPE_BUSINESS_DISTRICT,
239    @SerializedName("PARKING_LOT_TYPE_OFFICE_BUILDING")
240    PARKING_LOT_TYPE_OFFICE_BUILDING,
241    @SerializedName("PARKING_LOT_TYPE_TRANSPORTATION_HUB")
242    PARKING_LOT_TYPE_TRANSPORTATION_HUB,
243    @SerializedName("PARKING_LOT_TYPE_RESIDENTIAL_AREA")
244    PARKING_LOT_TYPE_RESIDENTIAL_AREA,
245    @SerializedName("PARKING_LOT_TYPE_PARK_AREA")
246    PARKING_LOT_TYPE_PARK_AREA,
247    @SerializedName("PARKING_LOT_TYPE_OTHER_PUBLIC_FACILITY")
248    PARKING_LOT_TYPE_OTHER_PUBLIC_FACILITY
249  }
250  
251  public static class ChargingRule {
252    @SerializedName("rule_type")
253    public ChargingRuleType ruleType;
254  
255    @SerializedName("fee_limit_type")
256    public FeeLimitType feeLimitType;
257  
258    @SerializedName("daily_limit_type")
259    public DailyLimitType dailyLimitType;
260  
261    @SerializedName("time_rounding_type")
262    public TimeRoundingType timeRoundingType;
263  
264    @SerializedName("free_entry_duration")
265    public Long freeEntryDuration;
266  
267    @SerializedName("free_exit_duration")
268    public Long freeExitDuration;
269  
270    @SerializedName("fixed_interval_rule")
271    public List<FixedIntervalRule> fixedIntervalRule;
272  
273    @SerializedName("duration_segment_rule")
274    public List<DurationSegmentRule> durationSegmentRule;
275  
276    @SerializedName("pre_entry_rule")
277    public List<PreEntryRule> preEntryRule;
278  
279    @SerializedName("holiday_mode")
280    public HolidayMode holidayMode;
281  
282    @SerializedName("aggregate_limit_mode")
283    public AggregateLimitMode aggregateLimitMode;
284  
285    @SerializedName("first_charge_time_mode")
286    public FirstChargeTimeMode firstChargeTimeMode;
287  }
288  
289  public enum ChargingRuleType {
290    @SerializedName("CHARGING_RULE_UNKNOWN")
291    CHARGING_RULE_UNKNOWN,
292    @SerializedName("CHARGING_RULE_FIXED_INTERVAL")
293    CHARGING_RULE_FIXED_INTERVAL,
294    @SerializedName("CHARGING_RULE_SEGMENT")
295    CHARGING_RULE_SEGMENT,
296    @SerializedName("CHARGING_RULE_PER_ENTRY")
297    CHARGING_RULE_PER_ENTRY
298  }
299  
300  public enum FeeLimitType {
301    @SerializedName("FEE_LIMIT_UNKNOWN")
302    FEE_LIMIT_UNKNOWN,
303    @SerializedName("FEE_LIMIT_AGGREGATE")
304    FEE_LIMIT_AGGREGATE,
305    @SerializedName("FEE_LIMIT_SINGLE")
306    FEE_LIMIT_SINGLE
307  }
308  
309  public enum DailyLimitType {
310    @SerializedName("DAILY_LIMIT_UNKNOWN")
311    DAILY_LIMIT_UNKNOWN,
312    @SerializedName("DAILY_LIMIT_ROLLING_24H")
313    DAILY_LIMIT_ROLLING_24H,
314    @SerializedName("DAILY_LIMIT_CALENDAR_DAY")
315    DAILY_LIMIT_CALENDAR_DAY
316  }
317  
318  public enum TimeRoundingType {
319    @SerializedName("TIME_ROUND_UNKNOWN")
320    TIME_ROUND_UNKNOWN,
321    @SerializedName("TIME_ROUND_DOWN")
322    TIME_ROUND_DOWN,
323    @SerializedName("TIME_ROUND_UP")
324    TIME_ROUND_UP
325  }
326  
327  public static class FixedIntervalRule {
328    @SerializedName("day_type")
329    public DayType dayType;
330  
331    @SerializedName("start_time")
332    public String startTime;
333  
334    @SerializedName("end_time")
335    public String endTime;
336  
337    @SerializedName("vehicle_type")
338    public VehicleType vehicleType;
339  
340    @SerializedName("plate_type")
341    public PlateType plateType;
342  
343    @SerializedName("first_duration")
344    public Long firstDuration;
345  
346    @SerializedName("first_amount")
347    public Long firstAmount;
348  
349    @SerializedName("interval_duration")
350    public Long intervalDuration;
351  
352    @SerializedName("interval_amount")
353    public Long intervalAmount;
354  
355    @SerializedName("interval_max_amount")
356    public Long intervalMaxAmount;
357  
358    @SerializedName("max_fee_per_day")
359    public Long maxFeePerDay;
360  
361    @SerializedName("free_period_charging_mode")
362    public FreePeriodChargingMode freePeriodChargingMode;
363  
364    @SerializedName("free_period_calculation_mode")
365    public FreePeriodCalculationMode freePeriodCalculationMode;
366  
367    @SerializedName("is_green_vehicle_free_parking")
368    public Boolean isGreenVehicleFreeParking;
369  
370    @SerializedName("first_duration_mode")
371    public FirstDurationMode firstDurationMode;
372  }
373  
374  public static class DurationSegmentRule {
375    @SerializedName("day_type")
376    public DayType dayType;
377  
378    @SerializedName("start_time")
379    public String startTime;
380  
381    @SerializedName("end_time")
382    public String endTime;
383  
384    @SerializedName("vehicle_type")
385    public VehicleType vehicleType;
386  
387    @SerializedName("plate_type")
388    public PlateType plateType;
389  
390    @SerializedName("charge_mode")
391    public ChargeMode chargeMode;
392  
393    @SerializedName("duration_from")
394    public Long durationFrom;
395  
396    @SerializedName("duration_to")
397    public Long durationTo;
398  
399    @SerializedName("fixed_amount")
400    public Long fixedAmount;
401  
402    @SerializedName("interval_min")
403    public Long intervalMin;
404  
405    @SerializedName("interval_amount")
406    public Long intervalAmount;
407  
408    @SerializedName("interval_max_amount")
409    public Long intervalMaxAmount;
410  
411    @SerializedName("max_fee_per_day")
412    public Long maxFeePerDay;
413  }
414  
415  public static class PreEntryRule {
416    @SerializedName("day_type")
417    public DayType dayType;
418  
419    @SerializedName("start_time")
420    public String startTime;
421  
422    @SerializedName("end_time")
423    public String endTime;
424  
425    @SerializedName("vehicle_type")
426    public VehicleType vehicleType;
427  
428    @SerializedName("plate_type")
429    public PlateType plateType;
430  
431    @SerializedName("amount")
432    public Long amount;
433  
434    @SerializedName("max_fee_per_day")
435    public Long maxFeePerDay;
436  }
437  
438  public enum HolidayMode {
439    @SerializedName("HOLIDAY_MODE_UNKNOWN")
440    HOLIDAY_MODE_UNKNOWN,
441    @SerializedName("HOLIDAY_MODE_LEGAL_MODY")
442    HOLIDAY_MODE_LEGAL_MODY,
443    @SerializedName("HOLIDAY_MODE_CALENDAR_MODY")
444    HOLIDAY_MODE_CALENDAR_MODY,
445    @SerializedName("HOLIDAY_MODE_FINANCIAL_MODY")
446    HOLIDAY_MODE_FINANCIAL_MODY
447  }
448  
449  public enum AggregateLimitMode {
450    @SerializedName("AGGREGATE_LIMIT_MODE_UNKNOWN")
451    AGGREGATE_LIMIT_MODE_UNKNOWN,
452    @SerializedName("AGGREGATE_LIMIT_MODE_NORMAL")
453    AGGREGATE_LIMIT_MODE_NORMAL,
454    @SerializedName("AGGREGATE_LIMIT_MODE_MIN")
455    AGGREGATE_LIMIT_MODE_MIN
456  }
457  
458  public enum FirstChargeTimeMode {
459    @SerializedName("FIRST_CHARGE_TIME_MODE_UNKNOWN")
460    FIRST_CHARGE_TIME_MODE_UNKNOWN,
461    @SerializedName("FIRST_CHARGE_TIME_MODE_ENTER")
462    FIRST_CHARGE_TIME_MODE_ENTER,
463    @SerializedName("FIRST_CHARGE_TIME_MODE_AFTER_FREE")
464    FIRST_CHARGE_TIME_MODE_AFTER_FREE
465  }
466  
467  public enum DayType {
468    @SerializedName("DAY_TYPE_UNKNOWN")
469    DAY_TYPE_UNKNOWN,
470    @SerializedName("DAY_TYPE_WEEKDAY")
471    DAY_TYPE_WEEKDAY,
472    @SerializedName("DAY_TYPE_HOLIDAY")
473    DAY_TYPE_HOLIDAY,
474    @SerializedName("DAY_TYPE_ALL_DAY")
475    DAY_TYPE_ALL_DAY
476  }
477  
478  public enum VehicleType {
479    @SerializedName("VEHICLE_TYPE_UNKNOWN")
480    VEHICLE_TYPE_UNKNOWN,
481    @SerializedName("VEHICLE_TYPE_SMALL")
482    VEHICLE_TYPE_SMALL,
483    @SerializedName("VEHICLE_TYPE_LARGE")
484    VEHICLE_TYPE_LARGE,
485    @SerializedName("VEHICLE_TYPE_EXTRA_LARGE")
486    VEHICLE_TYPE_EXTRA_LARGE,
487    @SerializedName("VEHICLE_TYPE_ALL_TYPE")
488    VEHICLE_TYPE_ALL_TYPE
489  }
490  
491  public enum PlateType {
492    @SerializedName("PLATE_TYPE_UNKNOWN")
493    PLATE_TYPE_UNKNOWN,
494    @SerializedName("PLATE_TYPE_TEMPORARY")
495    PLATE_TYPE_TEMPORARY,
496    @SerializedName("PLATE_TYPE_MONTHLY")
497    PLATE_TYPE_MONTHLY,
498    @SerializedName("PLATE_TYPE_FREE")
499    PLATE_TYPE_FREE,
500    @SerializedName("PLATE_TYPE_PREPAID")
501    PLATE_TYPE_PREPAID,
502    @SerializedName("PLATE_TYPE_OTHERS")
503    PLATE_TYPE_OTHERS
504  }
505  
506  public enum FreePeriodChargingMode {
507    @SerializedName("FREE_PERIOD_CHARGING_UNKNOWN")
508    FREE_PERIOD_CHARGING_UNKNOWN,
509    @SerializedName("FREE_PERIOD_CHARGING_ONCE_PER_ENTRY")
510    FREE_PERIOD_CHARGING_ONCE_PER_ENTRY,
511    @SerializedName("FREE_PERIOD_CHARGING_ONCE_PER_24_HOURS")
512    FREE_PERIOD_CHARGING_ONCE_PER_24_HOURS,
513    @SerializedName("FREE_PERIOD_CHARGING_ONCE_PER_CALENDAR_DAY")
514    FREE_PERIOD_CHARGING_ONCE_PER_CALENDAR_DAY,
515    @SerializedName("FREE_PERIOD_CHARGING_CUMULATIVE_QUOTA_CALCULATION")
516    FREE_PERIOD_CHARGING_CUMULATIVE_QUOTA_CALCULATION
517  }
518  
519  public enum FreePeriodCalculationMode {
520    @SerializedName("FREE_PERIOD_CAL_UNKNOWN")
521    FREE_PERIOD_CAL_UNKNOWN,
522    @SerializedName("FREE_PERIOD_CAL_CONCURRENT_START")
523    FREE_PERIOD_CAL_CONCURRENT_START,
524    @SerializedName("FREE_PERIOD_CAL_SEQUENTIAL_START")
525    FREE_PERIOD_CAL_SEQUENTIAL_START
526  }
527  
528  public enum FirstDurationMode {
529    @SerializedName("FIRST_DURATION_MODE_UNKNOWN")
530    FIRST_DURATION_MODE_UNKNOWN,
531    @SerializedName("FIRST_DURATION_MODE_ONLY_FIRST_DURATION")
532    FIRST_DURATION_MODE_ONLY_FIRST_DURATION,
533    @SerializedName("FIRST_DURATION_MODE_EVERY_FIRST_DURATION")
534    FIRST_DURATION_MODE_EVERY_FIRST_DURATION
535  }
536  
537  public enum ChargeMode {
538    @SerializedName("UNKNOWN")
539    UNKNOWN,
540    @SerializedName("INTERVAL")
541    INTERVAL,
542    @SerializedName("ONE_TIME")
543    ONE_TIME
544  }
545  
546}
547

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 := &SubmitApplicationRequest{
27		ParkingLot: &ParkingLot{
28			ParkingLotName:            wxpay_utility.String("腾讯大厦停车场"),
29			OutParkingLotId:           wxpay_utility.String("lot_sz_tencent_001"),
30			ParkingLotAddress:         wxpay_utility.String("广东省深圳市南山区科技中一道10000号"),
31			Longitude:                 wxpay_utility.String("113.934528"),
32			Latitude:                  wxpay_utility.String("22.540503"),
33			ParkingLotType:            PARKINGLOTTYPE_PARKING_LOT_TYPE_UNKNOWN.Ptr(),
34			PhoneNumber:               wxpay_utility.String("0755-86013388"),
35			ParkingSignUrl:            wxpay_utility.String("https://example.com/parking_sign.jpg"),
36			NotificationTextList:      []string{"example_NotificationTextList"},
37			PaymentMiniProgAppid:      wxpay_utility.String("wx1234567890abcdef"),
38			PaymentPath:               wxpay_utility.String("/pages/pay/index?park_uuid=xxx"),
39			ParkingOrderMiniProgAppid: wxpay_utility.String("wx1234567890abcdef"),
40			ParkingOrderPath:          wxpay_utility.String("/pages/order/index"),
41			ChargingRule: &ChargingRule{
42				RuleType:          CHARGINGRULETYPE_CHARGING_RULE_UNKNOWN.Ptr(),
43				FeeLimitType:      FEELIMITTYPE_FEE_LIMIT_UNKNOWN.Ptr(),
44				DailyLimitType:    DAILYLIMITTYPE_DAILY_LIMIT_UNKNOWN.Ptr(),
45				TimeRoundingType:  TIMEROUNDINGTYPE_TIME_ROUND_UNKNOWN.Ptr(),
46				FreeEntryDuration: wxpay_utility.Int64(1),
47				FreeExitDuration:  wxpay_utility.Int64(1),
48				FixedIntervalRule: []FixedIntervalRule{FixedIntervalRule{
49					DayType:                   DAYTYPE_DAY_TYPE_UNKNOWN.Ptr(),
50					StartTime:                 wxpay_utility.String("08:00"),
51					EndTime:                   wxpay_utility.String("22:00"),
52					VehicleType:               VEHICLETYPE_VEHICLE_TYPE_UNKNOWN.Ptr(),
53					PlateType:                 PLATETYPE_PLATE_TYPE_UNKNOWN.Ptr(),
54					FirstDuration:             wxpay_utility.Int64(1),
55					FirstAmount:               wxpay_utility.Int64(1),
56					IntervalDuration:          wxpay_utility.Int64(1),
57					IntervalAmount:            wxpay_utility.Int64(1),
58					IntervalMaxAmount:         wxpay_utility.Int64(1),
59					MaxFeePerDay:              wxpay_utility.Int64(1),
60					FreePeriodChargingMode:    FREEPERIODCHARGINGMODE_FREE_PERIOD_CHARGING_UNKNOWN.Ptr(),
61					FreePeriodCalculationMode: FREEPERIODCALCULATIONMODE_FREE_PERIOD_CAL_UNKNOWN.Ptr(),
62					IsGreenVehicleFreeParking: wxpay_utility.Bool(false),
63					FirstDurationMode:         FIRSTDURATIONMODE_FIRST_DURATION_MODE_UNKNOWN.Ptr(),
64				}},
65				DurationSegmentRule: []DurationSegmentRule{DurationSegmentRule{
66					DayType:           DAYTYPE_DAY_TYPE_UNKNOWN.Ptr(),
67					StartTime:         wxpay_utility.String("08:00"),
68					EndTime:           wxpay_utility.String("22:00"),
69					VehicleType:       VEHICLETYPE_VEHICLE_TYPE_UNKNOWN.Ptr(),
70					PlateType:         PLATETYPE_PLATE_TYPE_UNKNOWN.Ptr(),
71					ChargeMode:        CHARGEMODE_UNKNOWN.Ptr(),
72					DurationFrom:      wxpay_utility.Int64(1),
73					DurationTo:        wxpay_utility.Int64(1),
74					FixedAmount:       wxpay_utility.Int64(1),
75					IntervalMin:       wxpay_utility.Int64(1),
76					IntervalAmount:    wxpay_utility.Int64(1),
77					IntervalMaxAmount: wxpay_utility.Int64(1),
78					MaxFeePerDay:      wxpay_utility.Int64(1),
79				}},
80				PreEntryRule: []PreEntryRule{PreEntryRule{
81					DayType:      DAYTYPE_DAY_TYPE_UNKNOWN.Ptr(),
82					StartTime:    wxpay_utility.String("08:00"),
83					EndTime:      wxpay_utility.String("22:00"),
84					VehicleType:  VEHICLETYPE_VEHICLE_TYPE_UNKNOWN.Ptr(),
85					PlateType:    PLATETYPE_PLATE_TYPE_UNKNOWN.Ptr(),
86					Amount:       wxpay_utility.Int64(1),
87					MaxFeePerDay: wxpay_utility.Int64(1),
88				}},
89				HolidayMode:         HOLIDAYMODE_HOLIDAY_MODE_UNKNOWN.Ptr(),
90				AggregateLimitMode:  AGGREGATELIMITMODE_AGGREGATE_LIMIT_MODE_UNKNOWN.Ptr(),
91				FirstChargeTimeMode: FIRSTCHARGETIMEMODE_FIRST_CHARGE_TIME_MODE_UNKNOWN.Ptr(),
92			},
93		},
94	}
95
96	response, err := SubmitApplication(config, request)
97	if err != nil {
98		fmt.Printf("请求失败: %+v\n", err)
99		// TODO: 请求失败，根据状态码执行不同的处理
100		return
101	}
102
103	// TODO: 请求成功，继续业务逻辑
104	fmt.Printf("请求成功: %+v\n", response)
105}
106
107func SubmitApplication(config *wxpay_utility.MchConfig, request *SubmitApplicationRequest) (response *SubmitApplicationResponse, err error) {
108	const (
109		host   = "https://api.mch.weixin.qq.com"
110		method = "POST"
111		path   = "/v3/parking/reminders/application"
112	)
113
114	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
115	if err != nil {
116		return nil, err
117	}
118	reqBody, err := json.Marshal(request)
119	if err != nil {
120		return nil, err
121	}
122	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
123	if err != nil {
124		return nil, err
125	}
126	httpRequest.Header.Set("Accept", "application/json")
127	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
128	httpRequest.Header.Set("Content-Type", "application/json")
129	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
130	if err != nil {
131		return nil, err
132	}
133	httpRequest.Header.Set("Authorization", authorization)
134
135	client := &http.Client{}
136	httpResponse, err := client.Do(httpRequest)
137	if err != nil {
138		return nil, err
139	}
140	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
141	if err != nil {
142		return nil, err
143	}
144	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
145		// 2XX 成功，验证应答签名
146		err = wxpay_utility.ValidateResponse(
147			config.WechatPayPublicKeyId(),
148			config.WechatPayPublicKey(),
149			&httpResponse.Header,
150			respBody,
151		)
152		if err != nil {
153			return nil, err
154		}
155		response := &SubmitApplicationResponse{}
156		if err := json.Unmarshal(respBody, response); err != nil {
157			return nil, err
158		}
159
160		return response, nil
161	} else {
162		return nil, wxpay_utility.NewApiException(
163			httpResponse.StatusCode,
164			httpResponse.Header,
165			respBody,
166		)
167	}
168}
169
170type SubmitApplicationRequest struct {
171	ParkingLot *ParkingLot `json:"parking_lot,omitempty"`
172}
173
174type SubmitApplicationResponse struct {
175	Code              *string `json:"code,omitempty"`
176	Message           *string `json:"message,omitempty"`
177	ParkingLotAuditNo *string `json:"parking_lot_audit_no,omitempty"`
178}
179
180type ParkingLot struct {
181	ParkingLotName            *string         `json:"parking_lot_name,omitempty"`
182	OutParkingLotId           *string         `json:"out_parking_lot_id,omitempty"`
183	ParkingLotAddress         *string         `json:"parking_lot_address,omitempty"`
184	Longitude                 *string         `json:"longitude,omitempty"`
185	Latitude                  *string         `json:"latitude,omitempty"`
186	ParkingLotType            *ParkingLotType `json:"parking_lot_type,omitempty"`
187	PhoneNumber               *string         `json:"phone_number,omitempty"`
188	ParkingSignUrl            *string         `json:"parking_sign_url,omitempty"`
189	NotificationTextList      []string        `json:"notification_text_list,omitempty"`
190	PaymentMiniProgAppid      *string         `json:"payment_mini_prog_appid,omitempty"`
191	PaymentPath               *string         `json:"payment_path,omitempty"`
192	ParkingOrderMiniProgAppid *string         `json:"parking_order_mini_prog_appid,omitempty"`
193	ParkingOrderPath          *string         `json:"parking_order_path,omitempty"`
194	ChargingRule              *ChargingRule   `json:"charging_rule,omitempty"`
195}
196
197type ParkingLotType string
198
199func (e ParkingLotType) Ptr() *ParkingLotType {
200	return &e
201}
202
203const (
204	PARKINGLOTTYPE_PARKING_LOT_TYPE_UNKNOWN               ParkingLotType = "PARKING_LOT_TYPE_UNKNOWN"
205	PARKINGLOTTYPE_PARKING_LOT_TYPE_BUSINESS_DISTRICT     ParkingLotType = "PARKING_LOT_TYPE_BUSINESS_DISTRICT"
206	PARKINGLOTTYPE_PARKING_LOT_TYPE_OFFICE_BUILDING       ParkingLotType = "PARKING_LOT_TYPE_OFFICE_BUILDING"
207	PARKINGLOTTYPE_PARKING_LOT_TYPE_TRANSPORTATION_HUB    ParkingLotType = "PARKING_LOT_TYPE_TRANSPORTATION_HUB"
208	PARKINGLOTTYPE_PARKING_LOT_TYPE_RESIDENTIAL_AREA      ParkingLotType = "PARKING_LOT_TYPE_RESIDENTIAL_AREA"
209	PARKINGLOTTYPE_PARKING_LOT_TYPE_PARK_AREA             ParkingLotType = "PARKING_LOT_TYPE_PARK_AREA"
210	PARKINGLOTTYPE_PARKING_LOT_TYPE_OTHER_PUBLIC_FACILITY ParkingLotType = "PARKING_LOT_TYPE_OTHER_PUBLIC_FACILITY"
211)
212
213type ChargingRule struct {
214	RuleType            *ChargingRuleType     `json:"rule_type,omitempty"`
215	FeeLimitType        *FeeLimitType         `json:"fee_limit_type,omitempty"`
216	DailyLimitType      *DailyLimitType       `json:"daily_limit_type,omitempty"`
217	TimeRoundingType    *TimeRoundingType     `json:"time_rounding_type,omitempty"`
218	FreeEntryDuration   *int64                `json:"free_entry_duration,omitempty"`
219	FreeExitDuration    *int64                `json:"free_exit_duration,omitempty"`
220	FixedIntervalRule   []FixedIntervalRule   `json:"fixed_interval_rule,omitempty"`
221	DurationSegmentRule []DurationSegmentRule `json:"duration_segment_rule,omitempty"`
222	PreEntryRule        []PreEntryRule        `json:"pre_entry_rule,omitempty"`
223	HolidayMode         *HolidayMode          `json:"holiday_mode,omitempty"`
224	AggregateLimitMode  *AggregateLimitMode   `json:"aggregate_limit_mode,omitempty"`
225	FirstChargeTimeMode *FirstChargeTimeMode  `json:"first_charge_time_mode,omitempty"`
226}
227
228type ChargingRuleType string
229
230func (e ChargingRuleType) Ptr() *ChargingRuleType {
231	return &e
232}
233
234const (
235	CHARGINGRULETYPE_CHARGING_RULE_UNKNOWN        ChargingRuleType = "CHARGING_RULE_UNKNOWN"
236	CHARGINGRULETYPE_CHARGING_RULE_FIXED_INTERVAL ChargingRuleType = "CHARGING_RULE_FIXED_INTERVAL"
237	CHARGINGRULETYPE_CHARGING_RULE_SEGMENT        ChargingRuleType = "CHARGING_RULE_SEGMENT"
238	CHARGINGRULETYPE_CHARGING_RULE_PER_ENTRY      ChargingRuleType = "CHARGING_RULE_PER_ENTRY"
239)
240
241type FeeLimitType string
242
243func (e FeeLimitType) Ptr() *FeeLimitType {
244	return &e
245}
246
247const (
248	FEELIMITTYPE_FEE_LIMIT_UNKNOWN   FeeLimitType = "FEE_LIMIT_UNKNOWN"
249	FEELIMITTYPE_FEE_LIMIT_AGGREGATE FeeLimitType = "FEE_LIMIT_AGGREGATE"
250	FEELIMITTYPE_FEE_LIMIT_SINGLE    FeeLimitType = "FEE_LIMIT_SINGLE"
251)
252
253type DailyLimitType string
254
255func (e DailyLimitType) Ptr() *DailyLimitType {
256	return &e
257}
258
259const (
260	DAILYLIMITTYPE_DAILY_LIMIT_UNKNOWN      DailyLimitType = "DAILY_LIMIT_UNKNOWN"
261	DAILYLIMITTYPE_DAILY_LIMIT_ROLLING_24_H DailyLimitType = "DAILY_LIMIT_ROLLING_24H"
262	DAILYLIMITTYPE_DAILY_LIMIT_CALENDAR_DAY DailyLimitType = "DAILY_LIMIT_CALENDAR_DAY"
263)
264
265type TimeRoundingType string
266
267func (e TimeRoundingType) Ptr() *TimeRoundingType {
268	return &e
269}
270
271const (
272	TIMEROUNDINGTYPE_TIME_ROUND_UNKNOWN TimeRoundingType = "TIME_ROUND_UNKNOWN"
273	TIMEROUNDINGTYPE_TIME_ROUND_DOWN    TimeRoundingType = "TIME_ROUND_DOWN"
274	TIMEROUNDINGTYPE_TIME_ROUND_UP      TimeRoundingType = "TIME_ROUND_UP"
275)
276
277type FixedIntervalRule struct {
278	DayType                   *DayType                   `json:"day_type,omitempty"`
279	StartTime                 *string                    `json:"start_time,omitempty"`
280	EndTime                   *string                    `json:"end_time,omitempty"`
281	VehicleType               *VehicleType               `json:"vehicle_type,omitempty"`
282	PlateType                 *PlateType                 `json:"plate_type,omitempty"`
283	FirstDuration             *int64                     `json:"first_duration,omitempty"`
284	FirstAmount               *int64                     `json:"first_amount,omitempty"`
285	IntervalDuration          *int64                     `json:"interval_duration,omitempty"`
286	IntervalAmount            *int64                     `json:"interval_amount,omitempty"`
287	IntervalMaxAmount         *int64                     `json:"interval_max_amount,omitempty"`
288	MaxFeePerDay              *int64                     `json:"max_fee_per_day,omitempty"`
289	FreePeriodChargingMode    *FreePeriodChargingMode    `json:"free_period_charging_mode,omitempty"`
290	FreePeriodCalculationMode *FreePeriodCalculationMode `json:"free_period_calculation_mode,omitempty"`
291	IsGreenVehicleFreeParking *bool                      `json:"is_green_vehicle_free_parking,omitempty"`
292	FirstDurationMode         *FirstDurationMode         `json:"first_duration_mode,omitempty"`
293}
294
295type DurationSegmentRule struct {
296	DayType           *DayType     `json:"day_type,omitempty"`
297	StartTime         *string      `json:"start_time,omitempty"`
298	EndTime           *string      `json:"end_time,omitempty"`
299	VehicleType       *VehicleType `json:"vehicle_type,omitempty"`
300	PlateType         *PlateType   `json:"plate_type,omitempty"`
301	ChargeMode        *ChargeMode  `json:"charge_mode,omitempty"`
302	DurationFrom      *int64       `json:"duration_from,omitempty"`
303	DurationTo        *int64       `json:"duration_to,omitempty"`
304	FixedAmount       *int64       `json:"fixed_amount,omitempty"`
305	IntervalMin       *int64       `json:"interval_min,omitempty"`
306	IntervalAmount    *int64       `json:"interval_amount,omitempty"`
307	IntervalMaxAmount *int64       `json:"interval_max_amount,omitempty"`
308	MaxFeePerDay      *int64       `json:"max_fee_per_day,omitempty"`
309}
310
311type PreEntryRule struct {
312	DayType      *DayType     `json:"day_type,omitempty"`
313	StartTime    *string      `json:"start_time,omitempty"`
314	EndTime      *string      `json:"end_time,omitempty"`
315	VehicleType  *VehicleType `json:"vehicle_type,omitempty"`
316	PlateType    *PlateType   `json:"plate_type,omitempty"`
317	Amount       *int64       `json:"amount,omitempty"`
318	MaxFeePerDay *int64       `json:"max_fee_per_day,omitempty"`
319}
320
321type HolidayMode string
322
323func (e HolidayMode) Ptr() *HolidayMode {
324	return &e
325}
326
327const (
328	HOLIDAYMODE_HOLIDAY_MODE_UNKNOWN        HolidayMode = "HOLIDAY_MODE_UNKNOWN"
329	HOLIDAYMODE_HOLIDAY_MODE_LEGAL_MODY     HolidayMode = "HOLIDAY_MODE_LEGAL_MODY"
330	HOLIDAYMODE_HOLIDAY_MODE_CALENDAR_MODY  HolidayMode = "HOLIDAY_MODE_CALENDAR_MODY"
331	HOLIDAYMODE_HOLIDAY_MODE_FINANCIAL_MODY HolidayMode = "HOLIDAY_MODE_FINANCIAL_MODY"
332)
333
334type AggregateLimitMode string
335
336func (e AggregateLimitMode) Ptr() *AggregateLimitMode {
337	return &e
338}
339
340const (
341	AGGREGATELIMITMODE_AGGREGATE_LIMIT_MODE_UNKNOWN AggregateLimitMode = "AGGREGATE_LIMIT_MODE_UNKNOWN"
342	AGGREGATELIMITMODE_AGGREGATE_LIMIT_MODE_NORMAL  AggregateLimitMode = "AGGREGATE_LIMIT_MODE_NORMAL"
343	AGGREGATELIMITMODE_AGGREGATE_LIMIT_MODE_MIN     AggregateLimitMode = "AGGREGATE_LIMIT_MODE_MIN"
344)
345
346type FirstChargeTimeMode string
347
348func (e FirstChargeTimeMode) Ptr() *FirstChargeTimeMode {
349	return &e
350}
351
352const (
353	FIRSTCHARGETIMEMODE_FIRST_CHARGE_TIME_MODE_UNKNOWN    FirstChargeTimeMode = "FIRST_CHARGE_TIME_MODE_UNKNOWN"
354	FIRSTCHARGETIMEMODE_FIRST_CHARGE_TIME_MODE_ENTER      FirstChargeTimeMode = "FIRST_CHARGE_TIME_MODE_ENTER"
355	FIRSTCHARGETIMEMODE_FIRST_CHARGE_TIME_MODE_AFTER_FREE FirstChargeTimeMode = "FIRST_CHARGE_TIME_MODE_AFTER_FREE"
356)
357
358type DayType string
359
360func (e DayType) Ptr() *DayType {
361	return &e
362}
363
364const (
365	DAYTYPE_DAY_TYPE_UNKNOWN DayType = "DAY_TYPE_UNKNOWN"
366	DAYTYPE_DAY_TYPE_WEEKDAY DayType = "DAY_TYPE_WEEKDAY"
367	DAYTYPE_DAY_TYPE_HOLIDAY DayType = "DAY_TYPE_HOLIDAY"
368	DAYTYPE_DAY_TYPE_ALL_DAY DayType = "DAY_TYPE_ALL_DAY"
369)
370
371type VehicleType string
372
373func (e VehicleType) Ptr() *VehicleType {
374	return &e
375}
376
377const (
378	VEHICLETYPE_VEHICLE_TYPE_UNKNOWN     VehicleType = "VEHICLE_TYPE_UNKNOWN"
379	VEHICLETYPE_VEHICLE_TYPE_SMALL       VehicleType = "VEHICLE_TYPE_SMALL"
380	VEHICLETYPE_VEHICLE_TYPE_LARGE       VehicleType = "VEHICLE_TYPE_LARGE"
381	VEHICLETYPE_VEHICLE_TYPE_EXTRA_LARGE VehicleType = "VEHICLE_TYPE_EXTRA_LARGE"
382	VEHICLETYPE_VEHICLE_TYPE_ALL_TYPE    VehicleType = "VEHICLE_TYPE_ALL_TYPE"
383)
384
385type PlateType string
386
387func (e PlateType) Ptr() *PlateType {
388	return &e
389}
390
391const (
392	PLATETYPE_PLATE_TYPE_UNKNOWN   PlateType = "PLATE_TYPE_UNKNOWN"
393	PLATETYPE_PLATE_TYPE_TEMPORARY PlateType = "PLATE_TYPE_TEMPORARY"
394	PLATETYPE_PLATE_TYPE_MONTHLY   PlateType = "PLATE_TYPE_MONTHLY"
395	PLATETYPE_PLATE_TYPE_FREE      PlateType = "PLATE_TYPE_FREE"
396	PLATETYPE_PLATE_TYPE_PREPAID   PlateType = "PLATE_TYPE_PREPAID"
397	PLATETYPE_PLATE_TYPE_OTHERS    PlateType = "PLATE_TYPE_OTHERS"
398)
399
400type FreePeriodChargingMode string
401
402func (e FreePeriodChargingMode) Ptr() *FreePeriodChargingMode {
403	return &e
404}
405
406const (
407	FREEPERIODCHARGINGMODE_FREE_PERIOD_CHARGING_UNKNOWN                      FreePeriodChargingMode = "FREE_PERIOD_CHARGING_UNKNOWN"
408	FREEPERIODCHARGINGMODE_FREE_PERIOD_CHARGING_ONCE_PER_ENTRY               FreePeriodChargingMode = "FREE_PERIOD_CHARGING_ONCE_PER_ENTRY"
409	FREEPERIODCHARGINGMODE_FREE_PERIOD_CHARGING_ONCE_PER_24_HOURS            FreePeriodChargingMode = "FREE_PERIOD_CHARGING_ONCE_PER_24_HOURS"
410	FREEPERIODCHARGINGMODE_FREE_PERIOD_CHARGING_ONCE_PER_CALENDAR_DAY        FreePeriodChargingMode = "FREE_PERIOD_CHARGING_ONCE_PER_CALENDAR_DAY"
411	FREEPERIODCHARGINGMODE_FREE_PERIOD_CHARGING_CUMULATIVE_QUOTA_CALCULATION FreePeriodChargingMode = "FREE_PERIOD_CHARGING_CUMULATIVE_QUOTA_CALCULATION"
412)
413
414type FreePeriodCalculationMode string
415
416func (e FreePeriodCalculationMode) Ptr() *FreePeriodCalculationMode {
417	return &e
418}
419
420const (
421	FREEPERIODCALCULATIONMODE_FREE_PERIOD_CAL_UNKNOWN          FreePeriodCalculationMode = "FREE_PERIOD_CAL_UNKNOWN"
422	FREEPERIODCALCULATIONMODE_FREE_PERIOD_CAL_CONCURRENT_START FreePeriodCalculationMode = "FREE_PERIOD_CAL_CONCURRENT_START"
423	FREEPERIODCALCULATIONMODE_FREE_PERIOD_CAL_SEQUENTIAL_START FreePeriodCalculationMode = "FREE_PERIOD_CAL_SEQUENTIAL_START"
424)
425
426type FirstDurationMode string
427
428func (e FirstDurationMode) Ptr() *FirstDurationMode {
429	return &e
430}
431
432const (
433	FIRSTDURATIONMODE_FIRST_DURATION_MODE_UNKNOWN              FirstDurationMode = "FIRST_DURATION_MODE_UNKNOWN"
434	FIRSTDURATIONMODE_FIRST_DURATION_MODE_ONLY_FIRST_DURATION  FirstDurationMode = "FIRST_DURATION_MODE_ONLY_FIRST_DURATION"
435	FIRSTDURATIONMODE_FIRST_DURATION_MODE_EVERY_FIRST_DURATION FirstDurationMode = "FIRST_DURATION_MODE_EVERY_FIRST_DURATION"
436)
437
438type ChargeMode string
439
440func (e ChargeMode) Ptr() *ChargeMode {
441	return &e
442}
443
444const (
445	CHARGEMODE_UNKNOWN  ChargeMode = "UNKNOWN"
446	CHARGEMODE_INTERVAL ChargeMode = "INTERVAL"
447	CHARGEMODE_ONE_TIME ChargeMode = "ONE_TIME"
448)
449