autumn/jsowell-charger-web
1
0
Fork 0
mirror of https://codeup.aliyun.com/67c68d4e484ca2f0a13ac3c1/ydc/jsowell-charger-web.git synced 2026-04-21 19:45:09 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
e50b4ff7edbaeed43c53ee6db49b4c0dac9b57d2
jsowell-charger-web/jsowell-admin/src/test/java/SpringBootTestController.java

3119 lines
143 KiB
Java
Raw Normal View History

提供给lianlian获取token
2023-05-26 19:25:35 +08:00
import cn.hutool.json.JSONUtil;
update 联联
2023-05-27 11:55:45 +08:00
import com.alibaba.fastjson2.JSON;
update 计算退款金额
2023-09-14 17:36:45 +08:00
import com.alibaba.fastjson2.JSONArray;
commit
2023-03-04 16:29:55 +08:00
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
保存汇付支付退款回调记录
2023-05-31 16:05:18 +08:00
import com.fasterxml.jackson.databind.DeserializationFeature;
加日志
2023-05-30 16:33:49 +08:00
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
commit
2023-03-04 16:29:55 +08:00
import com.google.common.collect.ImmutableMap;
update 高德
2023-06-26 17:10:36 +08:00
import com.google.common.collect.Lists;
汇付支付 执行退款
2023-05-27 16:01:27 +08:00
import com.google.common.collect.Maps;
update
2023-07-17 16:44:04 +08:00
import com.google.common.collect.Sets;
update 0x31报文回复不足位数补零
2023-06-12 17:38:16 +08:00
import com.google.common.primitives.Bytes;
update 汇付会员逻辑修改
2023-06-15 14:06:33 +08:00
import com.huifu.adapay.core.exception.BaseAdaPayException;
update 实时分账
2023-08-25 16:07:15 +08:00
import com.huifu.adapay.model.Payment;
update
2023-10-08 16:42:56 +08:00
import com.huifu.adapay.model.PaymentReverse;
汇付支付 执行退款
2023-05-27 16:01:27 +08:00
import com.huifu.adapay.model.Refund;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.JsowellApplication;
update 支付 占桩订单 后面拼上时间戳
2023-11-03 16:07:28 +08:00
import com.jsowell.adapay.common.AdaPayment;
多商户配置
2023-08-15 11:02:02 +08:00
import com.jsowell.adapay.config.AbstractAdapayConfig;
查询支付确认对象列表
2023-08-21 08:52:32 +08:00
import com.jsowell.adapay.dto.QueryAcctFlowDTO;
查询支付确认对象列表
2023-08-21 16:19:33 +08:00
import com.jsowell.adapay.dto.QueryPaymentConfirmDTO;
手动变更银行卡信息
2023-08-21 15:37:00 +08:00
import com.jsowell.adapay.dto.SettleAccountDTO;
多商户配置
2023-08-15 11:02:02 +08:00
import com.jsowell.adapay.factory.AdapayConfigFactory;
优化余额支付订单
2023-09-28 16:48:24 +08:00
import com.jsowell.adapay.operation.PaymentReverseOperation;
update
2023-09-28 09:16:44 +08:00
import com.jsowell.adapay.response.PaymentConfirmResponse;
优化余额支付订单
2023-09-28 16:48:24 +08:00
import com.jsowell.adapay.response.PaymentReverseResponse;
查询支付确认对象列表
2023-08-21 16:19:33 +08:00
import com.jsowell.adapay.response.QueryPaymentConfirmDetailResponse;
优化余额支付订单
2023-09-28 16:48:24 +08:00
import com.jsowell.adapay.response.RefundResponse;
支付占桩订单
2023-08-18 09:52:12 +08:00
import com.jsowell.adapay.service.AdapayService;
汇付基础响应
2023-08-21 13:20:17 +08:00
import com.jsowell.adapay.vo.DrawCashDetailVO;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.common.constant.CacheConstants;
import com.jsowell.common.constant.Constants;
update 汇付支付 支付回调
2023-05-30 13:45:56 +08:00
import com.jsowell.common.core.domain.entity.SysDictData;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.common.core.domain.ykc.LoginRequestData;
import com.jsowell.common.core.domain.ykc.TransactionRecordsData;
import com.jsowell.common.core.redis.RedisCache;
新增 订单流程测试方法
2023-08-30 10:13:56 +08:00
import com.jsowell.common.enums.AcquirerEnum;
update 保存提现信息
2023-08-01 16:16:34 +08:00
import com.jsowell.common.enums.DelFlagEnum;
update 卡启动、vin启动逻辑修改
2023-07-08 11:33:45 +08:00
import com.jsowell.common.enums.ykc.*;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.common.exception.BusinessException;
add 联联平台相关工具类
2023-05-10 08:49:01 +08:00
import com.jsowell.common.util.*;
update
2023-07-08 09:58:20 +08:00
import com.jsowell.common.util.Cp56Time2a.Cp56Time2aUtil;
update 联联
2023-05-30 14:22:34 +08:00
import com.jsowell.common.util.http.HttpUtils;
update
2023-07-08 09:58:20 +08:00
import com.jsowell.common.util.id.IdUtils;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.common.util.id.SnowflakeIdWorker;
import com.jsowell.common.util.ip.AddressUtils;
import com.jsowell.netty.handler.HeartbeatRequestHandler;
update
2023-07-08 09:58:20 +08:00
import com.jsowell.netty.handler.TransactionRecordsRequestHandler;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.netty.service.yunkuaichong.YKCBusinessService;
提供给lianlian获取token
2023-05-26 19:25:35 +08:00
import com.jsowell.pile.domain.*;
update 高德
2023-06-26 17:10:36 +08:00
import com.jsowell.pile.domain.ykcCommond.IssueQRCodeCommand;
import com.jsowell.pile.domain.ykcCommond.ProofreadTimeCommand;
add 联联平台相关工具类
2023-05-10 08:49:01 +08:00
import com.jsowell.pile.dto.*;
update 高德
2023-06-26 17:10:36 +08:00
import com.jsowell.pile.dto.amap.GetStationInfoDTO;
新增 路通云停平台 给车辆绑定优惠券接口
2023-08-24 10:33:26 +08:00
import com.jsowell.pile.dto.lutongyunting.BindCouponDTO;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.pile.mapper.MemberBasicInfoMapper;
import com.jsowell.pile.mapper.PileBillingTemplateMapper;
提供给lianlian获取token
2023-05-26 19:25:35 +08:00
import com.jsowell.pile.service.*;
改名
2023-12-07 11:01:45 +08:00
import com.jsowell.pile.service.programlogic.AbstractProgramLogic;
import com.jsowell.pile.service.programlogic.ProgramLogicFactory;
交易分账 重构
2023-08-29 16:03:43 +08:00
import com.jsowell.pile.transaction.dto.OrderTransactionDTO;
import com.jsowell.pile.transaction.service.TransactionService;
import com.jsowell.pile.util.SnUtils;
update 会员钱包
2023-11-21 14:57:58 +08:00
import com.jsowell.pile.vo.base.MemberWalletVO;
update
2023-06-26 14:40:03 +08:00
import com.jsowell.pile.vo.base.PileInfoVO;
update 卡启动、vin启动逻辑修改
2023-07-08 11:33:45 +08:00
import com.jsowell.pile.vo.uniapp.MemberVO;
新增 订单流程测试方法
2023-08-30 10:13:56 +08:00
import com.jsowell.pile.vo.uniapp.PileConnectorDetailVO;
计算余额扣除金额
2023-08-11 11:04:28 +08:00
import com.jsowell.pile.vo.web.BalanceDeductionAmountVO;
单元测试
2023-03-07 16:55:03 +08:00
import com.jsowell.pile.vo.web.BillingTemplateVO;
import com.jsowell.pile.vo.web.OrderListVO;
import com.jsowell.pile.vo.web.PileDetailVO;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.service.MemberService;
import com.jsowell.service.OrderService;
import com.jsowell.service.PileService;
update 校验支付单
2023-10-24 13:14:33 +08:00
import com.jsowell.service.TempService;
update 高德地图
2023-06-17 10:37:02 +08:00
import com.jsowell.thirdparty.amap.service.AMapService;
update 联联接口
2023-05-27 15:56:26 +08:00
import com.jsowell.thirdparty.lianlian.dto.CommonParamsDTO;
update lianlian
2023-05-26 16:14:45 +08:00
import com.jsowell.thirdparty.lianlian.service.LianLianService;
提供给lianlian获取token
2023-05-26 19:25:35 +08:00
import com.jsowell.thirdparty.lianlian.util.Cryptos;
import com.jsowell.thirdparty.lianlian.util.Encodes;
import com.jsowell.thirdparty.lianlian.util.GBSignUtils;
新增 路通云停系统获取令牌接口
2023-08-23 14:13:11 +08:00
import com.jsowell.thirdparty.lutongyunting.service.LTYTService;
commit
2023-03-04 16:29:55 +08:00
import com.jsowell.wxpay.common.WeChatPayParameter;
import com.jsowell.wxpay.dto.AppletTemplateMessageSendDTO;
import com.jsowell.wxpay.response.WechatPayRefundRequest;
import com.jsowell.wxpay.service.WxAppletRemoteService;
import org.apache.commons.collections4.CollectionUtils;
新增 微信第三方平台 获取令牌接口
2023-07-28 14:47:26 +08:00
import org.apache.commons.lang3.RandomStringUtils;
commit
2023-03-04 16:29:55 +08:00
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.StopWatch;
提供给lianlian获取token
2023-05-26 19:25:35 +08:00
import java.io.UnsupportedEncodingException;
commit
2023-03-04 16:29:55 +08:00
import java.math.BigDecimal;
update
2023-06-08 11:50:06 +08:00
import java.nio.charset.StandardCharsets;
commit
2023-03-04 16:29:55 +08:00
import java.text.ParseException;
import java.text.SimpleDateFormat;
add 联联平台相关工具类
2023-05-10 08:49:01 +08:00
import java.util.*;
update
2023-12-01 13:29:35 +08:00
import java.util.stream.Collectors;
commit
2023-03-04 16:29:55 +08:00
@ActiveProfiles("dev")
@SpringBootTest(classes = JsowellApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@RunWith(SpringRunner.class)
public class SpringBootTestController {
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
commit
2023-03-04 16:29:55 +08:00
update
2023-10-31 15:17:39 +08:00
String wechatAppId1 = "wxbb3e0d474569481d"; // 万车充
String wechatAppId2 = "wx20abc5210391649c"; // 嘉佳充电
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private SnUtils snUtils;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private PileService pileService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private YKCPushCommandService ykcPushCommandService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
汇付会员表加备注字段
2023-11-29 11:55:33 +08:00
private AdapayMemberAccountService adapayMemberAccountService;
update
2023-07-13 15:27:09 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IPileMsgRecordService pileMsgRecordService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IPileStationInfoService pileStationInfoService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private YKCPushCommandService ykcPushBusinessService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private HeartbeatRequestHandler heartbeatRequestHandler;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private YKCBusinessService ykcBusinessService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private PileBillingTemplateMapper pileBillingTemplateMapper;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private PileRemoteService pileRemoteService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private MemberService memberService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private OrderService orderService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IPileBillingTemplateService pileBillingTemplateService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private MemberBasicInfoMapper memberBasicInfoMapper;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private SimCardService simCardService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IPileBasicInfoService pileBasicInfoService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private WechatPayService wechatPayService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IOrderBasicInfoService orderBasicInfoService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private WxpayCallbackRecordService wxpayCallbackRecordService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private WxAppletRemoteService wxAppletRemoteService;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private RedisCache redisCache;
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
update
2023-12-01 13:29:35 +08:00
private PileAuthCardService pileAuthCardService;
update
2023-04-01 15:33:36 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private LianLianService lianLianService;
add 联联平台相关工具类
2023-05-10 08:49:01 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IMemberPlateNumberRelationService memberPlateNumberRelationService;
update 0x31报文回复不足位数补零
2023-06-12 17:38:16 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
static final String MAC_KEY = "53TtFpc4gdVZbF3x";
add 联联平台相关工具类
2023-05-10 08:49:01 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
static final String ALGORITHM_MAC = "HmacMD5";
add 联联平台相关工具类
2023-05-10 08:49:01 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private AdapayCallbackRecordService adapayCallbackRecordService;
update 汇付支付回调
2023-05-27 11:20:43 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IAdapayRefundRecordService adapayRefundRecordService;
保存汇付支付退款回调记录
2023-05-31 16:05:18 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private AdapayService adapayService;
update 汇付会员逻辑修改
2023-06-15 14:06:33 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private AMapService aMapService;
update 高德地图
2023-06-17 10:37:02 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IPileConnectorInfoService pileConnectorInfoService;
update
2023-07-08 15:37:53 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private TransactionRecordsRequestHandler transactionRecordsRequestHandler;
update
2023-07-08 09:58:20 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private IMemberBasicInfoService memberBasicInfoService;
update 卡启动、vin启动逻辑修改
2023-07-08 11:33:45 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private ClearingWithdrawInfoService clearingWithdrawInfoService;
update 保存提现信息
2023-08-01 16:16:34 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private OrderPileOccupyService orderPileOccupyService;
update 生成占桩订单
2023-08-08 08:43:50 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Autowired
private LTYTService ltytService;
@Autowired
private IPileMerchantInfoService pileMerchantInfoService;
@Autowired
private MemberAdapayRecordService memberAdapayRecordService;
@Autowired
private TransactionService transactionService;
@Autowired
private OrderPayRecordService orderPayRecordService;
update 校验支付单
2023-10-24 13:14:33 +08:00
@Autowired
private TempService tempService;
update 会员钱包
2023-11-21 14:57:58 +08:00
@Autowired
private MemberWalletInfoService memberWalletInfoService;
@Test
public void selectByMemberWalletListTest() {
String memberId = "12345678";
List<MemberWalletVO> memberWalletVOS = memberWalletInfoService.selectByMemberWalletList(memberId);
System.out.println(JSON.toJSONString(memberWalletVOS));
}
update 支付 占桩订单 后面拼上时间戳
2023-11-03 16:07:28 +08:00
@Test
public void queryPaymentByOrderNoTest() {
String orderNo = "C44903356969";
update校验未支付订单
2023-11-03 16:43:33 +08:00
String wechatAppId = "wxbb3e0d474569481d";
update 支付 占桩订单 后面拼上时间戳
2023-11-03 16:07:28 +08:00
try {
update校验未支付订单
2023-11-03 16:43:33 +08:00
List<AdaPayment> adaPayments = adapayService.queryPaymentByOrderNo(orderNo, wechatAppId);
update 支付 占桩订单 后面拼上时间戳
2023-11-03 16:07:28 +08:00
System.out.println(JSON.toJSONString(adaPayments));
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
}
update 校验支付单
2023-10-24 13:14:33 +08:00
@Test
public void checkPaymentTest() {
QueryOrderDTO dto = new QueryOrderDTO();
update
2023-10-26 16:54:50 +08:00
String startTime = "2023-09-01 00:00:00";
String endTime = "2023-09-30 23:59:59";
update 校验支付单
2023-10-24 14:49:49 +08:00
dto.setStartTime(startTime);
dto.setEndTime(endTime);
update 校验支付单
2023-10-24 13:14:33 +08:00
try {
tempService.checkPayment(dto);
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
}
update
2023-10-13 14:57:28 +08:00
@Test
public void toStringTest() {
String jsonString = "{\"business\":\"00\",\"communicationVersion\":\"v1.5\",\"connectorNum\":\"01\",\"iccid\":\"89860620180085681816\",\"internetConnection\":\"00\",\"pileSn\":\"88230000000259\",\"pileType\":\"01\",\"programVersion\":\"gyk-V29\\u0000\"}";
LoginRequestData loginRequestData = JSONObject.parseObject(jsonString, LoginRequestData.class);
System.out.println(loginRequestData.toString());
}
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
/**
* 单元测试，测试订单流程
*/
@Test
public void testTheOrderProcess() throws Exception {
// 生成订单
// OrderBasicInfo orderBasicInfo = generateAnOrder();
// System.out.println(orderBasicInfo);
// // 支付订单
// int a = payOrder(orderBasicInfo);
// System.out.println(a);
// 结算订单
OrderBasicInfo orderBasicInfo = orderBasicInfoService.getOrderInfoByOrderCode("C46006767636");
settleOrder(orderBasicInfo);
// 订单退款
BigDecimal payAmount = orderBasicInfo.getPayAmount();
BigDecimal settleAmount = orderBasicInfo.getSettleAmount();
BigDecimal refundAmt = payAmount.subtract(settleAmount);
// 延时分账的，可以部分解冻
memberAdapayRecordService.updateRefundAmountFromFreezeAmount("1234", refundAmt);
// 实时分账，全部解冻
// memberAdapayRecordService.unfreezeAmountAndUpdateSpendAmount("test01", payAmount, refundAmt);
}
// 生成订单
private OrderBasicInfo generateAnOrder() throws ParseException {
GenerateOrderDTO dto = new GenerateOrderDTO();
PileConnectorDetailVO vo = new PileConnectorDetailVO();
vo.setStationId("2");
dto.setPileConnector(vo);
dto.setMemberId("1");
dto.setStartMode("1");
dto.setPayMode("4");
dto.setPileSn("88000000000001");
dto.setConnectorCode("01");
dto.setChargeAmount(new BigDecimal("10"));
// 查询充电桩的计费模板
BillingTemplateVO billingTemplateVO = pileBillingTemplateService.selectBillingTemplateDetailByPileSn(dto.getPileSn());
dto.setBillingTemplate(billingTemplateVO);
OrderBasicInfo orderBasicInfo = orderBasicInfoService.saveOrder2Database(dto);
return orderBasicInfo;
}
// 支付订单
private int payOrder(OrderBasicInfo orderBasicInfo) throws Exception {
// PayOrderDTO dto = new PayOrderDTO();
// dto.setMemberId(orderBasicInfo.getMemberId());
// dto.setOrderCode(orderBasicInfo.getOrderCode());
// dto.setStartMode(orderBasicInfo.getStartMode());
// dto.setPayMode(orderBasicInfo.getPayMode());
// dto.setPayAmount(orderBasicInfo.getPayAmount());
//
// Map<String, Object> map = orderBasicInfoService.payOrder(dto);
// return map;
String paymentId = "1234";
BigDecimal amount = orderBasicInfo.getPayAmount();
String orderCode = orderBasicInfo.getOrderCode();
JSONObject json = new JSONObject();
json.put("paymentId", paymentId);
json.put("amount", amount);
// 记录订单支付流水
OrderPayRecord orderPayRecord = OrderPayRecord.builder()
.orderCode(orderCode)
.payMode(OrderPayRecordEnum.WECHATPAY_PAYMENT.getValue())
.payAmount(amount)
.acquirer(AcquirerEnum.ADAPAY.getValue())
.deductionRecord(json.toJSONString())
.createBy(null)
订单支付记录 给默认值
2023-08-31 10:30:05 +08:00
.delFlag(DelFlagEnum.NORMAL.getValue())
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
.build();
orderPayRecordService.batchInsert(Lists.newArrayList(orderPayRecord));
// 更新冻结金额 支付成功后全部冻结
memberAdapayRecordService.updateFreezeAmount(paymentId, amount);
// 支付订单成功
PayOrderSuccessCallbackDTO callbackDTO = PayOrderSuccessCallbackDTO.builder()
.orderCode(orderCode)
.payAmount(amount)
.payMode(OrderPayModeEnum.PAYMENT_OF_WECHATPAY.getValue())
.acquirer(AcquirerEnum.ADAPAY.getValue())
.build();
// 订单支付成功 支付回调
// orderBasicInfoService.payOrderSuccessCallback(callbackDTO);
OrderBasicInfo orderInfo = orderBasicInfoService.getOrderInfoByOrderCode(callbackDTO.getOrderCode());
// 修改订单
orderInfo.setPayMode(callbackDTO.getPayMode());
orderInfo.setPayStatus(Constants.ONE);
orderInfo.setPayAmount(callbackDTO.getPayAmount());
orderInfo.setPayTime(new Date());
orderInfo.setChargeStartTime(new Date());
orderInfo.setOrderStatus(OrderStatusEnum.IN_THE_CHARGING.getValue());
return orderBasicInfoService.updateOrderBasicInfo(orderInfo);
}
// 结算订单
private void settleOrder(OrderBasicInfo orderBasicInfo) {
TransactionRecordsData data = TransactionRecordsData.builder()
.transactionCode(orderBasicInfo.getTransactionCode())
.pileSn(orderBasicInfo.getPileSn())
.connectorCode(orderBasicInfo.getConnectorCode())
.startTime("2023-03-10 17:10:24")
.endTime("2023-03-10 17:10:46")
.sharpPrice("1.10000")
.sharpUsedElectricity("2.0000")
.sharpAmount("2.2000")
.peakPrice("1.20000")
.peakUsedElectricity("0")
.peakAmount("0")
.flatPrice("1.30000")
.flatUsedElectricity("0")
.flatAmount("0")
.valleyPrice("1.40000")
.valleyUsedElectricity("0")
.valleyAmount("0")
.totalElectricity("2")
.consumptionAmount("5.3000")
.vinCode("\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000\\u0000")
.transactionIdentifier("01")
.transactionTime("2023-03-10 17:10:46")
.stopReasonMsg("结束充电，APP远程停止")
.logicCard("0")
.createTime(new Date())
.build();
// orderBasicInfoService.settleOrder(data, orderBasicInfo);
// 获取更新数据后的orderBasicInfo对象
orderBasicInfoService.returnUpdateOrderBasicInfo(orderBasicInfo, data);
// 获取更新数据后的orderDetail对象/更新订单详情 查询订单详情 修改订单数据
OrderDetail orderDetail = orderBasicInfoService.returnUpdateOrderDetail(orderBasicInfo, data);
// 更新数据库
OrderTransactionDTO dto = new OrderTransactionDTO();
dto.setOrderBasicInfo(orderBasicInfo);
dto.setOrderDetail(orderDetail);
transactionService.doUpdateOrder(dto);
}
update 计算退款金额
2023-09-14 17:36:45 +08:00
public static List<BigDecimal> calculateRefund(BigDecimal totalAmount, List<BigDecimal> payments) {
List<BigDecimal> refundList = new ArrayList<>();
BigDecimal remainingAmount = totalAmount;
for (BigDecimal payment : payments) {
if (remainingAmount.compareTo(BigDecimal.ZERO) <= 0) {
// refundList.add(BigDecimal.ZERO);
refundList.add(payment);
} else {
BigDecimal refundPerPayment = remainingAmount.min(payment);
// refundList.add(refundPerPayment);
refundList.add(payment.subtract(refundPerPayment));
remainingAmount = remainingAmount.subtract(refundPerPayment);
}
}
return refundList;
}
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
update 计算退款金额
2023-09-14 17:36:45 +08:00
public static void main(String[] args) {
BigDecimal totalAmount = new BigDecimal("0.1");
List<BigDecimal> payments = Lists.newArrayList(new BigDecimal("0.97"), new BigDecimal("1.00"));
List<BigDecimal> refunds = calculateRefund(totalAmount, payments);
System.out.println("每笔单需要退还的金额: " + refunds);
}
/**
* 测试多笔支付情况，解冻部分金额
*/
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Test
public void calculateUnfreezeAmountTest() {
update 计算退款金额
2023-09-14 17:36:45 +08:00
BigDecimal orderAmount = new BigDecimal("0.06");
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
List<OrderPayRecord> payRecordList = Lists.newArrayList();
// 第一笔支付记录
JSONObject jsonObject = new JSONObject();
update 计算解冻金额逻辑
2023-08-31 18:35:16 +08:00
jsonObject.put("paymentId", "002212023083114213410543206907226374144");
update 计算退款金额
2023-09-14 17:36:45 +08:00
jsonObject.put("amount", "0.97");
JSONObject jsonObject2 = new JSONObject();
jsonObject2.put("paymentId", "002212023083114213410543206907226374144");
jsonObject2.put("amount", "1");
JSONArray jsonArray = new JSONArray();
jsonArray.add(jsonObject);
jsonArray.add(jsonObject2);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
OrderPayRecord build = OrderPayRecord.builder()
update 计算退款金额
2023-09-14 17:36:45 +08:00
.payAmount(new BigDecimal("1.97"))
.deductionRecord(jsonArray.toJSONString())
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
.build();
payRecordList.add(build);
改名
2023-12-07 11:01:45 +08:00
AbstractProgramLogic orderLogic = ProgramLogicFactory.getProgramLogic("1");
update 计算退款金额
2023-09-14 17:36:45 +08:00
List<Map<String, Object>> maps = orderLogic.calculateUnfreezeAmount(orderAmount, payRecordList);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
System.out.println(maps);
}
@Test
public void unfreezeAmountAndUpdateSpendAmountTest() {
String paymentId = "123";
memberAdapayRecordService.updateRefundAmount(paymentId, new BigDecimal("5"));
// memberAdapayRecordService.updateRefundAmountFromFreezeAmount(paymentId, new BigDecimal("20"));
// BigDecimal unfreezeAmount = new BigDecimal("32");
// BigDecimal spendAmount = new BigDecimal("10");
// memberAdapayRecordService.unfreezeAmountAndUpdateSpendAmount(paymentId, unfreezeAmount, spendAmount);
// memberAdapayRecordService.updateRefundAmountFromFreezeAmount(paymentId, new BigDecimal("2"));
}
@Test
public void getFirstLevelMerchantByMerchantIdTest() {
String merchantId = "13";
PileMerchantInfo merchantInfo = pileMerchantInfoService.getFirstLevelMerchantByMerchantId(merchantId);
System.out.println(JSON.toJSONString(merchantInfo));
}
@Test
public void queryPaymentInfoTest() throws BaseAdaPayException {
String paymentId = "002212023082514501110541039779091623936";
// 在完成初始化设置情况下，调用查询方法，获取 Payment 查询结果
update
2023-10-31 15:17:39 +08:00
Map<String, Object> response = Payment.query(paymentId, wechatAppId1);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
System.out.println(response);
}
/**
* 手动变更银行卡信息
*/
@Test
public void createSettleAccountRequestTest() throws BaseAdaPayException {
SettleAccountDTO dto = new SettleAccountDTO();
update
2023-09-05 08:42:05 +08:00
dto.setCardId("31050180460000002469");
dto.setCardName("上海擎昆物业管理有限公司");
update 后管订单详情页面中 实时订单数据添加字段
2023-08-31 10:29:17 +08:00
dto.setTelNo("18021373333");
update
2023-09-05 08:42:05 +08:00
dto.setBankCode("01050000");
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
dto.setBankAcctType("1");
update
2023-09-05 08:42:05 +08:00
dto.setProvCode("0031");
dto.setAreaCode("3100");
String adapayMemberId = "ACM80899105";
update
2023-10-31 15:17:39 +08:00
adapayService.createSettleAccountRequest(dto, adapayMemberId, wechatAppId1);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void createDeleteSettleAccountRequestTest() throws BaseAdaPayException {
String adapayMemberId = "ACM69424215";
String settleAccountId = "0498291998695360";
update
2023-10-31 15:17:39 +08:00
adapayService.createDeleteSettleAccountRequest(adapayMemberId, settleAccountId, wechatAppId1);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void queryDrawcashDetailTest() throws BaseAdaPayException {
String orderNo = "drawcash_1692339516947";
update
2023-10-31 15:17:39 +08:00
DrawCashDetailVO drawCashDetailVO = adapayService.queryDrawCashDetail(orderNo, wechatAppId1);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
System.out.println(drawCashDetailVO);
}
@Test
public void queryPaymentConfirmListTest() {
QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
update
2023-10-31 15:17:39 +08:00
dto.setWechatAppId(wechatAppId1);
update
2023-09-25 16:08:30 +08:00
// dto.setPaymentId("0022120230910032226990546664907296944128");
update 修改校验分账的方法
2023-10-11 17:01:23 +08:00
dto.setPaymentConfirmId("0022120231009032351990557174514064834560");
update
2023-09-25 16:08:30 +08:00
QueryPaymentConfirmDetailResponse.PaymentConfirmInfo paymentConfirmInfo = adapayService.queryPaymentConfirmDetail(dto);
System.out.println(JSON.toJSONString(paymentConfirmInfo));
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void queryAcctFlowListTest() {
QueryAcctFlowDTO dto = new QueryAcctFlowDTO();
try {
dto.setPageNo(1);
dto.setPageSize(100);
dto.setAcctType("01");
update
2023-10-31 15:17:39 +08:00
dto.setWechatAppId(wechatAppId1);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
dto.setAdapayMemberId("ACM69424215");
dto.setBeginDate("20230823");
dto.setEndDate("20230823");
adapayService.queryAcctFlowList(dto);
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
}
@Test
public void testCalculateTheBalanceDeductionAmount() {
String memberId = "123456";
BigDecimal amount = new BigDecimal("20");
List<BalanceDeductionAmountVO> resultList = Lists.newArrayList();
// 查询会员的余额充值记录 按照充值时间正序
List<MemberAdapayRecord> memberAdapayRecords = Lists.newArrayList();
memberAdapayRecords.add(MemberAdapayRecord.builder().paymentId("1").balanceAmt(new BigDecimal("50")).build());
memberAdapayRecords.add(MemberAdapayRecord.builder().paymentId("2").balanceAmt(new BigDecimal("60")).build());
memberAdapayRecords.add(MemberAdapayRecord.builder().paymentId("3").balanceAmt(new BigDecimal("10")).build());
// 定义一个临时金额等于消费金额
BigDecimal tempAmount = new BigDecimal(amount.toString());
for (MemberAdapayRecord memberAdapayRecord : memberAdapayRecords) {
// 该笔支付剩余金额 取出一笔判断是否剩余金额够支付订单消费吗
BigDecimal balanceAmt = memberAdapayRecord.getBalanceAmt();
// 该笔支付扣除金额
BigDecimal deductionAmount;
// 获取延时分账模式 延时分账的使用撤销方法退款，实时分账的使用退款方法
// AdapayCallbackRecord callbackRecord = adapayCallbackRecordService.selectByPaymentId(memberAdapayRecord.getPaymentId());
// String payMode = null;
// if (callbackRecord != null) {
// JSONObject expendJsonObject = JSON.parseObject(callbackRecord.getExpend());
// payMode = expendJsonObject.getString("payMode");
// }
// 消费金额 - 剩余金额
tempAmount = tempAmount.subtract(balanceAmt);
if (tempAmount.compareTo(BigDecimal.ZERO) >= 0) {
// 计算以后，大于等于0，说明这笔支付剩余金额需要扣完
deductionAmount = balanceAmt;
BalanceDeductionAmountVO build = BalanceDeductionAmountVO.builder()
.memberId(memberId)
.paymentId(memberAdapayRecord.getPaymentId())
.deductionAmount(deductionAmount)
.build();
resultList.add(build);
} else {
// 如果小于0，则说明剩余的钱用不完，扣除金额等于消费金额，并结束循环
deductionAmount = balanceAmt.add(tempAmount);
BalanceDeductionAmountVO build = BalanceDeductionAmountVO.builder()
.memberId(memberId)
.paymentId(memberAdapayRecord.getPaymentId())
.deductionAmount(deductionAmount)
.build();
resultList.add(build);
break;
}
}
System.out.println(JSON.toJSONString(resultList));
}
@Test
public void testGenerateOccupyPileOrder() {
String memberId = "67569684";
String pileSn = "88230000000135";
String connectorCode = "01";
GenerateOccupyOrderDTO dto = new GenerateOccupyOrderDTO();
dto.setMemberId(memberId);
dto.setPileSn(pileSn);
dto.setConnectorCode(connectorCode);
orderPileOccupyService.generateOccupyPileOrder(dto);
}
@Test
public void testStopOccupyPileOrder() {
String wechatAppId = "54135135";
AbstractAdapayConfig config = AdapayConfigFactory.getConfig(wechatAppId);
System.out.println(JSON.toJSONString(config));
update
2023-10-31 15:17:39 +08:00
AbstractAdapayConfig config2 = AdapayConfigFactory.getConfig(wechatAppId1);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
System.out.println(JSON.toJSONString(config2));
}
update 分账逻辑
2023-09-20 14:57:59 +08:00
/**
* 查询分账信息
* @throws BaseAdaPayException
*/
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
@Test
update
2023-09-11 16:43:26 +08:00
public void queryCreateConfirmReverse() throws BaseAdaPayException {
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
List<String> paymentIdList = getPaymentIdList(); // 查询分账信息
update
2023-09-28 09:16:44 +08:00
// 用于verify的汇付会员id
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
// String verifyAdapayMemberId = "AM27665969";
update
2023-09-11 16:43:26 +08:00
List<String> resultList = Lists.newArrayList();
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
// List<QueryPaymentConfirmDetailResponse.PaymentConfirmInfo> successList= Lists.newArrayList();
update
2023-09-06 14:30:06 +08:00
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
BigDecimal total = BigDecimal.ZERO;
Map<String, BigDecimal> map = Maps.newHashMap();
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
for (String paymentId : paymentIdList) {
if (StringUtils.isBlank(paymentId)) {
continue;
}
update
2023-09-06 14:30:06 +08:00
// 查询支付确认id
QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
dto.setPaymentId(paymentId);
update
2023-10-31 15:17:39 +08:00
dto.setWechatAppId(wechatAppId1);
update
2023-09-06 14:30:06 +08:00
QueryPaymentConfirmDetailResponse response = adapayService.queryPaymentConfirmList(dto);
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
// System.out.println("response==" + JSON.toJSONString(response));
update
2023-09-06 14:30:06 +08:00
if (response != null) {
List<QueryPaymentConfirmDetailResponse.PaymentConfirmInfo> confirms = response.getPaymentConfirms();
update
2023-09-08 14:26:13 +08:00
if (CollectionUtils.isEmpty(confirms)) {
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
resultList.add(paymentId);
update
2023-09-27 11:25:01 +08:00
} else {
update
2023-09-28 09:16:44 +08:00
for (QueryPaymentConfirmDetailResponse.PaymentConfirmInfo confirm : confirms) {
JSONObject jsonObject = JSON.parseObject(confirm.getDescription());
String adapayMemberId = jsonObject.getString("adapayMemberId");
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
BigDecimal confirmedAmt = new BigDecimal(confirm.getConfirmedAmt());
total = total.add(confirmedAmt);
// 校验是不是分给正确的商户
// System.out.println("分账账号：" + adapayMemberId);
// if (StringUtils.equals(adapayMemberId, verifyAdapayMemberId)) {
// successList.addAll(confirms);
// } else {
// resultList.add(s);
// }
// 放map
map.merge(adapayMemberId, confirmedAmt, BigDecimal::add);
update
2023-09-28 09:16:44 +08:00
}
update
2023-09-06 14:30:06 +08:00
}
}
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
update
2023-09-11 16:43:26 +08:00
System.out.println("=================未分账:" + JSON.toJSONString(resultList));
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
System.out.println("=================已分账:" + JSON.toJSONString(map) + ", 总分账:" + total);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
update
2023-10-27 16:37:04 +08:00
/**
* 测试分账
*/
update
2023-09-28 09:16:44 +08:00
@Test
public void test() {
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
String paymentId = "002212023102621451610563612286923030528";
update
2023-09-28 09:16:44 +08:00
AdapayMemberAccount adapayMemberAccount = new AdapayMemberAccount();
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
adapayMemberAccount.setAdapayMemberId("0");
BigDecimal deductionAmount = new BigDecimal("23.78");
String orderCode = "C23610900688";
update
2023-09-28 09:16:44 +08:00
// 延时分账，使用确认交易API
PaymentConfirmResponse paymentConfirmResponse = adapayService.createPaymentConfirmRequest(paymentId,
update
2023-10-31 15:17:39 +08:00
adapayMemberAccount, deductionAmount, orderCode, wechatAppId1);
update
2023-09-28 09:16:44 +08:00
System.out.println(JSON.toJSONString(paymentConfirmResponse));
}
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
/**
* 批量执行分账
*/
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
@Test
public void batchCreatePaymentConfirm() {
JSONArray paymentList = getPaymentList();
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
// TODO 获取默认结算账户，如需分给对应商户就填写正确的汇付会员id
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
AdapayMemberAccount adapayMemberAccount = adapayMemberAccountService.getDefault();
for (int i = 0; i < paymentList.size(); i++) {
JSONObject jsonObject = (JSONObject) paymentList.get(i);
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
BigDecimal confirmAmt = jsonObject.getBigDecimal("settleAmount"); // 确认金额就是结算金额
String paymentId = jsonObject.getString("paymentId"); // 支付id
String orderCode = jsonObject.getString("orderCode"); // 订单编号
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
// 延时分账，使用确认交易API
PaymentConfirmResponse paymentConfirmResponse = adapayService.createPaymentConfirmRequest(paymentId,
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
adapayMemberAccount, confirmAmt, orderCode, wechatAppId1);
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
}
}
// 需要重新分账的订单信息（针对未分账的订单）
public JSONArray getPaymentList() {
String jsonArrayString = "[" +
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
"{\"orderCode\":\"C40957699775\", \"settleAmount\":\"20.07\", \"paymentId\":\"002212023102608180610563409156395016192\"}" +
"{\"orderCode\":\"C40134359627\", \"settleAmount\":\"0.19\", \"paymentId\":\"002212023102613265510563486871366881280\"}" +
"{\"orderCode\":\"C29560601840\", \"settleAmount\":\"6.19\", \"paymentId\":\"002212023102812085110564192003156709376\"}" +
"{\"orderCode\":\"C21185002061\", \"settleAmount\":\"15.29\", \"paymentId\":\"002212023103121471210565424714177380352\"}" +
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
"]";
return JSONArray.parseArray(jsonArrayString);
}
update
2023-10-08 16:42:56 +08:00
/**
* 延迟分账未确认调撤销调撤销接口退款
*/
优化余额支付订单
2023-09-28 16:48:24 +08:00
@Test
public void createPaymentReverseRequestTest() {
update
2023-10-08 16:42:56 +08:00
String paymentId = "002212023082409392010540599165461884928";
BigDecimal refundAmount = new BigDecimal("0.09");
String memberId = null;
优化余额支付订单
2023-09-28 16:48:24 +08:00
// 延迟分账未确认调撤销调撤销接口退款
PaymentReverseOperation operation = new PaymentReverseOperation();
operation.setPaymentId(paymentId);
operation.setReverseAmt(refundAmount);
update
2023-10-31 15:17:39 +08:00
operation.setMerchantKey(wechatAppId2);
优化余额支付订单
2023-09-28 16:48:24 +08:00
operation.setMemberId(memberId);
operation.setScenarioType(ScenarioEnum.ORDER.getValue());
operation.setOrderCode(null);
PaymentReverseResponse response = adapayService.createPaymentReverseRequest(operation);
System.out.println(JSON.toJSONString(response));
}
update
2023-10-31 15:17:39 +08:00
/**
* 测试创建退款请求
*/
优化余额支付订单
2023-09-28 16:48:24 +08:00
@Test
public void createRefundRequestTest() {
update
2023-10-31 15:17:39 +08:00
String paymentId = "0022120231026150915990563512626531311616";
BigDecimal refundAmount = new BigDecimal("30.53");
String memberId = "65879222";
String orderCode = "C61028961274";
优化余额支付订单
2023-09-28 16:48:24 +08:00
// 调汇付的交易退款接口
RefundResponse response = adapayService.createRefundRequest(paymentId, refundAmount,
update
2023-10-31 15:17:39 +08:00
wechatAppId1, memberId, ScenarioEnum.ORDER.getValue(), orderCode);
优化余额支付订单
2023-09-28 16:48:24 +08:00
System.out.println(JSON.toJSONString(response));
}
update
2023-09-25 15:05:12 +08:00
/**
* 批量支付确认撤销
* @throws BaseAdaPayException
*/
update
2023-09-08 14:26:13 +08:00
@Test
update
2023-09-11 16:43:26 +08:00
public void testCreateConfirmReverse() throws BaseAdaPayException {
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
List<String> list = getPaymentIdList(); // 批量支付确认撤销
update
2023-10-31 15:17:39 +08:00
for (String paymentId : list) {
update
2023-09-08 14:26:13 +08:00
// 查询支付确认id
QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
update
2023-10-31 15:17:39 +08:00
dto.setPaymentId(paymentId);
dto.setWechatAppId(wechatAppId1);
update
2023-09-08 14:26:13 +08:00
QueryPaymentConfirmDetailResponse response = adapayService.queryPaymentConfirmList(dto);
if (response != null) {
List<QueryPaymentConfirmDetailResponse.PaymentConfirmInfo> confirms = response.getPaymentConfirms();
update
2023-10-31 15:17:39 +08:00
System.out.println("支付id:" + paymentId + ", 确认信息:" + JSON.toJSONString(confirms));
update 修改校验分账的方法
2023-10-11 17:01:23 +08:00
if (CollectionUtils.isNotEmpty(confirms)) {
for (QueryPaymentConfirmDetailResponse.PaymentConfirmInfo confirm : confirms) {
update
2023-10-31 15:17:39 +08:00
adapayService.createConfirmReverse(confirm.getId(), wechatAppId1);
update 修改校验分账的方法
2023-10-11 17:01:23 +08:00
}
}
update
2023-09-08 14:26:13 +08:00
}
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
update
2023-09-08 14:26:13 +08:00
}
update
2023-10-31 15:17:39 +08:00
/**
* 查询撤销列表
* @throws BaseAdaPayException
*/
@Test
public void queryPaymentReverseListTest() throws BaseAdaPayException {
JSONArray jsonList = getJsonList();
List<String> idList = Lists.newArrayList();
for (int i = 0; i < jsonList.size(); i++) {
JSONObject jsonObject = (JSONObject) jsonList.get(i);
// System.out.println(jsonObject.toJSONString());
BigDecimal refundAmount = jsonObject.getBigDecimal("refundAmount");
String paymentId = jsonObject.getString("paymentId");
update
2023-11-24 15:40:26 +08:00
adapayService.createPaymentReverseRequest(paymentId, refundAmount, wechatAppId1, "", ScenarioEnum.ORDER.getValue(), "");
update
2023-10-31 15:17:39 +08:00
}
System.out.println("需要撤销idList:" + idList);
}
public JSONArray getJsonList() {
update
2023-11-24 15:40:26 +08:00
String jsonArrayString = "[{\"refundAmount\":\"354.84\", \"paymentId\":\"002212023102509474610563069333816762368\"}]";
update
2023-10-31 15:17:39 +08:00
JSONArray jsonArray = JSONArray.parseArray(jsonArrayString);
return jsonArray;
}
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
public List<String> getPaymentIdList() {
update
2023-09-08 14:26:13 +08:00
List<String> list = Lists.newArrayList();
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
list.add("");
list.add("002212023080911513910535196643457490944");
list.add("002212023080917310510535282067647512576");
list.add("002212023080920233510535325478161035264");
list.add("002212023081014192310535596211322900480");
list.add("002212023081018421610535662367635296256");
list.add("002212023081019214010535672284102168576");
list.add("002212023081109372710535887647667904512");
list.add("002212023081121413210536069867639128064");
list.add("002212023081121564310536073688129978368");
list.add("002212023081210490210536268050325061632");
list.add("002212023081211435810536281872507260928");
list.add("002212023081212080910536287962106843136");
list.add("002212023081214515010536329151408025600");
list.add("002212023081218044810536377716367609856");
list.add("002212023081218535510536390074875957248");
list.add("002212023081219335410536400135797932032");
list.add("002212023081219390910536401457480249344");
list.add("002212023081220582410536421402983784448");
list.add("002212023081222104810536439622934351872");
list.add("002212023081222402610536447078682574848");
list.add("002212023081222442410536448077976109056");
list.add("002212023081300391510536476979343298560");
list.add("002212023081311123510536636362825416704");
list.add("002212023081318021310536739453994455040");
list.add("002212023081318345110536747662425870336");
list.add("002212023081320284510536776326702059520");
list.add("002212023081321173110536788601484410880");
list.add("002212023081321182410536788825176031232");
list.add("002212023081322345010536808056227643392");
list.add("002212023081322521310536812432816095232");
list.add("002212023081400063010536831127385722880");
list.add("002212023081408252910536956698702794752");
list.add("002212023081414495310537053436751183872");
list.add("002212023081417413510537096645896372224");
list.add("002212023081513031010537388967544909824");
list.add("002212023081515552410537432312858988544");
list.add("002212023081517180810537453132881428480");
list.add("002212023081520335810537502415345254400");
list.add("002212023081614042610537766773420998656");
list.add("002212023081615522710537793959720902656");
list.add("002212023081617341610537819581457383424");
list.add("002212023081619164910537845388505579520");
list.add("002212023081620160810537860315156299776");
list.add("002212023081623202010537906671250030592");
list.add("002212023081708302410538045099258040320");
list.add("002212023081713101610538115533954953216");
list.add("002212023081719463510538215268906479616");
list.add("002212023081719544110538217306568863744");
list.add("002212023081720324810538226898182942720");
list.add("002212023081721125110538236978358140928");
list.add("002212023081723134310538267393528758272");
list.add("002212023081723563110538278166862823424");
list.add("002212023081801290810538301472957952000");
list.add("002212023081801571410538308547201912832");
list.add("002212023081814401510538500563571302400");
list.add("002212023081814445010538501718643294208");
list.add("002212023081815575310538520102988144640");
list.add("002212023081818234110538556794644709376");
list.add("002212023081818540910538564459668590592");
list.add("002212023081823034410538627272334213120");
list.add("002212023081909361510538786448785969152");
list.add("");
list.add("002212023081910060410538793953300623360");
list.add("002212023081914414910538863347327717376");
list.add("002212023081914483310538865042690035712");
list.add("002212023081917162910538902270808576000");
list.add("002212023081921585210538973335899062272");
list.add("002212023081923332310538997121248022528");
list.add("002212023081923342110538997364304719872");
list.add("002212023082000004010539003987659247616");
list.add("002212023082001373010539028356149788672");
list.add("002212023082011300710539177493541588992");
list.add("002212023082016540910539259035753828352");
list.add("002212023082017095410539263001965514752");
list.add("002212023082017330610539268838730301440");
list.add("002212023082017545610539274332166238208");
list.add("002212023082020023510539306457748918272");
list.add("002212023082023031810539351935269900288");
list.add("002212023082023050310539352376170663936");
list.add("002212023082101473810539393293531463680");
list.add("002212023082112463110539559107157479424");
list.add("002212023082118120310539641030797856768");
list.add("002212023082121483910539695537059889152");
list.add("002212023082122263310539705078166159360");
list.add("002212023082123024210539714171989983232");
list.add("002212023082201301910539751323859603456");
list.add("002212023082208283110539856568383868928");
list.add("002212023082209445810539875807564320768");
list.add("002212023082212211510539915133888049152");
list.add("002212023082222485010540073070730919936");
list.add("002212023082223110410540078668262068224");
list.add("002212023082303251710540142642307284992");
list.add("002212023082310485210540254273614270464");
list.add("002212023082318185810540367545073479680");
list.add("002212023082320104610540395681495289856");
list.add("002212023082322321710540431295800131584");
list.add("002212023082323050110540439531292475392");
list.add("002212023082400202710540458514266640384");
list.add("002212023082407535410540572631681912832");
list.add("002212023082410263510540611054854549504");
list.add("002212023082415553510540693851089293312");
list.add("002212023082417255410540716578065797120");
list.add("002212023082419232110540746136356716544");
list.add("");
list.add("002212023082421511710540783365802733568");
list.add("002212023082422135610540789065768861696");
list.add("002212023082422222510540791200639168512");
list.add("002212023082501275310540837875738103808");
list.add("002212023082503132510540864431038025728");
list.add("002212023082508252410540942946259795968");
list.add("002212023082511184310540986562784280576");
list.add("");
list.add("002212023082517070610541074234499043328");
list.add("002212023082519312910541110573052739584");
list.add("002212023082519341910541111284830322688");
list.add("");
list.add("002212023082521180010541137375208747008");
list.add("002212023082521491510541145239486980096");
list.add("002212023082523595010541178105344286720");
list.add("002212023082607105610541286592551243776");
list.add("002212023082613400010541384506033324032");
list.add("002212023082615082910541406774347591680");
list.add("002212023082615180910541409206988607488");
list.add("002212023082618375910541459495911522304");
list.add("002212023082620292710541487547519488000");
list.add("");
list.add("002212023082621233410541501166566658048");
list.add("002212023082622582110541525018307883008");
list.add("002212023082623175210541529929854644224");
list.add("002212023082702085010541572954147409920");
list.add("002212023082707361210541655341507989504");
list.add("002212023082710153410541695444334665728");
list.add("002212023082711533210541720097936097280");
list.add("002212023082715195710541772044715704320");
list.add("002212023082716085010541784348720672768");
list.add("002212023082717350010541806032763240448");
list.add("002212023082717392610541807147967361024");
list.add("002212023082719092910541829808768462848");
list.add("002212023082720560310541856629967798272");
list.add("002212023082722104510541875429674397696");
list.add("002212023082807290510542015937137758208");
list.add("002212023082809432810542049753385185280");
list.add("002212023082815182010542134027438305280");
list.add("002212023082817031610542160436842647552");
list.add("002212023082817560110542173710710362112");
list.add("");
list.add("002212023082820190210542209703119843328");
list.add("");
list.add("002212023082909023810542401868354105344");
list.add("002212023082911163810542435589726388224");
list.add("002212023082911591510542446315247861760");
list.add("002212023082918223310542542776049119232");
list.add("002212023082920303510542574995091816448");
list.add("002212023082922384010542607228788793344");
list.add("002212023083011241810542799908620189696");
list.add("002212023083012503410542821616979169280");
list.add("002212023083014392510542849009854808064");
list.add("002212023083017544410542898163723177984");
list.add("002212023083019034910542915548445192192");
list.add("002212023083021044010542945959919026176");
list.add("002212023083022064410542961579917463552");
list.add("002212023083022123310542963045776936960");
list.add("002212023083112214210543176740885037056");
list.add("002212023083113225410543192143001071616");
list.add("002212023083118093510543264288814686208");
list.add("002212023083118583210543276606345605120");
list.add("002212023083119484410543289239890321408");
list.add("002212023083122144710543325992302137344");
list.add("002212023083122184310543326985915338752");
list.add("002212023090112434810543544691319656448");
list.add("002212023090119514510543652385933602816");
list.add("002212023090121124510543672771933622272");
list.add("002212023090121302510543677218274512896");
list.add("002212023090123232810543705665991143424");
list.add("002212023090123355710543708808341741568");
list.add("002212023090208394810543845673047273472");
list.add("002212023090213342710543919822878302208");
list.add("002212023090214333210543934693708627968");
list.add("002212023090214394610543936260781764608");
list.add("002212023090218405110543996930723139584");
list.add("002212023090219270410544008564594167808");
list.add("002212023090220295010544024358464737280");
list.add("002212023090223300210544069706587594752");
list.add("002212023090300355410544086282983026688");
list.add("002212023090301020510544092871901474816");
list.add("002212023090306565410544182164883103744");
list.add("002212023090313262810544280200422481920");
list.add("002212023090313531110544286925746663424");
list.add("002212023090315162910544307889622843392");
list.add("002212023090318081010544351094558584832");
list.add("002212023090321170210544398623752015872");
list.add("002212023090321251810544400704541392896");
list.add("002212023090322410810544419790387834880");
list.add("002212023090410302810544598299004755968");
list.add("002212023090419105310544729264036499456");
list.add("002212023090419283210544733708827889664");
list.add("002212023090421010310544756988227379200");
list.add("002212023090422322710544779992993230848");
list.add("002212023090500314110544809998093770752");
list.add("002212023090509562610544952122147966976");
list.add("002212023090518210410545079118518349824");
list.add("002212023090518255210545080324992032768");
list.add("002212023090519173010545093320424927232");
list.add("002212023090520263510545110703815909376");
list.add("002212023090521354610545128113298894848");
list.add("002212023090601062510545181125809139712");
list.add("002212023090619342310545459956702466048");
list.add("002212023090623322310545519849739636736");
list.add("002212023090708331910545655982339489792");
list.add("002212023090715360310545762366528544768");
list.add("002212023090719411510545824070909317120");
list.add("002212023090719574610545828226453831680");
list.add("002212023090722442310545870156928339968");
list.add("002212023090811334810546063786779631616");
list.add("002212023090813584110546100247382880256");
list.add("002212023090816465710546142595950948352");
list.add("002212023090818042210546162076081303552");
list.add("002212023090818060810546162521008877568");
list.add("002212023090819051510546177398738505728");
list.add("002212023090821415310546216817356042240");
list.add("002212023090822103010546224020578234368");
list.add("002212023090823592110546251410211364864");
list.add("002212023090914060010546464477812981760");
list.add("002212023090914350910546471815530369024");
list.add("002212023090919182210546543087612719104");
list.add("002212023090920035110546554532997750784");
list.add("002212023090920430610546564411142406144");
list.add("002212023090921593810546583674089222144");
list.add("002212023091000173510546618390597496832");
list.add("002212023091000292410546621361481158656");
list.add("002212023091008252610546741160548888576");
list.add("002212023091011435710546791119940734976");
list.add("002212023091013224810546815994008285184");
list.add("002212023091018053010546887138713763840");
list.add("002212023091018512110546898678474715136");
list.add("002212023091019081410546902924227534848");
list.add("002212023091020553210546929927187132416");
list.add("002212023091023052110546962599850438656");
list.add("002212023091100040710546977388099932160");
list.add("");
list.add("002212023091111520010547155530152923136");
list.add("002212023091113132710547176028927815680");
list.add("002212023091120512110547291265674534912");
list.add("002212023091122321210547316644195885056");
list.add("002212023091209261510547481241595011072");
list.add("002212023091213520210547548126692794368");
list.add("002212023091217492910547607884790108160");
list.add("002212023091217565710547609763706630144");
list.add("002212023091218202810547615682417152000");
list.add("002212023091218311610547618396642848768");
list.add("002212023091222073010547672817516367872");
list.add("002212023091317254910547964315248054272");
list.add("002212023091317512410547970755183476736");
list.add("");
list.add("");
list.add("002212023091319310610547995842010251264");
list.add("002212023091322085210548035549470253056");
list.add("002212023091322203510548038496812347393");
list.add("002212023091322582110548047999484809216");
list.add("002212023091408342910548192987720835072");
list.add("002212023091410084110548216695450054656");
list.add("");
list.add("002212023091412392610548254634511298560");
list.add("002212023091418014210548335733482033152");
list.add("002212023091419272310548357297851514880");
list.add("002212023091419311910548358288533114880");
list.add("002212023091421540310548394206287802368");
list.add("002212023091500321810548434033424281600");
list.add("002212023091503431310548482076360822784");
list.add("");
list.add("002212023091515212410548657781333807104");
list.add("002212023091519464510548724558899834880");
list.add("002212023091520282610548735050025897984");
list.add("002212023091522021010548758637003177984");
list.add("002212023091523101610548775776024129536");
list.add("002212023091523383010548782881905602560");
list.add("002212023091523414910548783713843433472");
list.add("002212023091612052410548970842227191808");
list.add("002212023091615530210549028129170698240");
list.add("002212023091616003610549030034239524864");
list.add("002212023091617571010549059369594810368");
list.add("002212023091619544510549088958869385216");
list.add("002212023091621065110549107103101169664");
list.add("002212023091622363110549129668955975680");
list.add("002212023091700214110549156135467347968");
list.add("002212023091701013710549166184109256704");
list.add("002212023091710431710549312567500058624");
list.add("002212023091711541410549330423276974080");
list.add("002212023091716444610549403536746483712");
list.add("002212023091719131610549440909122236416");
list.add("002212023091719272310549444458482675712");
list.add("002212023091801554910549542211845230592");
list.add("002212023091808253010549640280669601792");
list.add("002212023091808551810549647779947745280");
list.add("002212023091812232010549700132812128256");
list.add("002212023091817363410549778960795688960");
list.add("002212023091818553110549798827605569536");
list.add("002212023091819224810549805693209010176");
list.add("002212023091819513110549812922134376448");
list.add("002212023091819573910549814463578578944");
list.add("002212023091820551010549828938590310400");
list.add("002212023091821422110549840813230338048");
list.add("002212023091900154510549879418637012992");
list.add("002212023091901521310549903694903627776");
list.add("002212023091916535410550130611411464192");
list.add("002212023091917451610550143535847485440");
list.add("002212023091919224310550168060550025216");
list.add("002212023091920524610550190721550114816");
list.add("");
list.add("002212023091921214010550197994735742976");
list.add("");
list.add("002212023092004521510550311390219849728");
list.add("002212023092008282710550365799283191808");
list.add("002212023092014042810550450359211683840");
list.add("002212023092014461910550460891247591424");
list.add("002212023092018031910550510468632752128");
list.add("");
list.add("002212023092019143710550528409372635136");
list.add("002212023092019261610550531342513283072");
list.add("002212023092021275410550561952458964992");
list.add("002212023092100430310550611064920715264");
list.add("002212023092108545510550734844807106560");
list.add("002212023092118141710550875617280229376");
list.add("002212023092118463810550883758572118016");
list.add("002212023092119254310550893594188697600");
list.add("002212023092120053110550903606648369152");
list.add("002212023092120272910550909136260218880");
list.add("002212023092122074110550934351173419008");
list.add("002212023092122404610550942678009352192");
list.add("002212023092123320010550955571402366976");
list.add("002212023092123352710550956439504105472");
list.add("002212023092200121010550965680069484544");
list.add("002212023092208283210551090593928413184");
list.add("002212023092215003210551189246374301696");
list.add("002212023092219350610551258340256505856");
list.add("002212023092222365010551304075132514304");
list.add("002212023092222382010551304452976537600");
list.add("002212023092305383710551410221313445888");
list.add("002212023092309262210551467536752754688");
list.add("002212023092309490010551473233143517184");
list.add("002212023092313455910551532872081289216");
list.add("002212023092313491010551533674076696576");
list.add("002212023092314175810551540921847279616");
list.add("002212023092314202310551541528242192384");
list.add("002212023092317371210551591057743069184");
list.add("002212023092319233910551617847520952320");
list.add("002212023092319342810551620569230077952");
list.add("002212023092320033210551627885622669312");
list.add("002212023092320462610551638680597008384");
list.add("002212023092323585310551687111517847552");
list.add("002212023092409251710551829652152020992");
list.add("002212023092417150610551947886492483584");
list.add("002212023092419565910551988624923430912");
list.add("002212023092420505010552002177378910208");
list.add("002212023092421095710552006986343673856");
list.add("002212023092421244510552010712205565952");
list.add("002212023092421425110552015266918203392");
list.add("002212023092421470410552016328282583040");
list.add("002212023092422434510552030591926239232");
list.add("002212023092422583210552034312383963136");
list.add("002212023092423275610552041712312041472");
list.add("002212023092515243510552282462336561152");
list.add("002212023092515313110552284207140483072");
list.add("002212023092518270910552328403712724992");
list.add("002212023092519161910552340776229408768");
list.add("002212023092519265610552343450557644800");
list.add("002212023092520095510552354266103967744");
list.add("002212023092520205910552357049986134016");
list.add("002212023092521001110552366915611181056");
list.add("002212023092523283710552404271420321792");
list.add("002212023092600303810552419878409940992");
list.add("002212023092614321310552631671040634880");
list.add("002212023092617540110552682452564910080");
list.add("002212023092619190610552703867824816128");
list.add("002212023092619201310552704147078492160");
list.add("002212023092619363810552708280581914624");
list.add("002212023092619581110552713702302842880");
list.add("002212023092622502910552757063885815808");
list.add("002212023092623025510552760191074775040");
list.add("002212023092708254310552901825309736960");
list.add("002212023092713384110552980586671669248");
list.add("002212023092717205610553036517898690560");
list.add("002212023092718125510553049600159035392");
list.add("002212023092718244310553052568742707200");
list.add("002212023092719291810553068823284289536");
list.add("002212023092719303710553069153142956032");
list.add("002212023092719333210553069885942620160");
list.add("002212023092719453110553072903865192448");
list.add("002212023092720180110553081079443673088");
list.add("002212023092720565310553090862134845440");
list.add("002212023092721572410553106093716258816");
list.add("002212023092722550310553120600563302400");
list.add("002212023092723143810553125527868100608");
list.add("002212023092723261310553128443406364672");
list.add("002212023092801144810553155769987203072");
list.add("002212023092809151210553276665498382336");
list.add("002212023092811473310553315007963312128");
list.add("002212023092812262410553324784890396672");
list.add("002212023092812553010553332104573460480");
list.add("002212023092814054010553349765376729088");
list.add("002212023092814140010553351862544715776");
list.add("002212023092817494610553406161413464064");
list.add("002212023092818443810553419969748275200");
list.add("002212023092819411910553434231255552000");
list.add("002212023092820200210553443975454216192");
list.add("002212023092820243510553445121187360768");
list.add("002212023092821460610553465635214155776");
list.add("002212023092822275410553476153733259264");
list.add("002212023092910122510553653453927698432");
list.add("002212023092912075610553682521843007488");
list.add("002212023092912511410553693421067923456");
list.add("002212023092918473110553783080155590656");
list.add("002212023092920373010553810760989401088");
list.add("002212023092920461810553812974036840448");
list.add("002212023092921240210553822471448420352");
list.add("002212023092921350710553825260224098304");
list.add("002212023092922191210553836353901129728");
list.add("002212023093010003610554012866985242624");
list.add("002212023093011285610554035094668435456");
list.add("002212023093012180410554047461959884800");
list.add("002212023093014083710554075281010716672");
list.add("002212023093014273310554080045376417792");
list.add("002212023093017564610554132698471018496");
list.add("002212023093020184410554168424765763584");
list.add("002212023093020222710554169361968353280");
list.add("002212023093020324010554171932125151232");
list.add("002212023093021353310554187757297057792");
list.add("002212023100114253510554441939350159360");
list.add("002212023100119262810554517661048115200");
list.add("002212023100119480310554523092105461760");
list.add("002212023100122021610554556869197647872");
list.add("002212023100200102010554589098735280128");
list.add("002212023100213290610554790114475278336");
list.add("002212023100218214910554863777346580480");
list.add("002212023100218500810554870905529643008");
list.add("002212023100220273310554895419762253824");
list.add("002212023100221384910554913355479023616");
list.add("002212023100222320110554926741853822976");
list.add("002212023100300283610554956080917467136");
list.add("002212023100301012310554964330103398400");
list.add("002212023100307124110555057770778034176");
list.add("002212023100314551310555174175003324416");
list.add("002212023100317033510555206478790086656");
list.add("002212023100318014510555221115778871296");
list.add("002212023100320392310555260786772783104");
list.add("002212023100320454510555262389432832000");
list.add("002212023100321141910555269574813007872");
list.add("002212023100322074410555283017572544512");
list.add("002212023100416131010555556177041383424");
list.add("002212023100417494610555580486789459968");
list.add("002212023100418010910555583352852946944");
list.add("002212023100418183010555587717231456256");
list.add("002212023100419564410555612438180605952");
list.add("002212023100420312610555621173354041344");
list.add("002212023100420403210555623462286295040");
list.add("002212023100422275210555650472817176576");
list.add("002212023100423102510555661182287220736");
list.add("002212023100423564110555672825701826560");
list.add("002212023100501242010555694882350092288");
list.add("002212023100501364610555698012639952896");
list.add("002212023100503083710555721125188845568");
list.add("002212023100509404610555819814248751104");
list.add("002212023100516542410555928943692849152");
list.add("002212023100518065610555947194349105152");
list.add("002212023100518402410555955619308720128");
list.add("002212023100519344010555969273626316800");
list.add("002212023100521230610555996561374150656");
list.add("002212023100521380210556000322176004096");
list.add("002212023100523162510556025079673565184");
list.add("002212023100609593210556186924739145728");
list.add("002212023100611164310556206348808740864");
list.add("002212023100615160010556266565269446656");
list.add("002212023100619151810556326790101676032");
list.add("002212023100619195410556327948055662592");
list.add("002212023100620300210556345594808606720");
list.add("002212023100620544810556351829815558144");
list.add("002212023100621414010556363624968622080");
list.add("002212023100622062710556369860209627136");
list.add("002212023100622483010556380444048224256");
list.add("002212023100622560010556382331127377920");
list.add("002212023100711095610556567032020971520");
list.add("002212023100712301310556587235541512192");
list.add("002212023100712463210556591338484928512");
list.add("002212023100718034510556671168926167040");
list.add("002212023100718111310556673047957258240");
list.add("002212023100719480110556697410331742208");
list.add("002212023100720250310556706730193932288");
list.add("002212023100808142210556885234290491392");
list.add("002212023100811375910556936475817525248");
list.add("002212023100811572710556941375813181440");
list.add("002212023100811590910556941804788346880");
list.add("002212023100813245610556963393686056960");
list.add("002212023100819330610557056046136913920");
list.add("002212023100820155210557066806606594048");
list.add("002212023100821061010557079464059314176");
list.add("002212023100822145910557096783127232512");
list.add("002212023100900324710557131461140410368");
list.add("002212023100907191010557233731280265216");
list.add("002212023100912065910557306161524858880");
list.add("002212023100918044110557396181353230336");
list.add("002212023100918382210557404655983505408");
list.add("002212023100919110010557412872078233600");
list.add("002212023100919244610557416335073001472");
list.add("002212023101000425610557496403703476224");
list.add("002212023101011465810557663512088023040");
list.add("002212023101012472210557678715107913728");
list.add("002212023101017480210557754378634371072");
list.add("002212023101018255210557763900910592000");
list.add("002212023101019152410557776366243360768");
list.add("002212023101019410210557782817191985152");
list.add("002212023101021434510557813700237029376");
list.add("002212023101100373210557857434382794752");
list.add("002212023101108272610557975687732092928");
list.add("002212023101111570610558028450409119744");
list.add("002212023101112505610558042000307478528");
list.add("002212023101119585010558149682777006080");
list.add("002212023101121215010558170572419997696");
list.add("002212023101121251610558171434498875392");
list.add("002212023101122384710558189938027487232");
list.add("002212023101200050410558211650205249536");
list.add("002212023101210091610558363702566842368");
list.add("002212023101212035610558392561062076416");
list.add("002212023101212134110558395011154759680");
list.add("002212023101216273410558458903739191296");
list.add("002212023101218413710558492639633559553");
list.add("002212023101218425610558492970241146880");
list.add("002212023101219071510558499089093472256");
list.add("002212023101219241210558503356659511296");
list.add("002212023101220353210558521308199157760");
list.add("002212023101220370910558521712661725184");
list.add("002212023101220410010558522682131062784");
list.add("002212023101221065210558529193902075904");
list.add("002212023101222150310558546352338464768");
list.add("002212023101311001810558738932598665216");
list.add("002212023101311052610558740226832019456");
list.add("002212023101311273410558745794615410688");
list.add("002212023101312042310558755059869601792");
list.add("002212023101312332710558762376242315264");
list.add("002212023101318273110558851476751568896");
list.add("002212023101319222810558865306694443008");
list.add("002212023101320380710558884343988801536");
list.add("002212023101321442410558901025859694592");
list.add("002212023101323034110558920979742679040");
list.add("002212023101323340110558928610624258048");
list.add("002212023101407293410559048286125535232");
list.add("002212023101417305010559199602158956544");
list.add("002212023101418060810559208484152795136");
list.add("002212023101421064210559253925748461568");
list.add("002212023101421450010559263565766180864");
list.add("002212023101422020910559267881687920640");
list.add("002212023101422215810559272868472127488");
list.add("002212023101508151810559422187011264512");
list.add("002212023101513073410559495736522620928");
list.add("002212023101513432410559504754551717888");
list.add("002212023101516543210559552853703503872");
list.add("002212023101517122310559557346814050304");
list.add("002212023101517482910559566432291614720");
list.add("002212023101518245310559575591745126400");
list.add("002212023101519271910559591302607396864");
list.add("002212023101520390410559609360579289088");
list.add("002212023101520504410559612297791098880");
list.add("002212023101521383610559624341579808768");
list.add("002212023101522170610559634032237211648");
list.add("002212023101522213210559635147313901568");
list.add("002212023101612295110559848631017779200");
list.add("002212023101613214510559861693534433280");
list.add("002212023101619230910559952643444551680");
list.add("002212023101621122610559980146944876544");
list.add("002212023101621383310559986718452137984");
list.add("002212023101622280410559999178471858176");
list.add("002212023101708510710560155976448978944");
list.add("002212023101710570710560187682269425664");
list.add("002212023101715022910560249432054071296");
list.add("002212023101718223810560299800332578816");
list.add("002212023101718275810560301141868118016");
list.add("002212023101718532110560307532765589504");
list.add("002212023101719440810560320312033931264");
list.add("002212023101719592310560324151252537344");
list.add("002212023101723084210560371792201375744");
list.add("002212023101723254910560376099860492288");
list.add("002212023101816543910560640047767310336");
list.add("002212023101817524210560654655274008576");
list.add("002212023101818312210560664388969164800");
list.add("002212023101819220910560677164950597632");
list.add("002212023101820165910560690967020777472");
list.add("002212023101821021410560702353521946624");
list.add("002212023101821203910560706988523606016");
list.add("002212023101910355610560907127342419968");
list.add("002212023101911533410560926666733551616");
list.add("002212023101912181110560932860100784128");
list.add("002212023101913013610560943787393900544");
list.add("002212023101916265810560995467223814144");
list.add("002212023101918072710561020755994451968");
list.add("002212023101919253910561040436799320064");
list.add("002212023101919454310561045485660844032");
list.add("002212023101920103810561051754474352640");
list.add("002212023101921000110561064184713232384");
list.add("002212023101921093310561066581958512640");
list.add("002212023101922495210561091828216680448");
list.add("002212023102008391510561240149807235072");
list.add("002212023102009333110561253809033494528");
list.add("002212023102011054910561277037921935360");
list.add("002212023102012055610561292166526582784");
list.add("002212023102012421810561301315282972672");
list.add("002212023102014553810561334873740009472");
list.add("002212023102015015110561336437261471744");
list.add("002212023102016340010561359626789662720");
list.add("002212023102018040910561382315051753472");
list.add("002212023102019115610561399372634091520");
list.add("002212023102020042410561412573863854080");
list.add("002212023102020370610561420806089568256");
list.add("002212023102021311810561434443599532032");
list.add("002212023102021321410561434678351069184");
list.add("002212023102021352710561435489093255168");
list.add("002212023102022080510561443702187028480");
list.add("002212023102023353710561465731445248000");
list.add("002212023102023480010561468844252155904");
list.add("002212023102100060710561473403510833152");
list.add("002212023102101083010561489103002759168");
list.add("002212023102111203610561643146301169664");
list.add("002212023102117121410561731634686631936");
list.add("002212023102118341610561752278732197888");
list.add("002212023102118360910561752755216015360");
list.add("002212023102120354210561782839714553856");
list.add("002212023102121054110561790386479063040");
list.add("002212023102121142810561792597744377856");
list.add("002212023102122074510561806006637584384");
list.add("002212023102122155710561808066933121024");
list.add("002212023102123312710561827071071571968");
list.add("002212023102202532710561877902215946240");
list.add("002212023102208231410561960895780003840");
list.add("002212023102210384510561995000358854656");
list.add("002212023102212055710562016943573004288");
list.add("002212023102213522710562043746673188864");
list.add("002212023102214462610562057330864726016");
list.add("002212023102216433510562086812420108288");
list.add("002212023102216522510562089038907146240");
list.add("002212023102217232910562096853091393536");
list.add("002212023102217294810562098443547004928");
list.add("002212023102217533710562104440424718336");
list.add("002212023102218100010562108561133969408");
list.add("002212023102219565310562135460264767488");
list.add("002212023102220511310562149134773743616");
list.add("002212023102221080510562153376813375488");
list.add("002212023102221322510562159499507200000");
list.add("002212023102303053310562243337727811584");
list.add("002212023102303390210562251761414000640");
list.add("002212023102307183310562307007285784576");
list.add("002212023102307193910562307282546745344");
list.add("002212023102308344210562326169121943552");
list.add("002212023102315141910562426737777926144");
list.add("002212023102315374110562432617101357056");
list.add("002212023102315542310562436819639672832");
list.add("002212023102316213810562443678391427072");
list.add("002212023102316461310562449864675254272");
list.add("002212023102318303510562476127217209344");
list.add("002212023102318573610562482926969233408");
list.add("002212023102319145110562487271008280576");
list.add("002212023102319470610562495387185668096");
list.add("002212023102319492010562495947449913344");
list.add("002212023102320405110562508913278418944");
list.add("002212023102322403610562539048965545984");
list.add("002212023102400450310562570364825673728");
list.add("002212023102409405710562705229247700992");
list.add("002212023102412441010562751337890562048");
list.add("002212023102415443710562796748665217024");
list.add("002212023102415481710562797673014063104");
list.add("002212023102415505410562798331264835584");
list.add("002212023102417201310562820807944790016");
list.add("002212023102417325910562824021102120960");
list.add("002212023102418191510562835666448764929");
list.add("002212023102419120310562848950656679936");
list.add("002212023102419195910562850948275990528");
list.add("002212023102419382410562855584537477120");
list.add("002212023102420010410562861288643846144");
list.add("002212023102420085910562863279070334976");
list.add("002212023102510080910563074462491832320");
list.add("002212023102517561910563192280452210688");
list.add("002212023102518082610563195330078404608");
list.add("002212023102518254110563199672280895488");
list.add("002212023102520162510563227539958091776");
list.add("002212023102520255110563229911567286272");
list.add("002212023102523371410563278077378646016");
list.add("002212023102601302010563306536613404672");
list.add("002212023102602194710563318984417177600");
list.add("002212023102608180610563409156395016192");
list.add("002212023102613265510563486871366881280");
list.add("002212023102613322510563488256137854976");
list.add("002212023102616295410563532923360997376");
list.add("002212023102618391110563565458181672960");
list.add("002212023102618522110563568769208373248");
list.add("002212023102619054510563572144770469888");
list.add("002212023102619200310563575742674989056");
list.add("002212023102619521210563583833479544832");
list.add("002212023102620020810563586330613477376");
list.add("002212023102620032910563586672493154304");
list.add("002212023102620153810563589731264798720");
list.add("002212023102623084210563633281251713024");
list.add("002212023102711572810563826750882689024");
list.add("002212023102713463510563854208540229632");
list.add("002212023102717512210563915812600029184");
list.add("002212023102718400110563928054754013184");
list.add("002212023102719145210563936823944945664");
list.add("002212023102719562810563947292034166784");
list.add("002212023102720130010563951455614644224");
list.add("002212023102720144110563951876685758464");
list.add("002212023102720312210563956076110684160");
list.add("002212023102721485810563975605958995968");
list.add("002212023102810235110564165577829498880");
list.add("002212023102812085110564192003156709376");
list.add("002212023102812170010564194051846197248");
list.add("002212023102813041610564205949544308736");
list.add("002212023102817272310564272165108826112");
list.add("002212023102818203510564285552317534208");
list.add("002212023102820155010564314556956766208");
list.add("002212023102820221110564316151640211456");
list.add("002212023102820563610564324815379775488");
list.add("002212023102900090610564373260171063296");
list.add("002212023102900170610564375270669000704");
list.add("002212023102910565610564536289890672640");
list.add("002212023102911043610564538222314766336");
list.add("002212023102912275810564559200735043584");
list.add("002212023102912303010564559838773231616");
list.add("002212023102915311310564605317353828352");
list.add("002212023102916431610564623450534932480");
list.add("002212023102917400910564637765132943360");
list.add("002212023102919003710564658013999710208");
list.add("002212023102920292610564680365753495552");
list.add("002212023102920550210564686808114774016");
list.add("002212023102920584610564687748894552064");
list.add("002212023102921094410564690505861844992");
list.add("002212023102921224810564693797465792512");
list.add("002212023102921503910564700803289952256");
list.add("002212023102922203310564708330853900288");
list.add("002212023103007451710564850450655911936");
list.add("002212023103011362410564908612548804608");
list.add("002212023103011563410564913684975173632");
list.add("002212023103017250610564996363737985024");
list.add("002212023103018293610565012594998886400");
list.add("002212023103020005710565035587053535232");
list.add("002212023103021122810565053584670978048");
list.add("002212023103021134310565053899694514176");
list.add("002212023103021512010565063363888672768");
list.add("002212023103022505310565078350041718784");
list.add("002212023103100315510565103776369324032");
list.add("002212023103112204210565282146991194112");
list.add("002212023103114430610565317984637403136");
list.add("002212023103117303610565360138508935168");
list.add("002212023103118252010565373911944929280");
list.add("002212023103118372910565376968571219968");
list.add("002212023103119244410565388860175773696");
list.add("002212023103119471710565394533219409920");
list.add("002212023103120524910565411025250938880");
list.add("002212023103121471210565424714177380352");
update 查询分账情况工具
2023-12-13 16:48:07 +08:00
update
2023-09-08 14:26:13 +08:00
return list;
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void testClearingWithdraw() {
// 保存提现记录
ClearingWithdrawInfo record = new ClearingWithdrawInfo();
record.setWithdrawCode("132321354");
record.setWithdrawStatus(Constants.ZERO);
Date now = new Date();
record.setApplicationTime(now);
record.setCreateTime(now);
record.setDelFlag(DelFlagEnum.NORMAL.getValue());
clearingWithdrawInfoService.insertOrUpdate(record);
}
@Test
public void testGetPileTypeNum() {
Long stationId = 1L;
pileConnectorInfoService.getPileTypeNum(stationId);
}
@Test
public void testUpdateStatus() {
String pileConnectorCode = "8800000000012601";
String status = "0";
pileConnectorInfoService.updateConnectorStatus(pileConnectorCode, status);
}
@Test
public void testRedisSet() {
String redisKey = "push_station_connector";
redisCache.setCacheSet(redisKey, Sets.newHashSet("1"));
redisCache.setCacheSet(redisKey, Sets.newHashSet("3"));
redisCache.setCacheSet(redisKey, Sets.newHashSet("5"));
redisCache.setCacheSet(redisKey, Sets.newHashSet("1"));
redisCache.setCacheSet(redisKey, Sets.newHashSet("1"));
redisCache.setCacheSet(redisKey, Sets.newHashSet("7"));
redisCache.setCacheSet(redisKey, Sets.newHashSet("3"));
Set<Object> cacheSet = redisCache.getCacheSet(redisKey);
System.out.println(cacheSet);
}
@Test
public void testSettleOrder() {
Map<String, BigDecimal> returnAmountMap = Maps.newHashMap();
returnAmountMap.put("returnPrincipal", new BigDecimal("16.8700"));
// 更新会员钱包
BigDecimal returnPrincipal = returnAmountMap.get("returnPrincipal");
// if (returnPrincipal != null && principalPayRecord != null) {
// principalPayRecord.setRefundAmount(returnPrincipal);
// updatePayRecordList.add(principalPayRecord);
// }
BigDecimal returnGift = returnAmountMap.get("returnGift");
System.out.println(returnPrincipal);
// if (returnGift != null && giftPayRecord != null) {
// giftPayRecord.setRefundAmount(returnGift);
// updatePayRecordList.add(giftPayRecord);
// // 支付的赠送金额-退回的赠送金额 = 实际使用赠送金额消费的部分
// virtualAmount = giftPay.subtract(returnGift);
// }
// UpdateMemberBalanceDTO updateMemberBalanceDTO = UpdateMemberBalanceDTO.builder()
// .memberId(orderBasicInfo.getMemberId())
// .type(MemberWalletEnum.TYPE_IN.getValue()) // 进账
// .subType(MemberWalletEnum.SUBTYPE_ORDER_SETTLEMENT_REFUND.getValue()) // 订单结算退款
// .updatePrincipalBalance(returnPrincipal)
// .updateGiftBalance(returnGift)
// .relatedOrderCode(orderBasicInfo.getOrderCode())
// .build();
// memberBasicInfoService.updateMemberBalance(updateMemberBalanceDTO);
}
@Test
public void testVin() {
String vinCode = "tango";
MemberPlateNumberRelation memberPlateInfoByVinCode = memberPlateNumberRelationService.getMemberPlateInfoByVinCode(vinCode);
System.out.println(memberPlateInfoByVinCode);
}
@Test
public void testParking() throws UnsupportedEncodingException {
// GetTokenDTO dto = new GetTokenDTO();
// dto.setAppId("I2qa3hdr116100dc");
// dto.setSecretKey("2qa3hdr13754a8e");
// String token = ltytService.getToken(dto);
// System.out.println(token);
BindCouponDTO dto = new BindCouponDTO();
dto.setAppId("I2qa3hdr116100dc");
dto.setSecretKey("2qa3hdr13754a8e");
dto.setMerchantId("3prv98bm8db70a9");
dto.setCouponId("3prvd0q7a4817bf");
dto.setPlateNumber("贵A12345");
dto.setPlateColor(1);
String s = ltytService.bindCoupon(dto);
System.out.println(s);
}
@Test
public void testUpdateConnectorStatus() {
String pileConnectorCode = "8800000000000101";
String status = PileConnectorStatusEnum.FREE.getValue();
pileConnectorInfoService.updateConnectorStatus(pileConnectorCode, status);
}
@Test
public void testOrder() throws Exception {
// 通过vin码查询数据库绑定用户信息
MemberPlateNumberRelation plateInfo = memberPlateNumberRelationService.getMemberPlateInfoByVinCode("LNBSCC4H1LT107646");
GenerateOrderDTO dto = new GenerateOrderDTO();
dto.setMemberPlateNumberRelation(plateInfo);
dto.setPileSn("88000000000126");
dto.setConnectorCode("01");
dto.setStartMode(StartModeEnum.VIN_CODE.getValue());
dto.setMemberId(plateInfo.getMemberId());
// 通过memberId获取账户余额
MemberVO memberVO = memberBasicInfoService.queryMemberInfoByMemberId(dto.getMemberId());
if (memberVO == null) {
throw new BusinessException(ReturnCodeEnum.CODE_GET_MEMBER_ACCOUNT_AMOUNT_ERROR);
}
BigDecimal totalAccountAmount = memberVO.getTotalAccountAmount();
if (totalAccountAmount.compareTo(BigDecimal.ZERO) <= 0) {
throw new BusinessException(ReturnCodeEnum.CODE_BALANCE_IS_INSUFFICIENT);
}
dto.setChargeAmount(totalAccountAmount); // 充电金额
dto.setPayMode(OrderPayModeEnum.PAYMENT_OF_BALANCE.getValue()); // 1-余额支付
OrderBasicInfo basicInfo = orderBasicInfoService.generateOrder(dto);
// 支付订单
PayOrderDTO payOrderDTO = new PayOrderDTO();
payOrderDTO.setOrderCode(basicInfo.getOrderCode());
payOrderDTO.setPayAmount(totalAccountAmount);
payOrderDTO.setPayMode(dto.getPayMode());
payOrderDTO.setMemberId(dto.getMemberId());
// payOrderDTO.setCode();
// payOrderDTO.setLockValue();
// payOrderDTO.setOrderBasicInfo(basicInfo);
Map<String, Object> map = orderBasicInfoService.payOrder(payOrderDTO);
System.out.println(map);
}
@Test
public void testTransactionRecord() {
// 获取消息体
String msg = "8823000000123302230707215317078588230000001233020000341507071763023615070717b02a0200a00f0000000000003016000090dc010000000000000000000000000020c50100000000000000000000000000888a0100000000000000000000000000b0220749005032074900a00f000000000000e01500004c4e425343433448314c543130373634360563023615070717450000000000000000";
byte[] msgBody = BytesUtil.str2Bcd(msg);
int startIndex = 0;
int length = 16;
// 交易流水号
byte[] orderCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String transactionCode = BytesUtil.bcd2Str(orderCodeByteArr);
// 桩编码
startIndex += length;
length = 7;
byte[] pileSnByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String pileSn = BytesUtil.bcd2Str(pileSnByteArr);
// 枪号
startIndex += length;
length = 1;
byte[] connectorCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String connectorCode = BytesUtil.bcd2Str(connectorCodeByteArr);
// 开始时间 CP56Time2a 格式
startIndex += length;
length = 7;
byte[] startTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
// String binary = BytesUtil.binary(startTimeByteArr, 16);
Date startDate = Cp56Time2aUtil.byte2Hdate(startTimeByteArr);
String startTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, startDate);
// 结束时间 CP56Time2a 格式
startIndex += length;
byte[] endTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
Date endDate = Cp56Time2aUtil.byte2Hdate(endTimeByteArr);
String endTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, endDate);
// 尖单价 精确到小数点后五位（尖电费+尖服务费，见费率帧）
startIndex += length;
length = 4;
byte[] sharpPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String sharpPrice = YKCUtils.convertDecimalPoint(sharpPriceByteArr, 5);
// 尖电量 精确到小数点后四位
startIndex += length;
length = 4;
byte[] sharpUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String sharpUsedElectricity = YKCUtils.convertDecimalPoint(sharpUsedElectricityByteArr, 4);
// 计损尖电量
startIndex += length;
byte[] sharpPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String sharpPlanLossElectricity = YKCUtils.convertDecimalPoint(sharpPlanLossElectricityByteArr, 4);
// 尖金额
startIndex += length;
byte[] sharpAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String sharpAmount = YKCUtils.convertDecimalPoint(sharpAmountByteArr, 4);
// 峰单价 精确到小数点后五位（峰电费+峰服务费）
startIndex += length;
byte[] peakPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String peakPrice = YKCUtils.convertDecimalPoint(peakPriceByteArr, 5);
// 峰电量
startIndex += length;
byte[] peakUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String peakUsedElectricity = YKCUtils.convertDecimalPoint(peakUsedElectricityByteArr, 4);
// 计损峰电量
startIndex += length;
byte[] peakPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String peakPlanLossElectricity = YKCUtils.convertDecimalPoint(peakPlanLossElectricityByteArr, 4);
// 峰金额
startIndex += length;
byte[] peakAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String peakAmount = YKCUtils.convertDecimalPoint(peakAmountByteArr, 4);
// 平单价 精确到小数点后五位（平电费+平服务费）
startIndex += length;
byte[] flatPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String flatPrice = YKCUtils.convertDecimalPoint(flatPriceByteArr, 5);
// 平电量
startIndex += length;
byte[] flatUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String flatUsedElectricity = YKCUtils.convertDecimalPoint(flatUsedElectricityByteArr, 4);
// 计损平电量
startIndex += length;
byte[] flatPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String flatPlanLossElectricity = YKCUtils.convertDecimalPoint(flatPlanLossElectricityByteArr, 4);
// 平金额
startIndex += length;
byte[] flatAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String flatAmount = YKCUtils.convertDecimalPoint(flatAmountByteArr, 4);
// 谷单价 精确到小数点后五位（谷电费+谷 服务费）
startIndex += length;
byte[] valleyPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String valleyPrice = YKCUtils.convertDecimalPoint(valleyPriceByteArr, 5);
// 谷电量
startIndex += length;
byte[] valleyUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String valleyUsedElectricity = YKCUtils.convertDecimalPoint(valleyUsedElectricityByteArr, 4);
// 计损谷电量
startIndex += length;
byte[] valleyPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String valleyPlanLossElectricity = YKCUtils.convertDecimalPoint(valleyPlanLossElectricityByteArr, 4);
// 谷金额
startIndex += length;
byte[] valleyAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String valleyAmount = YKCUtils.convertDecimalPoint(valleyAmountByteArr, 4);
// 电表总起值
startIndex += length;
length = 5;
byte[] ammeterTotalStartByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String ammeterTotalStart = YKCUtils.convertDecimalPoint(ammeterTotalStartByteArr, 4);
// 电表总止值
startIndex += length;
byte[] ammeterTotalEndByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String ammeterTotalEnd = YKCUtils.convertDecimalPoint(ammeterTotalEndByteArr, 4);
// 总电量
startIndex += length;
length = 4;
byte[] totalElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String totalElectricity = YKCUtils.convertDecimalPoint(totalElectricityByteArr, 4);
// 计损总电量
startIndex += length;
byte[] planLossTotalElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String planLossTotalElectricity = YKCUtils.convertDecimalPoint(planLossTotalElectricityByteArr, 4);
// 消费金额 精确到小数点后四位，包含电费、 服务费
startIndex += length;
byte[] consumptionAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String consumptionAmount = YKCUtils.convertDecimalPoint(consumptionAmountByteArr, 4);
// VIN 码 VIN 码，此处 VIN 码和充电时 VIN 码不同， 正序直接上传， 无需补 0 和反序
startIndex += length;
length = 17;
byte[] vinCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String vinCode = BytesUtil.ascii2Str(vinCodeByteArr);
/**
* 交易标识
* 0x01： app 启动
* 0x02：卡启动
* 0x04：离线卡启动
* 0x05: vin 码启动充电
*/
startIndex += length;
length = 1;
byte[] transactionIdentifierByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String transactionIdentifier = BytesUtil.bcd2Str(transactionIdentifierByteArr);
// 交易时间 CP56Time2a 格式
startIndex += length;
length = 7;
byte[] transactionTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
Date transactionDate = Cp56Time2aUtil.byte2Hdate(transactionTimeByteArr);
String transactionTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, transactionDate);
// 停止原因
startIndex += length;
length = 1;
byte[] stopReasonByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String stopReason = BytesUtil.bin2HexStr(stopReasonByteArr);
String stopReasonMsg = YKCChargingStopReasonEnum.getMsgByCode(Integer.parseInt(stopReason, 16));
// 物理卡号 不足 8 位补 0
startIndex += length;
length = 8;
byte[] cardNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
// byte[] logicCardNum = BytesUtil.checkLengthAndBehindAppendZero(cardNumByteArr, 16);
String logicCard = BytesUtil.binary(cardNumByteArr, 16);
// log.info("桩号:{}发送交易记录物理卡号:{}", pileSn, logicCard);
//
// log.info("[===交易记录===]交易流水号:{}, 桩编号:{}, 枪号:{}, 开始时间:{}, 结束时间:{}, 尖单价:{}, 尖电量:{}, 计损尖电量:{}, 尖金额:{}, " +
// "峰单价:{}, 峰电量:{}, 计损峰电量:{}, 峰金额:{}, 平单价:{}, 平电量:{}, 计损平电量:{}, 平金额:{}, " +
// "谷单价:{}, 谷电量:{}, 计损谷电量:{}, 谷金额:{}, 电表总起值:{}, 电表总止值:{}, 总电量:{}, 计损总电量:{}, 消费金额:{}, " +
// "电动汽车唯一标识:{}, 交易标识:{}, 交易日期、时间:{}, 停止原因码:{}, 停止原因描述:{}, 物理卡号:{}",
// transactionCode, pileSn, connectorCode, startTime, endTime, sharpPrice, sharpUsedElectricity, sharpPlanLossElectricity, sharpAmount,
// peakPrice, peakUsedElectricity, peakPlanLossElectricity, peakAmount, flatPrice, flatUsedElectricity, flatPlanLossElectricity, flatAmount,
// valleyPrice, valleyUsedElectricity, valleyPlanLossElectricity, valleyAmount, ammeterTotalStart, ammeterTotalEnd, totalElectricity, planLossTotalElectricity,
// consumptionAmount, vinCode, transactionIdentifier, transactionTime, stopReason, stopReasonMsg, logicCard);
// 交易记录封装到对象里
TransactionRecordsData data = TransactionRecordsData.builder()
// .orderCode(transactionCode)
.transactionCode(transactionCode)
.pileSn(pileSn)
.connectorCode(connectorCode)
.startTime(startTime)
.endTime(endTime)
.sharpPrice(sharpPrice)
.sharpUsedElectricity(sharpUsedElectricity)
.sharpPlanLossElectricity(sharpPlanLossElectricity)
.sharpAmount(sharpAmount)
.peakPrice(peakPrice)
.peakUsedElectricity(peakUsedElectricity)
.peakPlanLossElectricity(peakPlanLossElectricity)
.peakAmount(peakAmount)
.flatPrice(flatPrice)
.flatUsedElectricity(flatUsedElectricity)
.flatPlanLossElectricity(flatPlanLossElectricity)
.flatAmount(flatAmount)
.valleyPrice(valleyPrice)
.valleyUsedElectricity(valleyUsedElectricity)
.valleyPlanLossElectricity(valleyPlanLossElectricity)
.valleyAmount(valleyAmount)
.ammeterTotalStart(ammeterTotalStart)
.ammeterTotalEnd(ammeterTotalEnd)
.totalElectricity(totalElectricity)
.planLossTotalElectricity(planLossTotalElectricity)
.consumptionAmount(consumptionAmount)
.vinCode(vinCode)
.transactionIdentifier(transactionIdentifier)
.transactionTime(transactionTime)
.stopReasonMsg(stopReasonMsg)
.logicCard(logicCard)
.build();
// boolean flag = !StringUtils.equals("0000000000000000", "a511101970000000");
// System.out.println(flag);
// 处理订单加锁
String lockKey = "settle_order_" + transactionCode;
String uuid = IdUtils.fastUUID();
try {
// redis锁
Boolean isLock = redisCache.lock(lockKey, uuid, 1500);
if (isLock) {
// transactionRecordsRequestHandler.processOrder(data);
}
} catch (Exception e) {
System.out.println("处理订单发生异常: " + e);
} finally {
if (uuid.equals(redisCache.getCacheObject(lockKey).toString())) {
redisCache.unLock(lockKey);
}
}
}
@Test
public void testFault() {
StringBuffer sb = new StringBuffer("0100");
String lowOrder = sb.substring(0, 2);
String highOrder = sb.substring(2, 4);
// String hardwareFault = highOrder + lowOrder;
byte[] hardwareFaultByteArr = BytesUtil.str2Bcd(highOrder + lowOrder);
String binStr = BytesUtil.bytes2BinStr(hardwareFaultByteArr);
// log.info("binStr:{}", binStr); // 0000 0000 0000 0001
int faultCode = 0;
for (int i = 0; i < binStr.length(); i++) {
if (binStr.charAt(i) == '1') {
faultCode = 15 - i;
break;
}
}
String faultReason = YKCPileFaultReasonEnum.getValueByCode(faultCode);
System.out.println(faultReason);
}
@Test
public void testQueryCorpMember() {
List<AdapayMemberAccount> accountList = adapayMemberAccountService.selectAdapayMemberAccountList(new AdapayMemberAccount());
if (CollectionUtils.isNotEmpty(accountList)) {
update
2023-12-01 13:29:35 +08:00
List<String> ids = accountList.stream().map(x -> x.getId() + "").collect(Collectors.toList());
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
adapayMemberAccountService.deleteAdapayMemberAccountByIds(ids);
}
// try {
// Map<String, Object> map = adapayMemberService.selectAdapayMember("5");
//
// String adapayMemberId = "ACM29562569";
// AdapayCorpMemberVO adapayCorpMemberVO = adapayMemberService.queryCorpAdapayMemberInfo(adapayMemberId);
// System.out.println(adapayCorpMemberVO);
//
//
// } catch (BaseAdaPayException e) {
// throw new RuntimeException(e);
// }
}
@Test
public void testGetPileListByStationIdList() {
// List<String> stationIdList = Lists.newArrayList("2");
// Map<String, List<AMapEquipmentInfo>> pileListByStationIdList = aMapService.getPileListByStationIdList(stationIdList);
// System.out.println(pileListByStationIdList);
GetStationInfoDTO dto = new GetStationInfoDTO();
dto.setType("page");
aMapService.getStationInfosV2(dto);
}
@Test
public void testMultiSave() {
String prefix = "test_multi_save:";
Map<String, Object> redisMap = Maps.newHashMap();
for (int i = 0; i < 1000; i++) {
redisMap.put(prefix + i, PileInfoVO.builder().pileSn(i + "").build());
}
redisCache.multiSave(redisMap, 60);
}
@Test
public void testBillingTemplate() {
pileBillingTemplateService.queryStationBillingTemplateListForUniApp("2");
}
@Test
public void testQueryAdapayMemberInfo() {
String adapayMemberId = "AM25703321";
String settleAccountId = "0489089447022976";
try {
// adapayMemberService.queryAdapayMemberInfo(adapayMemberId);
adapayService.queryAdapaySettleAccount(adapayMemberId, settleAccountId, "");
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
}
@Test
public void testSaveAdapayCallbackRecord() throws JsonProcessingException {
String data = "{\n" +
" \"object\": \"refund\",\n" +
" \"status\": \"succeeded\",\n" +
" \"prod_mode\": \"true\",\n" +
" \"id\": \"0022120230531111946980509821471137853440\",\n" +
" \"refund_order_no\": \"823725974557265920\",\n" +
" \"payment_id\": \"002212023053110524210509814658135928832\",\n" +
" \"payment_order_no\": \"C27262970851\",\n" +
" \"refund_amt\": \"7.82\",\n" +
" \"fee_amt\": \"0.04\",\n" +
" \"channel_no\": \"2023053121R064uj\",\n" +
" \"created_time\": \"1685503187000\",\n" +
" \"succeed_time\": \"1685503199000\",\n" +
" \"app_id\": \"app_d0c80cb1-ffc8-48cb-a030-fe9bec823aaa\",\n" +
" \"reason\": \"\",\n" +
" \"notify_url\": \"https://api.jsowellcloud.com/uniapp/pay/adapayRefundCallback\"\n" +
"}";
JSONObject jsonObject = JSON.parseObject(data);
ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
AdapayRefundRecord adapayRefundRecord = mapper.readValue(jsonObject.toJSONString(), AdapayRefundRecord.class);
adapayRefundRecord.setRefundId(jsonObject.getString("id"));
// 保存到数据库
adapayRefundRecordService.insertAdapayRefundRecord(adapayRefundRecord);
}
@Test
public void testQueryCallback() {
AdapayCallbackRecord aaaa = adapayCallbackRecordService.selectByOrderCode("aaaa");
System.out.println(aaaa);
}
@Test
public void testAdapayRefund() {
// 创建汇付退款对象 在完成初始化设置情况下，调用方法，获取 Refund对象
try {
String id = "002212023052710075810508353847861903360";
String refundAmount = "0.01";
Map<String, Object> refundParams = Maps.newHashMap();
refundParams.put("refund_amt", AdapayUtil.formatAmount(refundAmount));
refundParams.put("refund_order_no", SnowflakeIdWorker.getSnowflakeId());
refundParams.put("notify_url", "https://api.jsowellcloud.com/uniapp/pay/adapayRefundCallback");
Map<String, Object> response = Refund.create(id, refundParams);
System.out.println(JSON.toJSONString(response));
// if (response != null && !response.isEmpty()) {
// JSONObject jsonObject = JSONObject.parseObject(response.get("expend").toString());
// JSONObject pay_info = jsonObject.getJSONObject("pay_info");
// Map<String, Object> resultMap = JSONObject.parseObject(pay_info.toJSONString(), new TypeReference<Map<String, Object>>() {});
// }
} catch (Exception e) {
System.out.println(e);
}
}
@Test
public void testSaveCallback() throws JsonProcessingException {
update
2023-10-26 16:54:50 +08:00
String data = "{\"app_id2\":\"app_d0c80cb1-ffc8-48cb-a030-fe9bec823aaa\",\"created_time\":\"20230530132956\",\"description\":\"{\\\"orderCode\\\":\\\"C29505932783\\\",\\\"type\\\":\\\"order\\\"}\",\"end_time\":\"20230530133027\",\"expend\":{\"bank_type\":\"OTHERS\",\"open_id\":\"o8jhot6PJF93EPhNISsXi28dKdS8\",\"sub_open_id\":\"o4REX5MprZfTaLnVNxfdOY-wnwGI\"},\"fee_amt\":\"0.11\",\"id\":\"002212023053013295610509491838664794112\",\"order_no\":\"C29505932783\",\"out_trans_id\":\"4200001855202305308670391485\",\"party_order_id\":\"02212305304859640306711\",\"pay_amt\":\"20.00\",\"pay_channel\":\"wx_lite\",\"real_amt\":\"20.00\",\"share_eq\":\"Y\",\"status\":\"succeeded\",\"wx_user_id\":\"\"}";
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
JSONObject jsonObject = JSON.parseObject(data);
ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
update
2023-10-26 16:54:50 +08:00
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
AdapayCallbackRecord adapayCallbackRecord = mapper.readValue(jsonObject.toJSONString(), AdapayCallbackRecord.class);
adapayCallbackRecord.setExpend(jsonObject.getString("expend"));
adapayCallbackRecord.setPaymentId(jsonObject.getString("id"));
update
2023-10-26 16:54:50 +08:00
// adapayCallbackRecordService.saveAdapayCallbackRecord(adapayCallbackRecord);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void testAMap() throws Exception {
String pileConnectorCode = "8800000000012601";
// String s = aMapService.pushChargingDeviceDynamics(pileConnectorCode);
GetStationInfoDTO dto = new GetStationInfoDTO();
dto.setType("page");
aMapService.getStationInfos(dto);
}
@Test
public void testVinCode() {
String msg = "880000000000210203000000000000000000000000000000000000000000000000004C5257594743454B584D43303437313434";
// 获取消息体
byte[] msgBody = BytesUtil.str2Bcd(msg);
int startIndex = 0;
int length = 7;
// 桩编码
byte[] pileSnByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String pileSn = BytesUtil.binary(pileSnByteArr, 16);
// 保存时间
update 校验channel
2023-11-24 11:30:53 +08:00
// saveLastTime(pileSn, channel);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
// 枪号
startIndex += length;
length = 1;
byte[] connectorNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String connectorCode = BytesUtil.bcd2Str(connectorNumByteArr);
// 启动方式
// 0x01 表示通过刷卡启动充电
// 0x02 表求通过帐号启动充电 （暂不支持）
// 0x03 表示vin码启动充电
startIndex += length;
byte[] startModeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String startMode = BytesUtil.bcd2Str(startModeByteArr);
// 是否需要密码 0x00 不需要 0x01 需要
startIndex += length;
byte[] needPasswordFlagByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String needPasswordFlag = BytesUtil.bcd2Str(needPasswordFlagByteArr);
// 物理卡号 不足 8 位补 0
startIndex += length;
length = 8;
byte[] cardNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String physicsCard = BytesUtil.binary(cardNumByteArr, 16);
// 输入密码 对用户输入的密码进行16 位MD5 加密，采用小写上传
startIndex += length;
length = 16;
byte[] inputPasswordByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
// VIN码
startIndex += length;
length = 17;
byte[] vinCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String vinCode = BytesUtil.ascii2Str(vinCodeByteArr);
System.out.println("桩号:" + pileSn + "申请充电VIN码:" + vinCode);
/**
* 刷卡启动充电
*/
String logicCard = "";
byte[] authenticationFlagByteArr = Constants.zeroByteArray; // 鉴权成功标识
byte[] accountBalanceByteArr = Constants.zeroByteArray; // 账户余额
String transactionCode = "";
try {
/**
* VIN码启动充电
*/
if (StringUtils.equals("03", startMode)) {
// 通过vin码查询数据库绑定用户信息
MemberPlateNumberRelation plateInfo = memberPlateNumberRelationService.getMemberPlateInfoByVinCode(vinCode);
if (plateInfo == null) {
throw new BusinessException("", "未查到绑定用户信息");
}
if (!StringUtils.equals("1", plateInfo.getVinStatus())) {
// 1- 正常使用
throw new BusinessException("", "vin状态不正确");
}
// vin码生成订单 vin启动充电
GenerateOrderDTO dto = new GenerateOrderDTO();
dto.setMemberPlateNumberRelation(plateInfo);
dto.setPileSn(pileSn);
dto.setConnectorCode(connectorCode);
dto.setStartMode(StartModeEnum.VIN_CODE.getValue());
Map<String, Object> map = orderBasicInfoService.generateOrderByCard(dto);
if (map != null) {
transactionCode = (String) map.get("transactionCode");
accountBalanceByteArr = YKCUtils.getPriceByte(String.valueOf(map.get("accountBalance")), 2);
// 鉴权成功标识 0x00 失败 0x01 成功
authenticationFlagByteArr = Constants.oneByteArray;
} else {
throw new BusinessException("", "生成vin订单失败");
}
}
} catch (BusinessException e) {
e.printStackTrace();
System.out.println("1");
// log.error("VIN码启动充电鉴权 error:{}, {}", e.getCode(), e.getMessage());
} catch (Exception e) {
e.printStackTrace();
System.out.println("2");
transactionCode = "00000000000000000000000000000000";
accountBalanceByteArr = BytesUtil.checkLengthAndBehindAppendZero(accountBalanceByteArr, 8);
authenticationFlagByteArr = Constants.zeroByteArray;
// log.error("VIN码启动充电鉴权 error", e);
}
byte[] serialNumByteArr = BytesUtil.str2Bcd(transactionCode);
byte[] defeatReasonByteArr = Constants.zeroByteArray;
// 不足位数的值补零
// cardNumByteArr = BytesUtil.checkLengthAndBehindAppendZero(cardNumByteArr, 16);
// serialNumByteArr = BytesUtil.checkLengthAndBehindAppendZero(serialNumByteArr, 32);
// pileSnByteArr = BytesUtil.checkLengthAndBehindAppendZero(pileSnByteArr, 14);
// accountBalanceByteArr = BytesUtil.checkLengthAndBehindAppendZero(accountBalanceByteArr, 8);
// 拼装消息体
byte[] msgBodyByteArr = Bytes.concat(serialNumByteArr, pileSnByteArr, connectorNumByteArr, cardNumByteArr, accountBalanceByteArr,
authenticationFlagByteArr, defeatReasonByteArr);
String s = BytesUtil.bin2HexStr(msgBodyByteArr);
System.out.println(s);
}
@Test
public void testGenerateLianlianToken() throws UnsupportedEncodingException {
String OperatorID = "425010765";
String OperatorSecret = "123123123123aaaa"; // 1234567890abcdef
//请求dataX
Map<String, String> data = new HashMap<>();
data.put("OperatorID", OperatorID);
data.put("OperatorSecret", OperatorSecret);
String dataJson = JSONUtil.toJsonStr(data);
//加密
byte[] encryptText = Cryptos.aesEncrypt(dataJson.getBytes(StandardCharsets.UTF_8),
OperatorSecret.getBytes(), OperatorSecret.getBytes());
String strData = Encodes.encodeBase64(encryptText);
Map<String, String> request = new LinkedHashMap<>();
request.put("OperatorID", OperatorID);
request.put("Data", strData);
request.put("TimeStamp", System.currentTimeMillis() + "");
request.put("Seq", "0001");
//生成签名
String sig = GBSignUtils.sign(request, OperatorSecret);
request.put("Sig", sig);
String tokenRequest = JSONUtil.toJsonStr(request);
CommonParamsDTO dto = JSONObject.parseObject(tokenRequest, CommonParamsDTO.class);
lianLianService.generateToken(dto);
}
@Test
public void testupdateElecAmount() {
// orderBasicInfoService.updateElecAmount();
}
@Test
public void testSelectSomeStatusCardInfo() {
PileAuthCard pileAuthCard = pileAuthCardService.selectCardInfoByLogicCard("1111111111111111");
System.out.println(pileAuthCard);
}
@Test
public void testLianLian() throws UnsupportedEncodingException {
// 获取令牌
// LianLianGetTokenDTO dto = new LianLianGetTokenDTO();
// dto.setOperatorId("MA1JLFUU8");
// dto.setOperatorSecret("Nh62XxlIR5OjAzFj");
// String token = lianLianService.getToken("", "MA1JLFUU8", "fGwLsxW1HdzLw7jp");
// System.out.println("token:" + token);
String operatorId = "425010765";
String operatorSecret = "3DSBTWHVIC6KVCKI";
// 请求data
// Map<String, String> data = new HashMap<>();
// data.put("OperatorID", operatorId);
// data.put("OperatorSecret", operatorSecret);
// String dataJson = JSONUtil.toJsonStr(data);
JSONObject json = new JSONObject();
// json.put("StationIDs", com.google.common.collect.Lists.newArrayList("1", "2"));
json.put("LastQueryTime", "2023-05-29 10:00:00");
json.put("PageNo", 1);
json.put("PageSize", 10);
String dataJson = JSONObject.toJSONString(json);
// 加密
byte[] encryptText = Cryptos.aesEncrypt(dataJson.getBytes(StandardCharsets.UTF_8),
operatorSecret.getBytes(), operatorSecret.getBytes());
String strData = Encodes.encodeBase64(encryptText);
String timeStamp = DateUtils.parseDateToStr(DateUtils.YYYYMMDDHHMMSS, new Date());
Map<String, String> request = new LinkedHashMap<>();
request.put("OperatorID", operatorId);
request.put("Data", strData);
request.put("TimeStamp", timeStamp);
request.put("Seq", "0001");
// 生成签名
String sig = GBSignUtils.sign(request, operatorSecret);
request.put("Sig", sig);
JSONObject jsonObject = new JSONObject(request);
System.out.println(jsonObject);
// CommonParamsDTO dto = new CommonParamsDTO();
// dto.setOperatorID(operatorId);
// dto.setData(strData);
// dto.setTimeStamp(timeStamp);
// dto.setSeq("0001");
// dto.setSig(sig);
// Map<String, String> map = lianLianService.generateToken(dto);
QueryStationInfoDTO dto = new QueryStationInfoDTO();
dto.setOperatorId(operatorId);
Map<String, String> map = lianLianService.query_stations_info(dto);
// String data1 = map.get("Data");
// 解密data
// String data1 = "JudlP17tnYuQc2zwOzmjJAb9hgghIymefG5v3ZzSOlPDh5+bJHIedsYzKMD56tHlmlg6Cb7vG+o6KjMSSpn1fyqBH3UVaEFF7uEc+lOuEc9c1vUzq20vBQ7N3EpDKqVBKjZbOezMsKYaCX7Br8XTsCYT8VCQui/np3cn+phi3VC+0s1coNxBX7xoEDZ7iuPjPoSWL7g3J0uOw2SoGaIdBQG3eTxaZJ5L+vBmuDF0pEXgazTMnuKml1mx1QHkig2F7h/ILT0VEKVXWMmmogYgiBk5ItO0DyzRl+ASb184gOhYGo82GJmWRiXrAXmceCiSNvTGg6aL26imIGKkJNfOx9/9mTqjGvy6kzxvWJ29PBU=";
// byte[] plainText = Cryptos.aesDecrypt(Encodes.decodeBase64(data1),
// operatorSecret.getBytes(), operatorSecret.getBytes());
// String dataStr = new String(plainText, "UTF-8");
// Map<String, String> resultMap = (Map<String, String>) JSON.parse(dataStr);
//
// String token = resultMap.get("AccessToken");
//
// System.out.println("解密后token：" + token);
// LianLianPushStationInfoDTO dto1 = LianLianPushStationInfoDTO.builder()
// .OperatorID("MA1JLFUU8")
// .DataSecret("HVicnbRZbhPdIdpF")
// .DataSecretIV("JNvcjSOn1vhrE11M")
// .SigSecret("53TtFpc4gdVZbF3x")
// // .token(token)
// .stationId(2L)
//
// .build();
// lianLianService.pushStationInfo(dto1);
// 推送订单状态
// lianLianService.pushConnectorStatus("8800000000000101", "1");
// 推送订单信息
// lianLianService.pushOrderInfo("C27680791529");
// 推送启动充电结果
// lianLianService.pushStartChargeResult("C27680791529");
// 推送充电状态
// lianLianService.pushChargeStatus("C27680791529");
// 推送停止充电结果
// lianLianService.pushStopChargeResult("C27680791529");
// 推送充电订单信息
// lianLianService.pushChargeOrderInfo("C27680791529");
// 推送订单结算信息
// lianLianService.pushOrderSettlementInfo("C27680791529");
// 查询订单结算信息
// lianLianService.queryOrderSettlementInfo("C27680791529");
// 推送订单对账结果信息
// lianLianService.pushOrderReconciliationInfo("C27680791529");
// 测试生成、解密令牌
// long ttlMillis = 60 * 60 * 24 * 1000;
// String token = JWTUtils.createToken(operatorId, operatorSecret, ttlMillis);
// System.out.println(JWTUtils.checkThirdPartyToken(token));
JSONObject jsonObject1 = new JSONObject(map);
jsonObject1.put("OperatorID", "425010765");
jsonObject1.put("Data", "Ntu99RpveEOm2VUNq6RpD7OuOPXRbNxMOPmaBl67nkLk0nD/VmhipdSpq/Qfswhe1o55YMT+3Z7e6xe3fiJA3cZcvetxOEUF6sjvKLRq2rU=");
jsonObject1.put("TimeStamp", "20230530090132");
jsonObject1.put("Seq", "0001");
jsonObject1.put("Sig", "1568D2D35B245A0205B33D0EF92E7981");
String jsonString = JSONObject.toJSONString(jsonObject1);
String result = HttpUtils.sendPostContentType("http://localhost:8080/LianLian/v1/query_stations_info", jsonString, "application/json");
JSONObject object = JSONObject.parseObject(result);
String data1 = (String) object.get("data");
// 解密data
byte[] plainText = Cryptos.aesDecrypt(Encodes.decodeBase64(data1),
operatorSecret.getBytes(), operatorSecret.getBytes());
String dataStr = new String(plainText, "UTF-8");
Map<String, String> resultMap = (Map<String, String>) JSON.parse(dataStr);
}
@Test
public void testRefundForBalance() {
BigDecimal refundAmount = new BigDecimal("2");
// 退款金额 元转分 123
int refundTotalCents = refundAmount.multiply(new BigDecimal(100)).intValue();
// 查询用户充值余额订单 过滤掉已经退款的充值订单 refundableOrder
List<RefundableWxPayOrderData> recordList = Lists.newArrayList();
// recordList.add(RefundableWxPayOrderData.builder().outTradeNo("1").transactionId("1").payerAmount(new BigDecimal("1000")).refundableAmount(new BigDecimal("0")).build());
// recordList.add(RefundableWxPayOrderData.builder().outTradeNo("2").transactionId("2").payerAmount(new BigDecimal("1000")).refundableAmount(new BigDecimal("0")).build());
recordList.add(RefundableWxPayOrderData.builder().outTradeNo("3").transactionId("3").payerAmount(new BigDecimal("500")).refundableAmount(new BigDecimal("300")).build());
// 也许需要多笔支付订单才够退款
List<WechatPayRefundRequest> requestList = com.google.common.collect.Lists.newArrayList();
WechatPayRefundRequest request;
for (RefundableWxPayOrderData record : recordList) {
int refundableTotal = record.getRefundableAmount().intValue(); // 该笔支付订单的可退金额，单位分
int payerTotal = record.getPayerAmount().intValue(); // 该笔支付订单的支付金额，单位分
// 用户申请退款金额-可退金额
refundTotalCents = refundTotalCents - refundableTotal; // 123 - 100
request = new WechatPayRefundRequest();
request.setTransaction_id(record.getTransactionId()); // 微信支付单号
request.setOut_trade_no(record.getOutTradeNo()); // 商户订单号
request.setOut_refund_no(SnowflakeIdWorker.getSnowflakeId()); // 商户退款单号
request.setNotify_url(WeChatPayParameter.refundNotifyUrl); // 回调接口
request.setReason("用户余额退款");
request.setFunds_account("AVAILABLE");
if (refundTotalCents > 0) {
// 如果大于0说明，这笔单退完也不够
WechatPayRefundRequest.Amount amount = new WechatPayRefundRequest.Amount();
amount.setRefund(refundableTotal); // 退款金额
amount.setTotal(payerTotal); // 原订单金额
request.setAmount(amount);
requestList.add(request);
} else {
// 如果小于0，这笔单退一部分
// 生成退款单号
WechatPayRefundRequest.Amount amount = new WechatPayRefundRequest.Amount();
// 部分退
int i = refundableTotal + refundTotalCents;
amount.setRefund(i); // 退款金额
amount.setTotal(payerTotal); // 原订单金额
request.setAmount(amount);
requestList.add(request);
break;
}
}
System.out.println(requestList);
}
@Test
public void testCloseStartFailedOrder() {
String startTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, DateUtils.addDays(new Date(), -2));
String endTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, new Date());
orderBasicInfoService.closeStartFailedOrder(startTime, endTime);
}
@Test
public void testRedisSaveRealTimeData() {
String pileSn = "88000000000001";
String connectorCode = "01";
String orderCode = "88000000000001012211161342359448";
String pileConnectorCode = pileSn + connectorCode;
String redisKey = CacheConstants.PILE_REAL_TIME_MONITOR_DATA + pileConnectorCode + "_" + orderCode;
// for (int i = 0; i < 10; i++) {
// try {
// Thread.sleep(10000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// Date now = new Date();
// redisCache.hset(redisKey, DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:00", now), i + ":" + DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:ss", now));
// }
orderBasicInfoService.getChargingRealTimeData(orderCode);
}
@Test
public void testuniformMessageSend() {
AppletTemplateMessageSendDTO appletTemplateMessageSendDTO = new AppletTemplateMessageSendDTO();
// String openId = wxAppletRemoteService.getOpenIdByCode("0537u2100jTXsP1Y0Y300j426t47u210");
// System.out.println("openId:" + openId);
appletTemplateMessageSendDTO.setTouser("o4REX5MprZfTaLnVNxfdOY-wnwGI"); // openid
String templateId = "UyBPbADlZfsCj89rh_xvfZGlxTW5J5KURpZtt9CNFrY";
appletTemplateMessageSendDTO.setTemplate_id(templateId);
// appletTemplateMessageSendDTO.setPage("跳转的页面");
Map<String, Object> map = new HashMap<>();
map.put("amount17", ImmutableMap.of("value", "￥100")); // 结束时间
map.put("time3", ImmutableMap.of("value", "2022-12-30")); // 结束时间
map.put("thing7", ImmutableMap.of("value", "thing7")); // 结束原因
// map.put("thing5", ImmutableMap.of("value", "thing5")); // 结束原因
// map.put("time2", ImmutableMap.of("value", "time2")); // 结束原因
appletTemplateMessageSendDTO.setData(map);
wxAppletRemoteService.uniformMessageSend(appletTemplateMessageSendDTO);
}
@Test
public void testWeChatRefund() {
ApplyRefundDTO dto = new ApplyRefundDTO();
dto.setRefundType("2");
dto.setMemberId("82100864");
dto.setRefundAmount(new BigDecimal("1.23"));
orderBasicInfoService.weChatRefund(dto);
}
@Test
public void testSelectBalanceRechargeRecord() {
List<WxpayCallbackRecord> list = wxpayCallbackRecordService.queryBalanceRechargeRecordOfTheLatestYear("82100864");
System.out.println(list);
}
@Test
public void testSelectOrderBasicInfoList() {
QueryOrderDTO orderBasicInfo = new QueryOrderDTO();
orderBasicInfo.setPileSn("88000000000001");
orderBasicInfo.setOrderStatus(OrderStatusEnum.IN_THE_CHARGING.getValue());
List<OrderListVO> orderListVOS = orderBasicInfoService.selectOrderBasicInfoList(orderBasicInfo);
System.out.println(orderListVOS);
for (OrderListVO orderListVO : orderListVOS) {
if (StringUtils.equals(orderListVO.getOrderStatus(), OrderStatusEnum.IN_THE_CHARGING.getValue())) {
// 修改数据库订单状态
OrderBasicInfo info = OrderBasicInfo.builder()
.id(Long.parseLong(orderListVO.getId()))
.orderStatus(OrderStatusEnum.ABNORMAL.getValue())
.build();
orderBasicInfoService.updateOrderBasicInfo(info);
}
}
}
@Test
public void testWechatRefund() throws JsonProcessingException {
WechatPayRefundRequest request = new WechatPayRefundRequest();
request.setTransaction_id("4200001656202212302746036536"); // 微信支付单号
request.setOut_trade_no("768677222373363712"); // 商户订单号
// 生成退款单号
request.setOut_refund_no(SnowflakeIdWorker.getSnowflakeId()); // 商户退款单号
request.setNotify_url(WeChatPayParameter.refundNotifyUrl); // 回调接口
WechatPayRefundRequest.Amount amount = new WechatPayRefundRequest.Amount();
amount.setRefund(10 * 100); // 退款金额
amount.setTotal(10 * 100); // 原订单金额
request.setAmount(amount);
request.setReason("结算退款");
request.setFunds_account("AVAILABLE");
wechatPayService.ApplyForWechatPayRefundV3(request);
// 退款方法
}
@Test
public void testUpdatePileSimInfo() {
String pileSn = "88000000000001";
String iccid = "89860402102091089943";
pileBasicInfoService.updatePileSimInfo(pileSn, iccid);
}
@Test
public void testPay() {
String code = "081zIoGa11GamE0iVVIa1aaJ4G0zIoGE";
String openId = memberService.getOpenIdByCode(code);
Map<String, Object> pay = null;
try {
WeixinPayDTO dto = new WeixinPayDTO();
dto.setOpenId(openId);
dto.setAmount("0.01");
pay = orderService.weixinPayV3(dto);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(JSONObject.toJSONString(pay));
}
@Test
public void testMemberRegisterAndLogin() throws BaseAdaPayException {
}
@Test
public void testMemberBasicInfoMapper() {
// String memberId = "21772870";
// BigDecimal principalBalance = new BigDecimal("-10");
// BigDecimal giftBalance = new BigDecimal("-110");
// Integer version = 2;
// int i = memberBasicInfoMapper.updateMemberBalance(memberId, principalBalance, giftBalance, version);
// if (i == 1) {
// System.out.println("更新余额成功");
// } else {
// System.out.println("更新余额失败");
// }
Map<String, Object> refundParams = new HashMap<>(2);
refundParams.put("payment_id", "002212023071011321210524320114191904768");
// refundParams.put("refund_id", refund_id);
// refundParams.put("refund_order_no", refund_order_no);
try {
Map<String, Object> refund = Refund.query(refundParams);
System.out.println(refund);
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
update
2023-10-08 16:42:56 +08:00
}
/**
* 查询退款信息
*/
@Test
public void queryRefundTest() {
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
List<String> list = getPaymentIdList(); // 查询退款信息
update
2023-10-08 16:42:56 +08:00
for (String paymentId : list) {
Map<String, Object> refundParams = Maps.newHashMap();
refundParams.put("payment_id", paymentId);
try {
update
2023-10-31 15:17:39 +08:00
Map<String, Object> refund = Refund.query(refundParams, wechatAppId2);
update
2023-10-08 16:42:56 +08:00
System.out.println("支付id:" + paymentId + ", 退款信息:" + JSON.toJSONString(refund));
System.out.println();
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
}
}
/**
* 查询支付撤销信息
*/
@Test
public void queryPaymentReverseTest() {
update 查询分账情况工具
2023-12-13 17:11:35 +08:00
List<String> list = getPaymentIdList(); // 查询支付撤销信息
update
2023-10-08 16:42:56 +08:00
for (String paymentId : list) {
try {
Map<String, Object> reverse = Maps.newHashMap();
reverse.put("payment_id", paymentId);
update
2023-10-31 15:17:39 +08:00
reverse.put("app_id", wechatAppId2);
Map<String, Object> response = PaymentReverse.queryList(reverse, wechatAppId2);
update
2023-10-08 16:42:56 +08:00
System.out.printf("支付id: %s, 支付撤销信息: %s%n", paymentId, JSON.toJSONString(response));
System.out.println();
} catch (BaseAdaPayException e) {
throw new RuntimeException(e);
}
}
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void testGenerateBillingTemplateMsgBody() {
String pileSn = "88000000000001";
// 根据桩号查询计费模板
BillingTemplateVO billingTemplateVO = pileBillingTemplateService.selectBillingTemplateDetailByPileSn(pileSn);
byte[] messageBody = pileBillingTemplateService.generateBillingTemplateMsgBody(pileSn, billingTemplateVO);
System.out.println(BytesUtil.binary(messageBody, 16));
}
@Test
public void testAnalysisPileParameter() {
BasicPileDTO dto = new BasicPileDTO();
// 3个都不传的情况
try {
System.out.println("3个都不传的情况");
dto.setPileSn("");
dto.setConnectorCode("");
dto.setPileConnectorCode("");
// orderService.analysisPileParameter(dto);
System.out.println("数据正确");
} catch (BusinessException e) {
System.out.println(e.getMessage());
}
System.out.println();
// 只传sn的情况
try {
System.out.println("只传sn的情况");
dto.setConnectorCode("");
dto.setPileConnectorCode("");
dto.setPileSn("88000000000001");
// orderService.analysisPileParameter(dto);
System.out.println("数据正确");
} catch (BusinessException e) {
System.out.println(e.getMessage());
}
System.out.println();
//
try {
System.out.println("只穿枪口号的情况");
dto.setConnectorCode("01");
dto.setPileConnectorCode("");
dto.setPileSn("");
// orderService.analysisPileParameter(dto);
System.out.println("数据正确");
} catch (BusinessException e) {
System.out.println(e.getMessage());
}
System.out.println();
// 只传充电桩枪口编号的情况
try {
System.out.println("只传充电桩枪口编号的情况");
dto.setPileConnectorCode("8800000000000101");
dto.setConnectorCode("");
dto.setPileSn("");
// orderService.analysisPileParameter(dto);
System.out.println("数据正确");
} catch (BusinessException e) {
System.out.println(e.getMessage());
}
try {
System.out.println();
System.out.println("传充电桩枪sn+枪口号的情况");
dto.setPileConnectorCode("");
dto.setConnectorCode("01");
dto.setPileSn("88000000000001");
// orderService.analysisPileParameter(dto);
System.out.println("数据正确");
} catch (BusinessException e) {
System.out.println(e.getMessage());
}
}
@Test
public void testImportBillingTemplate() {
ImportBillingTemplateDTO dto = new ImportBillingTemplateDTO();
dto.setBillingTemplateId("1");
// 查询公共计费模板是否存在
PileBillingTemplate pileBillingTemplate = pileBillingTemplateMapper.selectPileBillingTemplateById(Long.valueOf(dto.getBillingTemplateId()));
if (pileBillingTemplate == null) {
}
List<PileBillingDetail> billingDetailList = pileBillingTemplate.getPileBillingDetailList();
}
@Test
public void testProcess() {
// 62 68
String msgString = "680da300000388000000000001010020d06840a40000130000000000000000000000000000000088000000000001010202000000000000000000000000000000000000000000000000000000000000000000001516";
byte[] msg = BytesUtil.str2Bcd(msgString);
boolean b = YKCUtils.checkMsg(msg);
// ykcBusinessService.process(msg, null);
}
@Test
public void testHeartbeat() {
// heartbeatRequestHandler.updateStatus("88000000000001", "01", "0");
// heartbeatRequestHandler.updateStatus("88000000000001", "02", "0");
}
@Test
public void testPush() {
byte[] msg = new byte[]{};
String pileSn = "88000000000001";
// ykcPushBusinessService.push(msg, pileSn, YKCFrameTypeCode.READ_REAL_TIME_MONITOR_DATA_CODE);
}
@Test
public void TestMapUtils() {
String address = "淀山湖镇黄浦江南路278号";
String areaCode = "320000,320500,320583";
Map<String, String> longitudeAndLatitude = AddressUtils.getLongitudeAndLatitude(areaCode, address);
System.out.println(longitudeAndLatitude);
}
@Test
public void testCreatePile() {
BatchCreatePileDTO dto = BatchCreatePileDTO.builder()
.merchantId("1")
.stationId("1")
.softwareProtocol("1")
// .connectorNum(1)
// .num(10)
// .productionDate(new Date())
.build();
pileService.batchCreatePile(dto);
}
@Test
public void testGetIncre() {
StopWatch stopWatch = new StopWatch();
// 生成100个
stopWatch.start("生成100个sn号");
List<String> list2 = snUtils.generateSN(1);
stopWatch.stop();
System.out.println(list2);
System.out.println(stopWatch.getLastTaskTimeMillis());
}
@Test
public void testDict() {
// String dictValue = DictUtils.getDictValue("query_pile_info", "url");
// String station_type = DictUtils.getDictLabel("station_type", "1");
// System.out.println(station_type);
// System.out.println("123");
List<SysDictData> adapay_station = DictUtils.getDictCache("adapay_station");
List<String> stationIdList = com.google.common.collect.Lists.newArrayList();
if (CollectionUtils.isNotEmpty(adapay_station)) {
for (SysDictData sysDictData : adapay_station) {
stationIdList.add(sysDictData.getDictValue());
}
}
System.out.println(stationIdList);
}
@Test
public void testSelectByMerchantId() {
List<PileStationInfo> list = pileStationInfoService.selectStationListByMerchantId(Long.valueOf(Constants.ONE));
System.out.println(list);
}
@Test
public void testStr2Bcd() {
String logicCardNum = "00000000";
byte[] logicCardNumByteArr = BytesUtil.str2Bcd(logicCardNum);
System.out.println(Arrays.toString(logicCardNumByteArr));
}
@Test
public void testBigDecimalMultiply() {
BigDecimal a = new BigDecimal("216.5");
BigDecimal b = new BigDecimal("11.5");
BigDecimal result = a.multiply(b).setScale(2, BigDecimal.ROUND_HALF_UP);
System.out.println(result);
}
@Test
public void testRemoteUpdate() {
ArrayList<String> list = new ArrayList<>();
list.add("88000000000001");
// pileRemoteService.updateFirmware(list);
}
@Test
public void testGetUserPhoneNum() {
String code = "0e5394cfa4eb41c6181ed257f2368a86dfe4ebdac0a4fac85df63657637e6cc3";
wxAppletRemoteService.getMobileNumberByCode(code);
}
@Test
public void testDistance() {
QueryStationDTO dto = new QueryStationDTO();
dto.setStationLat("123.2222");
dto.setStationLng("55.6232");
// pileStationInfoService.uniAppQueryStationInfos(dto);
}
/**
* 生成英文字母随机数 RandomStringUtils.randomAlphabetic(10);
* 生成数字随机数 RandomStringUtils.randomNumeric(10);
* 字母+数字结合 RandomStringUtils.randomAlphanumeric(10);
*/
@Test
public void Test() throws ParseException {
commit
2023-03-04 16:29:55 +08:00
/*String s = RandomStringUtils.randomAlphanumeric(32);
System.out.println(s); // PuLe4Tyyg1jSFNPhF5d2Ts9ejRn6E8KQ
String str = "JS160829";
System.out.println(Md5Utils.hash(str).toUpperCase(Locale.ROOT));
*/
update 江苏省平台接口
2023-10-19 11:21:02 +08:00
String s = RandomStringUtils.randomAlphanumeric(16).toUpperCase(Locale.ROOT);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
System.out.println(s);
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
Date startTimeDate = sdf.parse("2022-11-26 10:44:11");
Date endTimeDate = sdf.parse("2022-11-27 12:45:11");
commit
2023-03-04 16:29:55 +08:00
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
System.out.println(DateUtils.getDatePoor(endTimeDate, startTimeDate)); // 1天2小时1分钟
commit
2023-03-04 16:29:55 +08:00
/*String stra = "sp_mchid=1632405339&sub_mchid=1632405339&out_trade_no=1217752501201407033233368318&sp_appid=wxbb3e0d474569481d&sub_appid=wxbb3e0d474569481d" +
"bbac689f4654b209de4d6944808ec80b";
System.out.println(Md5Utils.hash(stra).toUpperCase(Locale.ROOT));*/
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void testSimCard() throws ParseException {
ArrayList<String> list = Lists.newArrayList();
Collections.addAll(list, "898607B9102090253556", "898607B9102090253560");
// String s = list.toString().replaceAll("(?:\\[|null|\\]| +)", "");
// System.out.println(s);
// List<SimCardVO> simCardVOList = simCardService.selectSimCardInfoByIccId(list);
// System.out.println(simCardVOList.toString());
// simCardService.XunZhongSimRenewal(list, 12);
// System.out.println(s);
// SimCardVO simCardVO = simCardService.searchByLoop("898607B9102090253556");
//
// System.out.println(simCardVO.toString());
simCardService.WuLianSimRenew(list, 1);
}
@Test
public void testRefund() {
OrderBasicInfo orderInfo = orderBasicInfoService.getOrderInfoByOrderCode("88000000000001012212171045412218");
orderInfo.setReason("充电异常中止，急停开入");
TransactionRecordsData data = TransactionRecordsData.builder()
.transactionCode("88000000000001012212171045412218")
.consumptionAmount(String.valueOf(0.00))
.stopReasonMsg(orderInfo.getReason())
.totalElectricity("0")
.sharpUsedElectricity("0")
.peakUsedElectricity("0")
.flatUsedElectricity("0")
.valleyUsedElectricity("0")
.build();
update 订单逻辑改造工厂模式
2023-09-01 15:45:04 +08:00
// orderBasicInfoService.settleOrder(data, orderInfo);
单元测试 在线支付订单、退款
2023-08-30 11:02:18 +08:00
}
@Test
public void testLoginHandler() {
String msg = "8800000000001001010f63362d333000000000898604b319227036282200";
byte[] msgBody = BytesUtil.str2Bcd(msg);
int startIndex = 0;
int length = 7;
// 桩编码
byte[] pileSnByte = BytesUtil.copyBytes(msgBody, startIndex, length);
String pileSn = BytesUtil.binary(pileSnByte, 16);
// log.info("桩号：{}", pileSn);
// 桩类型 0 表示直流桩， 1 表示交流桩
startIndex += length;
length = 1;
byte[] pileTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String pileType = BytesUtil.bcd2Str(pileTypeByteArr);
// 充电枪数量
startIndex += length;
byte[] connectorNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String connectorNum = BytesUtil.bcd2Str(connectorNumByteArr);
// 通信协议版本 版本号乘 10，v1.0 表示 0x0A
startIndex += length;
byte[] communicationVersionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
// int i = Integer.parseInt(BytesUtil.bcd2Str(communicationVersionByteArr)); // 0F --> 15
BigDecimal bigDecimal = new BigDecimal(BytesUtil.bcd2Str(communicationVersionByteArr));
BigDecimal communicationVersionTemp = bigDecimal.divide(new BigDecimal(10));
String communicationVersion = "v" + communicationVersionTemp;
// 程序版本
startIndex += length;
length = 8;
byte[] programVersionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String programVersion = BytesUtil.bcd2Str(programVersionByteArr);
// 网络连接类型 0x00 SIM 卡 0x01 LAN 0x02 WAN 0x03 其他
startIndex += length;
length = 1;
byte[] internetConnectionTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String internetConnection = BytesUtil.bcd2Str(internetConnectionTypeByteArr);
// sim卡
startIndex += length;
length = 10;
byte[] simCardNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String iccid = BytesUtil.bin2HexStr(simCardNumByteArr);
// 运营商 0x00 移动 0x02 电信 0x03 联通 0x04 其他
startIndex += length;
length = 1;
byte[] businessTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
String business = BytesUtil.bcd2Str(businessTypeByteArr);
LoginRequestData loginRequestData = LoginRequestData.builder()
.pileSn(pileSn)
.pileType(pileType)
.connectorNum(connectorNum)
.communicationVersion(communicationVersion)
.programVersion(programVersion)
.internetConnection(internetConnection)
.iccid(iccid)
.business(business)
.build();
// 结果（默认 0x01:登录失败）
byte[] flag = Constants.oneByteArray;
// 通过桩编码SN查询数据库，如果有数据，则登录成功，否则登录失败
QueryPileDTO dto = new QueryPileDTO();
dto.setPileSn(pileSn);
List<PileDetailVO> list = pileBasicInfoService.queryPileInfos(dto);
if (CollectionUtils.isNotEmpty(list)) {
flag = Constants.zeroByteArray;
// 登录成功，保存桩号和channel的关系
// PileChannelEntity.put(pileSn, channel);
// 更改桩和该桩下的枪口状态分别为 在线、空闲
// pileBasicInfoService.updatePileStatus(pileSn, PileStatusEnum.ON_LINE.getValue());
// pileConnectorInfoService.updateConnectorStatusByPileSn(pileSn, PileConnectorDataBaseStatusEnum.FREE.getValue());
// 对时
ProofreadTimeCommand command = ProofreadTimeCommand.builder().pileSn(pileSn).build();
ykcPushCommandService.pushProofreadTimeCommand(command);
// 公共方法修改状态
pileBasicInfoService.updateStatus(BytesUtil.bcd2Str(new byte[]{0x01}), pileSn, null, null, null);
// 下发二维码
IssueQRCodeCommand issueQRCodeCommand = IssueQRCodeCommand.builder().pileSn(pileSn).build();
ykcPushCommandService.pushIssueQRCodeCommand(issueQRCodeCommand);
}
// 充电桩使用的sim卡，把信息存库
if (StringUtils.equals("00", internetConnection)) {
try {
pileBasicInfoService.updatePileSimInfo(pileSn, iccid);
} catch (Exception e) {
// log.error("更新充电桩sim卡信息失败", e);
System.out.println(e.getMessage());
}
}
// 保存报文
String jsonMsg = JSONObject.toJSONString(loginRequestData);
// pileMsgRecordService.save(pileSn, pileSn, type, jsonMsg, ykcDataProtocol.getHEXString());
// // 消息体
// byte[] messageBody = Bytes.concat(pileSnByte, flag);
// return getResult(ykcDataProtocol, messageBody);
}
@Test
public void testGetMemberToken() {
String memberId = JWTUtils.getMemberId("eyJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2NzY1MTY5MzgsImV4cCI6MTY3OTEwODkzOH0.4MwhZIOpnCfQloR7zEm2hwPOh2yyI2qxbBbTcv_SnZ4");
System.out.println(memberId);
}
commit
2023-03-04 16:29:55 +08:00
}
Reference in New Issue Copy Permalink