mirror of
https://codeup.aliyun.com/67c68d4e484ca2f0a13ac3c1/ydc/jsowell-charger-web.git
synced 2026-06-14 20:30:04 +08:00
1298 lines
57 KiB
Java
1298 lines
57 KiB
Java
package com.jsowell.quartz.task;
|
||
|
||
import com.alibaba.fastjson2.JSON;
|
||
import com.google.common.collect.Lists;
|
||
import com.jsowell.adapay.common.DivMember;
|
||
import com.jsowell.adapay.common.PaymentConfirmInfo;
|
||
import com.jsowell.adapay.dto.PaymentConfirmParam;
|
||
import com.jsowell.adapay.dto.QueryPaymentConfirmDTO;
|
||
import com.jsowell.adapay.dto.WithdrawDTO;
|
||
import com.jsowell.adapay.response.PaymentConfirmResponse;
|
||
import com.jsowell.adapay.response.QueryPaymentConfirmDetailResponse;
|
||
import com.jsowell.adapay.service.AdapayService;
|
||
import com.jsowell.common.YouDianUtils;
|
||
import com.jsowell.common.constant.CacheConstants;
|
||
import com.jsowell.common.constant.Constants;
|
||
import com.jsowell.common.core.redis.RedisCache;
|
||
import com.jsowell.common.enums.thirdparty.ThirdPlatformTypeEnum;
|
||
import com.jsowell.common.util.DateUtils;
|
||
import com.jsowell.common.util.PageUtils;
|
||
import com.jsowell.common.util.StringUtils;
|
||
import com.jsowell.common.util.spring.SpringUtils;
|
||
import com.jsowell.pile.domain.AdapayUnsplitRecord;
|
||
import com.jsowell.pile.domain.OrderBasicInfo;
|
||
import com.jsowell.pile.domain.PileMerchantInfo;
|
||
import com.jsowell.pile.domain.PileStationInfo;
|
||
import com.jsowell.pile.domain.ykcCommond.PublishPileBillingTemplateCommand;
|
||
import com.jsowell.pile.domain.ykcCommond.StartChargingCommand;
|
||
import com.jsowell.pile.service.*;
|
||
import com.jsowell.pile.service.MemberCouponService;
|
||
import com.jsowell.pile.vo.AdapayUnsplitRecordVO;
|
||
import com.jsowell.pile.vo.base.StationInfoVO;
|
||
import com.jsowell.pile.vo.web.BillingTemplateVO;
|
||
import com.jsowell.thirdparty.amap.service.AMapService;
|
||
import com.jsowell.thirdparty.common.NotificationDTO;
|
||
import com.jsowell.thirdparty.common.NotificationService;
|
||
import org.apache.commons.collections4.CollectionUtils;
|
||
import org.apache.poi.ss.usermodel.*;
|
||
import org.slf4j.Logger;
|
||
import org.slf4j.LoggerFactory;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.stereotype.Component;
|
||
|
||
import java.io.InputStream;
|
||
import java.math.BigDecimal;
|
||
import java.nio.file.Files;
|
||
import java.nio.file.Path;
|
||
import java.nio.file.Paths;
|
||
import java.time.LocalDate;
|
||
import java.time.LocalDateTime;
|
||
import java.util.*;
|
||
import java.util.stream.Collectors;
|
||
|
||
@Component("jsowellTask")
|
||
public class JsowellTask {
|
||
|
||
private final Logger log = LoggerFactory.getLogger(JsowellTask.class);
|
||
|
||
@Autowired
|
||
private OrderBasicInfoService orderBasicInfoService;
|
||
|
||
@Autowired
|
||
private PileBillingTemplateService pileBillingTemplateService;
|
||
|
||
@Autowired
|
||
private YKCPushCommandService ykcPushCommandService;
|
||
|
||
@Autowired
|
||
private PileMerchantInfoService pileMerchantInfoService;
|
||
|
||
@Autowired
|
||
private PileStationInfoService pileStationInfoService;
|
||
|
||
@Autowired
|
||
private RedisCache redisCache;
|
||
|
||
@Autowired
|
||
private NotificationService notificationService;
|
||
|
||
@Autowired
|
||
private AMapService aMapService;
|
||
|
||
@Autowired
|
||
private AdapayService adapayService;
|
||
|
||
@Autowired
|
||
private SettleOrderReportService settleOrderReportService;
|
||
|
||
@Autowired
|
||
private ThirdPartyStationRelationService thirdPartyStationRelationService;
|
||
|
||
// @Autowired
|
||
// private OrderUnsplitRecordService orderUnsplitRecordService;
|
||
|
||
@Autowired
|
||
private AdapayUnsplitRecordService adapayUnsplitRecordService;
|
||
|
||
@Autowired
|
||
private MemberCouponService memberCouponService;
|
||
|
||
/**
|
||
* 设置挡板, PRE环境不执行
|
||
*/
|
||
public void setBarrier() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
// return;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 关闭15分钟未支付的订单
|
||
* close15MinutesOfUnpaidOrders
|
||
*/
|
||
public void close15MinutesOfUnpaidOrders() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
// log.info("关闭15分钟未支付的订单");
|
||
orderBasicInfoService.close15MinutesOfUnpaidOrders();
|
||
}
|
||
|
||
/**
|
||
* 关闭启动失败的订单
|
||
* 订单支付成功，在15分钟内未启动，
|
||
*/
|
||
public void closeStartFailedOrder() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
// return;
|
||
}
|
||
// 查询出最近2天支付成功，并且订单状态为未启动的订单
|
||
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);
|
||
}
|
||
|
||
/**
|
||
* 查询预约充电的订单并启动
|
||
*/
|
||
public void appointmentOrderStart() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
// 查询出 已支付 设置预约充电 未启动 的订单
|
||
LocalDateTime now = LocalDateTime.now();
|
||
List<OrderBasicInfo> list = orderBasicInfoService.getReservedOrder(now);
|
||
if (CollectionUtils.isEmpty(list)) {
|
||
return;
|
||
}
|
||
log.info("待启动充电订单:{}", list);
|
||
for (OrderBasicInfo orderInfo : list) {
|
||
// 下发充电桩设置指令
|
||
String pileSn = orderInfo.getPileSn();
|
||
// 发送启动充电指令前，再次下发计费模板
|
||
BillingTemplateVO billingTemplateVO = pileBillingTemplateService.selectBillingTemplateDetailByPileSn(pileSn);
|
||
if (billingTemplateVO != null) {
|
||
PublishPileBillingTemplateCommand command = PublishPileBillingTemplateCommand.builder()
|
||
.billingTemplateVO(billingTemplateVO)
|
||
.pileSn(pileSn)
|
||
.build();
|
||
ykcPushCommandService.pushPublishPileBillingTemplate(command);
|
||
}
|
||
// 发送启动指令
|
||
String connectorCode = orderInfo.getConnectorCode();
|
||
String transactionCode = orderInfo.getTransactionCode();
|
||
BigDecimal payAmount = orderInfo.getPayAmount();
|
||
|
||
if (StringUtils.isEmpty(pileSn) || StringUtils.isEmpty(connectorCode)) {
|
||
log.warn("appointmentOrderStart-远程启动充电, 充电桩编号和枪口号不能为空");
|
||
return;
|
||
}
|
||
log.info("appointmentOrderStart 远程启动充电, 桩号：{}, 枪口号：{}", pileSn, connectorCode);
|
||
StartChargingCommand startChargingCommand = StartChargingCommand.builder()
|
||
.pileSn(pileSn)
|
||
.connectorCode(connectorCode)
|
||
.transactionCode(transactionCode)
|
||
.chargeAmount(payAmount)
|
||
.build();
|
||
ykcPushCommandService.pushStartChargingCommand(startChargingCommand);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 计算站点订单报表
|
||
* jsowellTask.calculateTheSiteOrdersReport()
|
||
*/
|
||
public void calculateTheSiteOrdersReport() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
// 查询出所有站点
|
||
PileStationInfo pileStationInfo = new PileStationInfo();
|
||
pileStationInfo.setDelFlag(Constants.ZERO);
|
||
// 查询未删除的站点列表
|
||
List<PileStationInfo> list = pileStationInfoService.selectPileStationInfoList(pileStationInfo);
|
||
if (CollectionUtils.isEmpty(list)) {
|
||
return;
|
||
}
|
||
LocalDate yesterday = LocalDate.now().plusDays(-1);
|
||
// 计算每个站点前一天的报表
|
||
for (PileStationInfo stationInfo : list) {
|
||
try {
|
||
settleOrderReportService.generateDailyOrderReports(stationInfo.getId() + "", yesterday.toString());
|
||
} catch (Exception e) {
|
||
log.error("计算站点订单报表 发生异常 stationId:{}", stationInfo.getId(), e);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 站点的枪口数据推送到高德
|
||
* jsowellTask.pushToAMap()
|
||
*/
|
||
public void pushToAMap() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
Set<String> stationIds = redisCache.getCacheSet(CacheConstants.PUSH_STATION_CONNECTOR);
|
||
if (CollectionUtils.isEmpty(stationIds)) {
|
||
return;
|
||
}
|
||
log.info("推送到高德的stationId:{}", stationIds);
|
||
for (String stationId : stationIds) {
|
||
try {
|
||
aMapService.pushChargingDeviceDynamics(stationId);
|
||
} catch (Exception e) {
|
||
log.error("推送到高德error", e);
|
||
}
|
||
}
|
||
// 删除缓存
|
||
redisCache.deleteObject(CacheConstants.PUSH_STATION_CONNECTOR);
|
||
}
|
||
|
||
/**
|
||
* 贵州省平台推送充电站实时功率 15分钟执行一次
|
||
*/
|
||
public void pushStationRealTimePowerInfo() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
|
||
List<String> thirdPartyTypeList = Lists.newArrayList(
|
||
ThirdPlatformTypeEnum.GUI_ZHOU_PLATFORM.getTypeCode(),
|
||
ThirdPlatformTypeEnum.SI_CHUAN_PLATFORM.getTypeCode(),
|
||
ThirdPlatformTypeEnum.JI_LIN_PLATFORM.getTypeCode()
|
||
);
|
||
|
||
for (String thirdPartyType : thirdPartyTypeList) {
|
||
List<StationInfoVO> stationInfoVOS = thirdPartyStationRelationService.selectStationList(thirdPartyType);
|
||
if (CollectionUtils.isEmpty(stationInfoVOS)) {
|
||
continue;
|
||
}
|
||
|
||
List<String> stationIdList = stationInfoVOS.stream()
|
||
.map(StationInfoVO::getStationId)
|
||
.collect(Collectors.toList());
|
||
|
||
for (String stationId : stationIdList) {
|
||
try {
|
||
NotificationDTO dto = new NotificationDTO();
|
||
dto.setStationId(stationId);
|
||
dto.setPlatformType(thirdPartyType);
|
||
notificationService.notificationStationPowerInfo(dto);
|
||
} catch (Exception e) {
|
||
log.error("平台类型：{}，站点ID：{}，推送充电站实时功率失败", thirdPartyType, stationId, e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* 推送统计信息 24小时执行一次
|
||
*/
|
||
public void pushStatisticsInfo() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
|
||
List<String> thirdPartyTypeList = Lists.newArrayList(
|
||
ThirdPlatformTypeEnum.GUI_ZHOU_PLATFORM.getTypeCode(),
|
||
ThirdPlatformTypeEnum.SI_CHUAN_PLATFORM.getTypeCode(),
|
||
ThirdPlatformTypeEnum.JI_LIN_PLATFORM.getTypeCode()
|
||
);
|
||
|
||
for (String thirdPartyType : thirdPartyTypeList) {
|
||
List<StationInfoVO> stationInfoVOS = thirdPartyStationRelationService.selectStationList(thirdPartyType);
|
||
if (CollectionUtils.isEmpty(stationInfoVOS)) {
|
||
continue;
|
||
}
|
||
|
||
List<String> stationIdList = stationInfoVOS.stream()
|
||
.map(StationInfoVO::getStationId)
|
||
.collect(Collectors.toList());
|
||
|
||
for (String stationId : stationIdList) {
|
||
try {
|
||
NotificationDTO dto = new NotificationDTO();
|
||
dto.setStationId(stationId);
|
||
dto.setPlatformType(thirdPartyType);
|
||
notificationService.notificationOperationStatsInfo(dto);
|
||
} catch (Exception e) {
|
||
log.error("平台类型：{}，站点ID：{}，推送统计信息失败", thirdPartyType, stationId, e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* 定时任务, 订单分账
|
||
* jsowellTask.processOrderSplitting()
|
||
*/
|
||
public void processOrderSplitting() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
// 查询运营商列表
|
||
List<PileMerchantInfo> pileMerchantInfos = pileMerchantInfoService.selectPileMerchantInfoList(null);
|
||
if (CollectionUtils.isEmpty(pileMerchantInfos)) {
|
||
log.info("定时任务，处理订单分账, 未查询到运营商列表，直接返回");
|
||
return;
|
||
}
|
||
// 获取日期
|
||
LocalDate yesterday = LocalDate.now().plusDays(-1);
|
||
|
||
// 设置挡板，8月1号之后的订单按照实际进行分账
|
||
// LocalDateTime now = LocalDateTime.now();
|
||
// LocalDateTime dateTime = LocalDateTime.of(2023, 8, 2, 0, 0, 0);
|
||
// if (now.isBefore(dateTime)) {
|
||
// log.info("当前时间:{}早于:{}, 不进行分账处理", DateUtils.formatDateTime(now), DateUtils.formatDateTime(dateTime));
|
||
// return;
|
||
// }
|
||
|
||
// 调生成运营商日报方法
|
||
pileMerchantInfos.parallelStream().forEach(merchant -> {
|
||
try {
|
||
orderBasicInfoService.orderSplittingOperations(merchant.getId() + "", yesterday.toString());
|
||
} catch (Exception e) {
|
||
log.error("生成运营商日报异常, merchantId:{}", merchant.getId(), e);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 生成运营商日报表
|
||
* jsowellTask.generateMerchantBill()
|
||
*
|
||
*
|
||
*/
|
||
public void generateMerchantBill() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
// 查询运营商列表
|
||
List<PileMerchantInfo> pileMerchantInfos = pileMerchantInfoService.selectPileMerchantInfoList(null);
|
||
if (CollectionUtils.isEmpty(pileMerchantInfos)) {
|
||
log.info("定时任务，处理订单分账, 未查询到运营商列表，直接返回");
|
||
return;
|
||
}
|
||
// 获取日期
|
||
LocalDate yesterday = LocalDate.now().plusDays(-1);
|
||
|
||
// 调生成运营商日报方法
|
||
pileMerchantInfos.parallelStream().forEach(merchant -> {
|
||
try {
|
||
orderBasicInfoService.generateMerchantBill(merchant.getId() + "", yesterday.toString());
|
||
} catch (Exception e) {
|
||
log.error("生成运营商日报异常, merchantId:{}", merchant.getId(), e);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 定时任务，自动提现
|
||
* jsowellTask.automaticPayouts()
|
||
*/
|
||
public void automaticPayouts() {
|
||
String env = SpringUtils.getActiveProfile();
|
||
if (StringUtils.equalsIgnoreCase(env, "pre")) {
|
||
log.debug("PRE环境不执行");
|
||
return;
|
||
}
|
||
// 查询开启自动提现运营商列表
|
||
// List<PileMerchantInfo> pileMerchantInfos = pileMerchantInfoService.selectPileMerchantInfoList(null);
|
||
List<PileMerchantInfo> pileMerchantInfos = pileMerchantInfoService.selectAutoWithdrawalMerchantInfoList();
|
||
if (CollectionUtils.isEmpty(pileMerchantInfos)) {
|
||
log.info("定时任务，自动提现, 未查询到运营商列表，直接返回");
|
||
return;
|
||
}
|
||
|
||
// 调提现方法
|
||
pileMerchantInfos.parallelStream().forEach(merchant -> {
|
||
try {
|
||
WithdrawDTO dto = new WithdrawDTO();
|
||
dto.setMerchantId(merchant.getId() + "");
|
||
dto.setFeeAmt("0");
|
||
adapayService.drawCash(dto);
|
||
} catch (Exception e) {
|
||
log.error("生成运营商日报异常, merchantId:{}", merchant.getId(), e);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 处理未分帐订单
|
||
* jsowellTask.processUnSettledOrder()
|
||
*/
|
||
public void processUnSettledOrder() {
|
||
// processUnSettledOrderOld(); // 旧方法
|
||
for (int i = 0; i < 35; i++) {
|
||
int batchNum = i + 1;
|
||
processUnSettledOrderV2(batchNum); // 新方法
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理adapay_unsplit_record待分账数据，统一分账到memberId=0
|
||
* 依赖queryList()，请先完成settle_amount/due_refund_amount等字段补齐
|
||
* jsowellTask.processUnsplitRecordToDefaultMember()
|
||
*/
|
||
public void processUnsplitRecordToDefaultMember() {
|
||
processUnsplitRecordToDefaultMember(Constants.DEFAULT_APP_ID, 500);
|
||
}
|
||
|
||
/**
|
||
* 处理adapay_unsplit_record待分账数据，统一分账到memberId=0
|
||
* jsowellTask.processUnsplitRecordToDefaultMember(wechatAppId, pageSize)
|
||
*/
|
||
public void processUnsplitRecordToDefaultMember(String wechatAppId, Integer pageSize) {
|
||
int size = pageSize == null || pageSize <= 0 ? 500 : pageSize;
|
||
int pageNum = 1;
|
||
int total = 0;
|
||
int success = 0;
|
||
int skipped = 0;
|
||
int failed = 0;
|
||
|
||
while (true) {
|
||
PageUtils.startPage(pageNum, size);
|
||
List<AdapayUnsplitRecordVO> list = adapayUnsplitRecordService.queryList();
|
||
if (CollectionUtils.isEmpty(list)) {
|
||
break;
|
||
}
|
||
|
||
log.info("处理未分账数据到默认账户, pageNum:{}, pageSize:{}, 当前页:{}条", pageNum, size, list.size());
|
||
for (AdapayUnsplitRecordVO item : list) {
|
||
total++;
|
||
String paymentId = item.getPaymentId();
|
||
String orderCode = item.getOrderCode();
|
||
BigDecimal waitSplitAmount = parseAmount(item.getWaitSplitAmount());
|
||
|
||
if (StringUtils.isBlank(paymentId) || waitSplitAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
||
skipped++;
|
||
continue;
|
||
}
|
||
|
||
BigDecimal confirmAmt = getLatestConfirmAmount(waitSplitAmount, item.getPayAmount(), paymentId, wechatAppId);
|
||
if (confirmAmt.compareTo(BigDecimal.ZERO) <= 0) {
|
||
skipped++;
|
||
continue;
|
||
}
|
||
|
||
PaymentConfirmResponse response;
|
||
try {
|
||
DivMember divMember = new DivMember();
|
||
divMember.setMemberId(Constants.ZERO);
|
||
divMember.setAmount(confirmAmt.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString());
|
||
divMember.setFeeFlag(Constants.Y);
|
||
|
||
PaymentConfirmParam param = PaymentConfirmParam.builder()
|
||
.paymentId(paymentId)
|
||
.divMemberList(Lists.newArrayList(divMember))
|
||
.confirmAmt(confirmAmt)
|
||
.orderCode(orderCode)
|
||
.wechatAppId(wechatAppId)
|
||
.build();
|
||
response = adapayService.createPaymentConfirmRequest(param);
|
||
} catch (Exception e) {
|
||
failed++;
|
||
log.error("处理未分账数据到默认账户异常, paymentId:{}, orderCode:{}, confirmAmt:{}",
|
||
paymentId, orderCode, confirmAmt, e);
|
||
markSplitResult(paymentId, "FAILED", "请求异常: " + e.getMessage());
|
||
continue;
|
||
}
|
||
|
||
if (response != null && response.isSuccess()) {
|
||
success++;
|
||
updateConfirmedSplitAmount(item, confirmAmt, paymentId);
|
||
markSplitResult(paymentId, "SUCCESS", "分账金额: " + confirmAmt.toPlainString());
|
||
log.info("处理未分账数据成功, paymentId:{}, orderCode:{}, confirmAmt:{}, response:{}",
|
||
paymentId, orderCode, confirmAmt, JSON.toJSONString(response));
|
||
} else {
|
||
failed++;
|
||
String errorCode = response == null ? "response_null" : response.getError_code();
|
||
String errorMsg = response == null ? "response_is_null" : response.getError_msg();
|
||
log.error("处理未分账数据失败, paymentId:{}, orderCode:{}, confirmAmt:{}, errorCode:{}, errorMsg:{}",
|
||
paymentId, orderCode, confirmAmt, errorCode, errorMsg);
|
||
markSplitResult(paymentId, "FAILED", errorCode + ": " + errorMsg);
|
||
}
|
||
}
|
||
|
||
if (list.size() < size) {
|
||
break;
|
||
}
|
||
pageNum++;
|
||
}
|
||
|
||
log.info("处理未分账数据到默认账户结束, total:{}, success:{}, skipped:{}, failed:{}",
|
||
total, success, skipped, failed);
|
||
}
|
||
|
||
/**
|
||
* 从Excel导入adapay_unsplit_record，并补齐缺失字段
|
||
* 默认文件路径：doc/万车充小程序-未分账明细.xlsx
|
||
* jsowellTask.importAdapayUnsplitRecordAndCompleteFields()
|
||
*/
|
||
/**
|
||
* 从默认路径导入未分账明细并补齐缺失字段（无参入口）
|
||
* 默认读取 doc/万车充小程序-未分账明细.xlsx（相对于工作目录）
|
||
* jsowellTask.importAdapayUnsplitRecordAndCompleteFields()
|
||
*/
|
||
public void importAdapayUnsplitRecordAndCompleteFields() {
|
||
importAdapayUnsplitRecordAndCompleteFields("doc/万车充小程序-未分账明细.xlsx");
|
||
}
|
||
|
||
/**
|
||
* 批量处理 adapay_unsplit_record 未分账记录，向汇付发起分账请求（无参入口）
|
||
* 默认：appId=DEFAULT_APP_ID，并行线程数=10
|
||
* jsowellTask.processUnsplitRecordBatch()
|
||
*/
|
||
public void processUnsplitRecordBatch() {
|
||
processUnsplitRecordBatch(Constants.DEFAULT_APP_ID, 10);
|
||
}
|
||
|
||
/**
|
||
* 批量处理 adapay_unsplit_record 未分账记录，向汇付发起分账请求（并行版本）
|
||
* 流程：
|
||
* 1. Redis setnx 防并发重入，锁有效期 120 秒
|
||
* 2. 全量查询所有待分账记录（避免 ThreadLocal 分页在并行流中失效）
|
||
* 3. 使用自定义 ForkJoinPool 并行发起分账请求，并发度由 parallelism 控制
|
||
* 4. 成功则更新 confirmed_split_amount 和 split_flag=SUCCESS，失败标记 FAILED
|
||
* jsowellTask.processUnsplitRecordBatch(wechatAppId, parallelism)
|
||
* 示例：jsowellTask.processUnsplitRecordBatch('wx_app_id', 10)
|
||
*/
|
||
public void processUnsplitRecordBatch(String wechatAppId, Integer parallelism) {
|
||
int threads = (parallelism == null || parallelism <= 0) ? 10 : parallelism;
|
||
|
||
// Redis 分布式锁，防止并发执行
|
||
Boolean acquired = redisCache.setnx(CacheConstants.PROCESS_UNSPLIT_ORDERS, Constants.ONE, 120L);
|
||
if (Boolean.FALSE.equals(acquired)) {
|
||
log.info("[processUnsplitRecordBatch] 上一批次仍在执行中，跳过本次调度");
|
||
return;
|
||
}
|
||
|
||
try {
|
||
// 全量查询待分账记录（queryList 已过滤 waitSplitAmount<=0 的记录）
|
||
// 注意：不使用 PageUtils.startPage，因为 ThreadLocal 分页在并行流中会失效
|
||
List<AdapayUnsplitRecordVO> list = adapayUnsplitRecordService.queryList();
|
||
if (CollectionUtils.isEmpty(list)) {
|
||
log.info("[processUnsplitRecordBatch] 无待分账记录，直接返回");
|
||
return;
|
||
}
|
||
log.info("[processUnsplitRecordBatch] 共查询到{}条待分账记录，并行线程数:{}", list.size(), threads);
|
||
|
||
java.util.concurrent.atomic.AtomicInteger total = new java.util.concurrent.atomic.AtomicInteger();
|
||
java.util.concurrent.atomic.AtomicInteger success = new java.util.concurrent.atomic.AtomicInteger();
|
||
java.util.concurrent.atomic.AtomicInteger skipped = new java.util.concurrent.atomic.AtomicInteger();
|
||
java.util.concurrent.atomic.AtomicInteger failed = new java.util.concurrent.atomic.AtomicInteger();
|
||
|
||
// 自定义 ForkJoinPool 控制并发度，避免占满公共池影响其他业务
|
||
java.util.concurrent.ForkJoinPool forkJoinPool = new java.util.concurrent.ForkJoinPool(threads);
|
||
try {
|
||
forkJoinPool.submit(() ->
|
||
list.parallelStream().forEach(item -> {
|
||
total.incrementAndGet();
|
||
String paymentId = item.getPaymentId();
|
||
String orderCode = item.getOrderCode();
|
||
BigDecimal waitSplitAmount = parseAmount(item.getWaitSplitAmount());
|
||
|
||
if (StringUtils.isBlank(paymentId) || waitSplitAmount.compareTo(BigDecimal.ZERO) <= 0) {
|
||
skipped.incrementAndGet();
|
||
return;
|
||
}
|
||
|
||
// 查询汇付最新可分账金额，以实际剩余可分账金额为准
|
||
BigDecimal confirmAmt = getLatestConfirmAmount(waitSplitAmount, item.getPayAmount(), paymentId, wechatAppId);
|
||
if (confirmAmt.compareTo(BigDecimal.ZERO) <= 0) {
|
||
skipped.incrementAndGet();
|
||
log.info("[processUnsplitRecordBatch] 可分账金额为0，跳过, paymentId:{}, orderCode:{}", paymentId, orderCode);
|
||
markSplitResult(paymentId, "SKIPPED", "可分账金额为0");
|
||
return;
|
||
}
|
||
|
||
// 发起汇付分账请求
|
||
PaymentConfirmResponse response;
|
||
try {
|
||
DivMember divMember = new DivMember();
|
||
divMember.setMemberId(Constants.ZERO);
|
||
divMember.setAmount(confirmAmt.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString());
|
||
divMember.setFeeFlag(Constants.Y);
|
||
|
||
PaymentConfirmParam param = PaymentConfirmParam.builder()
|
||
.paymentId(paymentId)
|
||
.divMemberList(Lists.newArrayList(divMember))
|
||
.confirmAmt(confirmAmt)
|
||
.orderCode(orderCode)
|
||
.wechatAppId(wechatAppId)
|
||
.build();
|
||
response = adapayService.createPaymentConfirmRequest(param);
|
||
} catch (Exception e) {
|
||
failed.incrementAndGet();
|
||
log.error("[processUnsplitRecordBatch] 发起分账请求异常, paymentId:{}, orderCode:{}, confirmAmt:{}",
|
||
paymentId, orderCode, confirmAmt, e);
|
||
markSplitResult(paymentId, "FAILED", "请求异常: " + e.getMessage());
|
||
return;
|
||
}
|
||
|
||
if (response != null && response.isSuccess()) {
|
||
success.incrementAndGet();
|
||
updateConfirmedSplitAmount(item, confirmAmt, paymentId);
|
||
markSplitResult(paymentId, "SUCCESS", "分账金额: " + confirmAmt.toPlainString());
|
||
log.info("[processUnsplitRecordBatch] 分账成功, paymentId:{}, orderCode:{}, confirmAmt:{}",
|
||
paymentId, orderCode, confirmAmt);
|
||
} else {
|
||
failed.incrementAndGet();
|
||
String errorCode = response == null ? "response_null" : response.getError_code();
|
||
String errorMsg = response == null ? "response_is_null" : response.getError_msg();
|
||
log.error("[processUnsplitRecordBatch] 分账失败, paymentId:{}, orderCode:{}, confirmAmt:{}, errorCode:{}, errorMsg:{}",
|
||
paymentId, orderCode, confirmAmt, errorCode, errorMsg);
|
||
markSplitResult(paymentId, "FAILED", errorCode + ": " + errorMsg);
|
||
}
|
||
})
|
||
).get();
|
||
} catch (Exception e) {
|
||
log.error("[processUnsplitRecordBatch] 并行执行异常", e);
|
||
} finally {
|
||
forkJoinPool.shutdown();
|
||
}
|
||
|
||
log.info("[processUnsplitRecordBatch] 执行结束, total:{}, success:{}, skipped:{}, failed:{}",
|
||
total.get(), success.get(), skipped.get(), failed.get());
|
||
} finally {
|
||
redisCache.deleteObject(CacheConstants.PROCESS_UNSPLIT_ORDERS);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 补齐 adapay_unsplit_record 表中缺失字段（独立入口，可单独作为定时任务调用）
|
||
* 以指定时间范围内的未分账记录为目标，补齐 orderCode、退款金额、结算金额、桩类型
|
||
* jsowellTask.completeAdapayUnsplitRecordFields(startTime, endTime)
|
||
* 示例：jsowellTask.completeAdapayUnsplitRecordFields('2024-01-01 00:00:00', '2025-12-31 23:59:59')
|
||
*/
|
||
public void completeAdapayUnsplitRecordFields(String startTime, String endTime) {
|
||
int updatedCount = completeUnsplitRecordMissingFields(startTime, endTime, 1000);
|
||
log.info("补齐未分账数据缺失字段完成, startTime:{}, endTime:{}, 更新:{}条", startTime, endTime, updatedCount);
|
||
}
|
||
|
||
/**
|
||
* 从Excel导入adapay_unsplit_record，并补齐缺失字段
|
||
* 流程：
|
||
* 1. 校验文件路径（相对路径自动拼接工作目录转为绝对路径）
|
||
* 2. 解析Excel，逐行转换为 AdapayUnsplitRecord，调用 insertOrUpdateSelective 写入数据库
|
||
* 3. 以导入数据的支付时间范围为条件，分页查询已入库记录，补齐 orderCode/退款金额/结算金额/桩类型等缺失字段
|
||
* jsowellTask.importAdapayUnsplitRecordAndCompleteFields(文件路径)
|
||
*/
|
||
public void importAdapayUnsplitRecordAndCompleteFields(String filePath) {
|
||
// 相对路径转绝对路径（基于 JVM 工作目录）
|
||
Path path = Paths.get(filePath);
|
||
if (!path.isAbsolute()) {
|
||
path = Paths.get(System.getProperty("user.dir"), filePath);
|
||
}
|
||
if (!Files.exists(path)) {
|
||
log.error("导入未分账数据失败，文件不存在:{}", path.toAbsolutePath());
|
||
return;
|
||
}
|
||
|
||
// 第一步：读取Excel，将每行数据 insertOrUpdate 到 adapay_unsplit_record 表
|
||
ImportSummary summary = importAdapayUnsplitRecord(path);
|
||
|
||
if (summary.successRows == 0) {
|
||
log.info("导入未分账数据结束，未写入任何数据，统计:{}", summary);
|
||
return;
|
||
}
|
||
|
||
// 第二步：以导入数据中最早/最晚支付时间为范围，补齐已入库记录的缺失字段
|
||
// 若 Excel 中无有效支付时间，则使用兜底时间范围（2024-01-01 至当前时间）
|
||
String startTime = summary.minPayTime == null
|
||
? "2024-01-01 00:00:00"
|
||
: DateUtils.formatDateTime(summary.minPayTime);
|
||
String endTime = summary.maxPayTime == null
|
||
? DateUtils.getDateTime()
|
||
: DateUtils.formatDateTime(summary.maxPayTime);
|
||
|
||
int updatedCount = completeUnsplitRecordMissingFields(startTime, endTime, 1000);
|
||
log.info("导入并补齐未分账数据完成, 导入统计:{}, 补齐更新:{}条", summary, updatedCount);
|
||
}
|
||
|
||
private static final int IMPORT_BATCH_SIZE = 500;
|
||
|
||
private ImportSummary importAdapayUnsplitRecord(Path filePath) {
|
||
ImportSummary summary = new ImportSummary();
|
||
DataFormatter formatter = new DataFormatter();
|
||
|
||
try (InputStream inputStream = Files.newInputStream(filePath);
|
||
Workbook workbook = WorkbookFactory.create(inputStream)) {
|
||
Sheet sheet = workbook.getSheetAt(0);
|
||
if (sheet == null) {
|
||
log.error("导入未分账数据失败，Excel没有sheet, file:{}", filePath.toAbsolutePath());
|
||
return summary;
|
||
}
|
||
|
||
Row headerRow = sheet.getRow(sheet.getFirstRowNum());
|
||
if (headerRow == null) {
|
||
log.error("导入未分账数据失败，Excel没有表头, file:{}", filePath.toAbsolutePath());
|
||
return summary;
|
||
}
|
||
|
||
Map<String, Integer> headerIndexMap = buildHeaderIndexMap(headerRow, formatter);
|
||
List<String> requiredHeaders = Lists.newArrayList(
|
||
"商户号", "支付时间", "交易流水号", "交易订单号", "交易订单金额", "已确认分账金额", "已撤销金额", "支付确认撤销金额", "剩余未分账金额"
|
||
);
|
||
for (String requiredHeader : requiredHeaders) {
|
||
if (!headerIndexMap.containsKey(normalizeHeader(requiredHeader))) {
|
||
log.error("导入未分账数据失败，缺少字段:{}, file:{}", requiredHeader, filePath.toAbsolutePath());
|
||
return summary;
|
||
}
|
||
}
|
||
|
||
int firstDataRow = sheet.getFirstRowNum() + 1;
|
||
int lastDataRow = sheet.getLastRowNum();
|
||
// 批量收集记录，每 IMPORT_BATCH_SIZE 条执行一次批量 upsert，减少数据库交互次数
|
||
List<AdapayUnsplitRecord> batch = new ArrayList<>(IMPORT_BATCH_SIZE);
|
||
for (int rowNum = firstDataRow; rowNum <= lastDataRow; rowNum++) {
|
||
Row row = sheet.getRow(rowNum);
|
||
if (row == null || isRowEmpty(row)) {
|
||
continue;
|
||
}
|
||
summary.totalRows++;
|
||
|
||
try {
|
||
AdapayUnsplitRecord record = convertRowToRecord(row, headerIndexMap, formatter);
|
||
if (record == null) {
|
||
summary.skippedRows++;
|
||
continue;
|
||
}
|
||
batch.add(record);
|
||
summary.updatePayTimeRange(record.getPayTime());
|
||
|
||
// 达到批量大小时执行一次批量写入
|
||
if (batch.size() >= IMPORT_BATCH_SIZE) {
|
||
adapayUnsplitRecordService.batchInsertOrUpdateSelective(batch);
|
||
summary.successRows += batch.size();
|
||
batch.clear();
|
||
}
|
||
} catch (Exception e) {
|
||
summary.failedRows++;
|
||
log.error("导入未分账数据失败, rowNum:{}, file:{}", rowNum + 1, filePath.toAbsolutePath(), e);
|
||
}
|
||
|
||
if (summary.totalRows % 1000 == 0) {
|
||
log.info("导入未分账数据进行中, total:{}, success:{}, skipped:{}, failed:{}",
|
||
summary.totalRows, summary.successRows, summary.skippedRows, summary.failedRows);
|
||
}
|
||
}
|
||
// 处理剩余不足一批的记录
|
||
if (!batch.isEmpty()) {
|
||
adapayUnsplitRecordService.batchInsertOrUpdateSelective(batch);
|
||
summary.successRows += batch.size();
|
||
}
|
||
} catch (Exception e) {
|
||
log.error("导入未分账数据失败, file:{}", filePath.toAbsolutePath(), e);
|
||
}
|
||
|
||
return summary;
|
||
}
|
||
|
||
private int completeUnsplitRecordMissingFields(String startTime, String endTime, int pageSize) {
|
||
int pageNum = 1;
|
||
int updatedCount = 0;
|
||
|
||
while (true) {
|
||
PageUtils.startPage(pageNum, pageSize);
|
||
List<AdapayUnsplitRecord> list = adapayUnsplitRecordService.queryUnsplitOrders(startTime, endTime);
|
||
if (CollectionUtils.isEmpty(list)) {
|
||
break;
|
||
}
|
||
|
||
Set<String> orderCodeSet = new HashSet<>();
|
||
for (AdapayUnsplitRecord record : list) {
|
||
if (StringUtils.isBlank(record.getOrderCode())) {
|
||
String extractedOrderCode = extractOrderCode(record.getOrderNo());
|
||
if (StringUtils.isNotBlank(extractedOrderCode)) {
|
||
record.setOrderCode(extractedOrderCode);
|
||
}
|
||
}
|
||
if (StringUtils.isNotBlank(record.getOrderCode())) {
|
||
orderCodeSet.add(record.getOrderCode());
|
||
}
|
||
}
|
||
|
||
Map<String, OrderBasicInfo> orderMap = new HashMap<>();
|
||
if (CollectionUtils.isNotEmpty(orderCodeSet)) {
|
||
List<OrderBasicInfo> orderList = orderBasicInfoService.selectOrderTemp(orderCodeSet);
|
||
orderMap = orderList.stream()
|
||
.collect(Collectors.toMap(OrderBasicInfo::getOrderCode, v -> v, (k1, k2) -> k1));
|
||
}
|
||
|
||
List<AdapayUnsplitRecord> updateList = new ArrayList<>();
|
||
Date now = DateUtils.getNowDate();
|
||
for (AdapayUnsplitRecord record : list) {
|
||
boolean needUpdate = false;
|
||
|
||
String orderCode = record.getOrderCode();
|
||
if (StringUtils.isBlank(orderCode)) {
|
||
orderCode = extractOrderCode(record.getOrderNo());
|
||
if (StringUtils.isNotBlank(orderCode)) {
|
||
record.setOrderCode(orderCode);
|
||
needUpdate = true;
|
||
}
|
||
}
|
||
|
||
if (StringUtils.isNotBlank(orderCode)) {
|
||
OrderBasicInfo orderBasicInfo = orderMap.get(orderCode);
|
||
if (orderBasicInfo != null) {
|
||
BigDecimal refundAmount = orderBasicInfo.getRefundAmount();
|
||
if (!isSameAmount(record.getDueRefundAmount(), refundAmount)) {
|
||
record.setDueRefundAmount(refundAmount);
|
||
needUpdate = true;
|
||
}
|
||
BigDecimal settleAmount = orderBasicInfo.getSettleAmount();
|
||
if (!isSameAmount(record.getSettleAmount(), settleAmount)) {
|
||
record.setSettleAmount(settleAmount);
|
||
needUpdate = true;
|
||
}
|
||
String pileType = YouDianUtils.isEBikePileSn(orderBasicInfo.getPileSn()) ? "eBike" : "EV";
|
||
if (!StringUtils.equals(record.getPileType(), pileType)) {
|
||
record.setPileType(pileType);
|
||
needUpdate = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (needUpdate) {
|
||
record.setUpdateTime(now);
|
||
updateList.add(record);
|
||
}
|
||
}
|
||
|
||
if (CollectionUtils.isNotEmpty(updateList)) {
|
||
adapayUnsplitRecordService.updateBatchSelective(updateList);
|
||
updatedCount += updateList.size();
|
||
}
|
||
|
||
if (list.size() < pageSize) {
|
||
break;
|
||
}
|
||
pageNum++;
|
||
}
|
||
|
||
return updatedCount;
|
||
}
|
||
|
||
private BigDecimal getLatestConfirmAmount(BigDecimal waitSplitAmount, String payAmount, String paymentId, String wechatAppId) {
|
||
BigDecimal confirmAmt = waitSplitAmount;
|
||
try {
|
||
QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
|
||
dto.setWechatAppId(wechatAppId);
|
||
dto.setPaymentId(paymentId);
|
||
QueryPaymentConfirmDetailResponse response = adapayService.queryPaymentConfirmList(dto);
|
||
BigDecimal latestRemaining = calculateLatestRemainingAmount(payAmount, response);
|
||
if (latestRemaining.compareTo(BigDecimal.ZERO) > 0) {
|
||
confirmAmt = waitSplitAmount.min(latestRemaining);
|
||
}
|
||
} catch (Exception e) {
|
||
log.warn("查询汇付确认金额异常，使用数据库待分账金额继续处理, paymentId:{}, waitSplitAmount:{}",
|
||
paymentId, waitSplitAmount, e);
|
||
}
|
||
return confirmAmt;
|
||
}
|
||
|
||
private BigDecimal calculateLatestRemainingAmount(String payAmount, QueryPaymentConfirmDetailResponse response) {
|
||
BigDecimal payAmt = parseAmount(payAmount);
|
||
if (payAmt.compareTo(BigDecimal.ZERO) <= 0 || response == null || CollectionUtils.isEmpty(response.getPaymentConfirms())) {
|
||
return payAmt;
|
||
}
|
||
|
||
BigDecimal maxConfirmedAmt = BigDecimal.ZERO;
|
||
BigDecimal maxReservedAmt = BigDecimal.ZERO;
|
||
List<PaymentConfirmInfo> confirms = response.getPaymentConfirms();
|
||
for (PaymentConfirmInfo confirm : confirms) {
|
||
BigDecimal confirmedAmt = parseAmount(confirm.getConfirmedAmt());
|
||
BigDecimal reservedAmt = parseAmount(confirm.getReservedAmt());
|
||
if (confirmedAmt.compareTo(maxConfirmedAmt) > 0) {
|
||
maxConfirmedAmt = confirmedAmt;
|
||
}
|
||
if (reservedAmt.compareTo(maxReservedAmt) > 0) {
|
||
maxReservedAmt = reservedAmt;
|
||
}
|
||
}
|
||
BigDecimal latestRemaining = payAmt.subtract(maxConfirmedAmt).subtract(maxReservedAmt);
|
||
return latestRemaining.compareTo(BigDecimal.ZERO) > 0 ? latestRemaining : BigDecimal.ZERO;
|
||
}
|
||
|
||
private void updateConfirmedSplitAmount(AdapayUnsplitRecordVO item, BigDecimal confirmAmt, String paymentId) {
|
||
BigDecimal oldConfirmedAmt = parseAmount(item.getConfirmedSplitAmount());
|
||
BigDecimal newConfirmedAmt = oldConfirmedAmt.add(confirmAmt).setScale(2, BigDecimal.ROUND_HALF_UP);
|
||
AdapayUnsplitRecord updateRecord = new AdapayUnsplitRecord();
|
||
updateRecord.setPaymentId(paymentId);
|
||
updateRecord.setConfirmedSplitAmount(newConfirmedAmt);
|
||
updateRecord.setUpdateTime(DateUtils.getNowDate());
|
||
adapayUnsplitRecordService.updateByPaymentIdSelective(updateRecord);
|
||
}
|
||
|
||
private void markSplitResult(String paymentId, String splitFlag, String splitRemark) {
|
||
AdapayUnsplitRecord updateRecord = new AdapayUnsplitRecord();
|
||
updateRecord.setPaymentId(paymentId);
|
||
updateRecord.setSplitFlag(splitFlag);
|
||
updateRecord.setSplitRemark(splitRemark);
|
||
updateRecord.setUpdateTime(DateUtils.getNowDate());
|
||
adapayUnsplitRecordService.updateByPaymentIdSelective(updateRecord);
|
||
}
|
||
|
||
private AdapayUnsplitRecord convertRowToRecord(Row row, Map<String, Integer> headerIndexMap, DataFormatter formatter) {
|
||
String paymentId = getCellString(row, headerIndexMap.get(normalizeHeader("交易流水号")), formatter);
|
||
if (StringUtils.isBlank(paymentId)) {
|
||
return null;
|
||
}
|
||
|
||
String orderNo = getCellString(row, headerIndexMap.get(normalizeHeader("交易订单号")), formatter);
|
||
Date payTime = parsePayTime(getCell(row, headerIndexMap.get(normalizeHeader("支付时间"))), formatter);
|
||
|
||
AdapayUnsplitRecord record = new AdapayUnsplitRecord();
|
||
record.setMerchantCode(getCellString(row, headerIndexMap.get(normalizeHeader("商户号")), formatter));
|
||
record.setPayTime(payTime);
|
||
record.setPaymentId(paymentId);
|
||
record.setOrderNo(orderNo);
|
||
record.setOrderCode(extractOrderCode(orderNo));
|
||
record.setPayAmount(getCellDecimal(row, headerIndexMap.get(normalizeHeader("交易订单金额")), formatter));
|
||
record.setConfirmedSplitAmount(getCellDecimal(row, headerIndexMap.get(normalizeHeader("已确认分账金额")), formatter));
|
||
record.setRefundAmount(getCellDecimal(row, headerIndexMap.get(normalizeHeader("已撤销金额")), formatter));
|
||
record.setPaymentRevokeAmount(getCellDecimal(row, headerIndexMap.get(normalizeHeader("支付确认撤销金额")), formatter));
|
||
record.setRemainingSplitAmount(getCellDecimal(row, headerIndexMap.get(normalizeHeader("剩余未分账金额")), formatter));
|
||
record.setUpdateTime(DateUtils.getNowDate());
|
||
return record;
|
||
}
|
||
|
||
private Map<String, Integer> buildHeaderIndexMap(Row headerRow, DataFormatter formatter) {
|
||
Map<String, Integer> headerIndexMap = new HashMap<>();
|
||
short firstCellNum = headerRow.getFirstCellNum();
|
||
short lastCellNum = headerRow.getLastCellNum();
|
||
if (firstCellNum < 0 || lastCellNum < 0) {
|
||
return headerIndexMap;
|
||
}
|
||
for (int cellIndex = firstCellNum; cellIndex < lastCellNum; cellIndex++) {
|
||
Cell cell = headerRow.getCell(cellIndex, Row.MissingCellPolicy.RETURN_BLANK_AS_NULL);
|
||
if (cell == null) {
|
||
continue;
|
||
}
|
||
String header = normalizeHeader(formatter.formatCellValue(cell));
|
||
if (StringUtils.isNotBlank(header)) {
|
||
headerIndexMap.put(header, cellIndex);
|
||
}
|
||
}
|
||
return headerIndexMap;
|
||
}
|
||
|
||
private String getCellString(Row row, Integer columnIndex, DataFormatter formatter) {
|
||
Cell cell = getCell(row, columnIndex);
|
||
if (cell == null) {
|
||
return null;
|
||
}
|
||
String value = formatter.formatCellValue(cell);
|
||
return StringUtils.isBlank(value) ? null : value.trim();
|
||
}
|
||
|
||
private Cell getCell(Row row, Integer columnIndex) {
|
||
if (row == null || columnIndex == null) {
|
||
return null;
|
||
}
|
||
return row.getCell(columnIndex, Row.MissingCellPolicy.RETURN_BLANK_AS_NULL);
|
||
}
|
||
|
||
private BigDecimal getCellDecimal(Row row, Integer columnIndex, DataFormatter formatter) {
|
||
String value = getCellString(row, columnIndex, formatter);
|
||
return parseAmount(value);
|
||
}
|
||
|
||
private Date parsePayTime(Cell cell, DataFormatter formatter) {
|
||
if (cell == null) {
|
||
return null;
|
||
}
|
||
if (cell.getCellType() == CellType.NUMERIC) {
|
||
return DateUtil.getJavaDate(cell.getNumericCellValue());
|
||
}
|
||
if (cell.getCellType() == CellType.FORMULA && cell.getCachedFormulaResultType() == CellType.NUMERIC) {
|
||
return DateUtil.getJavaDate(cell.getNumericCellValue());
|
||
}
|
||
|
||
String value = formatter.formatCellValue(cell);
|
||
if (StringUtils.isBlank(value)) {
|
||
return null;
|
||
}
|
||
Date date = DateUtils.parseDate(value.trim());
|
||
if (date != null) {
|
||
return date;
|
||
}
|
||
try {
|
||
return DateUtil.getJavaDate(Double.parseDouble(value.trim()));
|
||
} catch (Exception e) {
|
||
log.warn("解析支付时间失败，value:{}", value);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private String extractOrderCode(String orderNo) {
|
||
if (StringUtils.isBlank(orderNo)) {
|
||
return null;
|
||
}
|
||
int index = orderNo.indexOf("_");
|
||
String orderCode = index > 0 ? orderNo.substring(0, index) : orderNo;
|
||
// order_code 字段长度限制为 16，超长则无法匹配订单，返回 null
|
||
if (orderCode.length() >= 16) {
|
||
log.warn("order_code 字段长度超出限制，order_no:{}", orderNo);
|
||
}
|
||
return orderCode.length() <= 16 ? orderCode : null;
|
||
}
|
||
|
||
private String normalizeHeader(String header) {
|
||
return header == null ? "" : header.replace(" ", "").trim();
|
||
}
|
||
|
||
private boolean isSameAmount(BigDecimal left, BigDecimal right) {
|
||
if (left == null && right == null) {
|
||
return true;
|
||
}
|
||
if (left == null || right == null) {
|
||
return false;
|
||
}
|
||
return left.compareTo(right) == 0;
|
||
}
|
||
|
||
private BigDecimal parseAmount(String value) {
|
||
if (StringUtils.isBlank(value)) {
|
||
return BigDecimal.ZERO;
|
||
}
|
||
String normalizedValue = value.replace(",", "").trim();
|
||
try {
|
||
return new BigDecimal(normalizedValue);
|
||
} catch (NumberFormatException e) {
|
||
log.warn("解析数字失败，value:{}", value);
|
||
return BigDecimal.ZERO;
|
||
}
|
||
}
|
||
|
||
private boolean isRowEmpty(Row row) {
|
||
if (row == null) {
|
||
return true;
|
||
}
|
||
short firstCellNum = row.getFirstCellNum();
|
||
short lastCellNum = row.getLastCellNum();
|
||
if (firstCellNum < 0 || lastCellNum < 0) {
|
||
return true;
|
||
}
|
||
for (int i = firstCellNum; i < lastCellNum; i++) {
|
||
Cell cell = row.getCell(i, Row.MissingCellPolicy.RETURN_BLANK_AS_NULL);
|
||
if (cell == null) {
|
||
continue;
|
||
}
|
||
if (cell.getCellType() != CellType.BLANK) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private static class ImportSummary {
|
||
private int totalRows;
|
||
private int successRows;
|
||
private int skippedRows;
|
||
private int failedRows;
|
||
private Date minPayTime;
|
||
private Date maxPayTime;
|
||
|
||
private void updatePayTimeRange(Date payTime) {
|
||
if (payTime == null) {
|
||
return;
|
||
}
|
||
if (minPayTime == null || payTime.before(minPayTime)) {
|
||
minPayTime = payTime;
|
||
}
|
||
if (maxPayTime == null || payTime.after(maxPayTime)) {
|
||
maxPayTime = payTime;
|
||
}
|
||
}
|
||
|
||
@Override
|
||
public String toString() {
|
||
return "{"
|
||
+ "\"totalRows\":" + totalRows
|
||
+ ", \"successRows\":" + successRows
|
||
+ ", \"skippedRows\":" + skippedRows
|
||
+ ", \"failedRows\":" + failedRows
|
||
+ ", \"minPayTime\":\"" + (minPayTime == null ? "" : DateUtils.formatDateTime(minPayTime)) + "\""
|
||
+ ", \"maxPayTime\":\"" + (maxPayTime == null ? "" : DateUtils.formatDateTime(maxPayTime)) + "\""
|
||
+ "}";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* V1方法，获取退款金额与结算金额
|
||
* @param batchNum
|
||
*/
|
||
private void processUnSettledOrderV1(int batchNum) {
|
||
String startTime = "2025-01-01 00:00:00";
|
||
String endTime = "2025-12-31 23:59:59";
|
||
|
||
// 查询未分帐订单
|
||
PageUtils.startPage(1, 1000);
|
||
List<AdapayUnsplitRecord> list = adapayUnsplitRecordService.queryUnsplitOrders(startTime, endTime);
|
||
log.info("第{}批次，共查询到{}条数据", batchNum, list.size());
|
||
if (CollectionUtils.isEmpty(list)) {
|
||
return;
|
||
}
|
||
// 转为map, key:orderCode, value:AdapayUnsplitRecord
|
||
Map<String, AdapayUnsplitRecord> map = list.stream().collect(Collectors.toMap(AdapayUnsplitRecord::getOrderCode, v -> v, (k1, k2) -> k1));
|
||
|
||
// 取keySet
|
||
Set<String> orderCodes = map.keySet();
|
||
|
||
// 查询订单的退款金额与结算金额
|
||
List<OrderBasicInfo> orderList = orderBasicInfoService.selectOrderTemp(orderCodes);
|
||
// 转为map, key:orderCode, value:OrderBasicInfo
|
||
Map<String, OrderBasicInfo> orderMap = orderList.stream().collect(Collectors.toMap(OrderBasicInfo::getOrderCode, v -> v, (k1, k2) -> k1));
|
||
|
||
List<AdapayUnsplitRecord> updateList = new ArrayList<>();
|
||
//更新map
|
||
for (String orderCode : orderCodes) {
|
||
OrderBasicInfo orderBasicInfo = orderMap.get(orderCode);
|
||
if (Objects.isNull(orderBasicInfo)) {
|
||
// log.error("未查询到订单:{}", orderCode);
|
||
continue;
|
||
}
|
||
AdapayUnsplitRecord adapayUnsplitRecord = map.get(orderCode);
|
||
adapayUnsplitRecord.setDueRefundAmount(orderBasicInfo.getRefundAmount());
|
||
adapayUnsplitRecord.setSettleAmount(orderBasicInfo.getSettleAmount());
|
||
String pileSn = orderBasicInfo.getPileSn();
|
||
adapayUnsplitRecord.setPileType(YouDianUtils.isEBikePileSn(pileSn) ? "eBike" : "EV");
|
||
updateList.add(adapayUnsplitRecord);
|
||
}
|
||
adapayUnsplitRecordService.updateBatchSelective(updateList);
|
||
log.info("第{}批次，共更新{}条数据", batchNum, updateList.size());
|
||
}
|
||
|
||
/**
|
||
* 更新adapay_unsplit_record表, 去汇付查询最新的数据
|
||
* @param batchNum
|
||
*/
|
||
private void processUnSettledOrderV2(int batchNum) {
|
||
String startTime = "2025-01-01 00:00:00";
|
||
String endTime = "2025-12-31 23:59:59";
|
||
|
||
// 查询未分帐订单
|
||
PageUtils.startPage(1, 3);
|
||
List<AdapayUnsplitRecord> list = adapayUnsplitRecordService.queryUnsplitOrders(startTime, endTime);
|
||
|
||
// 根据paymentId去汇付查询最新数据
|
||
for (AdapayUnsplitRecord adapayUnsplitRecord : list) {
|
||
String paymentId = adapayUnsplitRecord.getPaymentId();
|
||
|
||
QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
|
||
dto.setWechatAppId(Constants.DEFAULT_APP_ID);
|
||
dto.setPaymentId(paymentId);
|
||
QueryPaymentConfirmDetailResponse response = adapayService.queryPaymentConfirmList(dto);
|
||
System.out.println(JSON.toJSONString(response));
|
||
}
|
||
}
|
||
|
||
public void updateOrderReview() {
|
||
LocalDate yesterday = DateUtils.getYesterday();
|
||
LocalDateTime start = yesterday.atStartOfDay();
|
||
LocalDateTime end = yesterday.atTime(23, 59, 59);
|
||
|
||
orderBasicInfoService.updateOrderReviewFlagTemp(start, end, null);
|
||
}
|
||
|
||
/**
|
||
* 批量归档过期优惠券（status=0 且 expire_time <= now 的记录更新为 status=2）
|
||
* jsowellTask.expireCoupons()
|
||
* Cron: 0 5 0 * * ?（每日 00:05 执行）
|
||
*/
|
||
public void expireCoupons() {
|
||
log.info("[expireCoupons] 开始归档过期优惠券...");
|
||
try {
|
||
int count = memberCouponService.batchExpire();
|
||
log.info("[expireCoupons] 归档完成，共归档 {} 张过期券", count);
|
||
} catch (Exception e) {
|
||
log.error("[expireCoupons] 归档过期券异常", e);
|
||
}
|
||
}
|
||
|
||
|
||
// private void processUnSettledOrderOld() {
|
||
// String startTime = "2023-01-01 00:00:00";
|
||
// String endTime = "2024-12-31 23:59:59";
|
||
//
|
||
// // 使用redis控制请求api
|
||
// Boolean setnx = redisCache.setnx(CacheConstants.PROCESS_UNSPLIT_ORDERS, Constants.ONE, 65);
|
||
// if (!setnx) {
|
||
// return;
|
||
// }
|
||
//
|
||
// // 查询未分帐订单
|
||
// PageUtils.startPage(1, 10);
|
||
// List<OrderUnsplitRecord> list = orderUnsplitRecordService.queryUnsplitOrders(startTime, endTime);
|
||
//
|
||
// log.info("处理未分帐订单start, 当前时间:{}, 查询出[{}]条未分账订单, 下面进行处理", DateUtils.getDateTime(), list.size());
|
||
// int count = 0;
|
||
// for (OrderUnsplitRecord orderUnsplitRecord : list) {
|
||
// String paymentId = orderUnsplitRecord.getPaymentId();
|
||
// String orderCode = orderUnsplitRecord.getOrderCode();
|
||
// BigDecimal confirmAmt = orderUnsplitRecord.getSettleAmount();
|
||
//
|
||
// DivMember divMember = new DivMember();
|
||
// divMember.setMemberId(Constants.ZERO); // 若是商户本身时，传入0
|
||
// divMember.setAmount(AdapayUtil.formatAmount(confirmAmt));
|
||
// divMember.setFeeFlag(Constants.Y);
|
||
//
|
||
// PaymentConfirmParam param = PaymentConfirmParam.builder()
|
||
// .paymentId(paymentId)
|
||
// .divMemberList(Lists.newArrayList(divMember))
|
||
// .confirmAmt(confirmAmt)
|
||
// .orderCode(orderCode)
|
||
// .wechatAppId(Constants.DEFAULT_APP_ID) // 默认使用万车充的appId
|
||
// .build();
|
||
// // 延时分账，使用确认交易API
|
||
// PaymentConfirmResponse paymentConfirmResponse = adapayService.createPaymentConfirmRequest(param);
|
||
//
|
||
// // 如果确认交易成功，则更新订单状态为已分账
|
||
// if (paymentConfirmResponse.isSuccess()) {
|
||
// count++;
|
||
// orderUnsplitRecord.setStatus(AdapayStatusEnum.SUCCEEDED.getValue());
|
||
// orderUnsplitRecordService.updateOrderUnsplitRecord(orderUnsplitRecord);
|
||
// log.info("processUnsplitOrders, 分账成功, paymentId:{}", paymentId);
|
||
// } else {
|
||
// // error_type:api_error, error_code:confirm_amt_over_limit, error_msg当前确认金额 > 支付金额 - 已支付确认金额 - 已支付撤销金额
|
||
// if (paymentConfirmResponse.getError_code().equals("confirm_amt_over_limit")) {
|
||
// // 查询paymentId的总分账金额
|
||
// BigDecimal totalSplitAmount;
|
||
// try {
|
||
// totalSplitAmount = adapayService.getTotalSplitAmountByPaymentId(paymentId);
|
||
// } catch (BaseAdaPayException e) {
|
||
// throw new RuntimeException(e);
|
||
// }
|
||
// if (totalSplitAmount.compareTo(confirmAmt) == 0) {
|
||
// // 如果总分账金额等于当前分账金额，则更新订单状态为已分账
|
||
// orderUnsplitRecord.setStatus(AdapayStatusEnum.SUCCEEDED.getValue());
|
||
// orderUnsplitRecordService.updateOrderUnsplitRecord(orderUnsplitRecord);
|
||
// log.info("processUnsplitOrders, 分账成功, paymentId:{}", paymentId);
|
||
// } else {
|
||
// log.info("processUnsplitOrders, 分账失败, paymentId:{}, 错误信息:{}", paymentId, paymentConfirmResponse.getError_msg());
|
||
// }
|
||
// }
|
||
//
|
||
// // error_type:invalid_request_error, error_code:payment_over_time_doing, error_msg:数据正在处理中，请稍后再试
|
||
// if (paymentConfirmResponse.getError_code().equals("payment_over_time_doing")) {
|
||
// log.info("processUnsplitOrders, 分账失败, paymentId:{}, 错误信息:{}", paymentId, paymentConfirmResponse.getError_msg());
|
||
// break;
|
||
// }
|
||
// // error_type:invalid_request_error, error_code:refund_repeate_request, error_msg:请求过于频繁
|
||
// if (paymentConfirmResponse.getError_code().equals("refund_repeate_request")) {
|
||
// log.info("processUnsplitOrders, 分账失败, paymentId:{}, 错误信息:{}", paymentId, paymentConfirmResponse.getError_msg());
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
// log.info("处理未分帐订单end, 当前时间:[{}], 成功分账[{}]条订单", DateUtils.getDateTime(), count);
|
||
// }
|
||
|
||
}
|