Merge branch 'dev' into feature-coupon

# Conflicts: # jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java
2026-06-15 04:39:50 +08:00 · 2026-03-13 10:05:41 +08:00
parent d5e58ba64c a94a755805
commit 5541538b4e
35 changed files with 1532 additions and 39 deletions
--- a/jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java
+++ b/jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java
@@ -2,8 +2,12 @@ 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;
@@ -23,18 +27,24 @@ 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.*;
@@ -422,6 +432,576 @@ public class JsowellTask {
        }
    }

+    /**
+     * 处理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");
+                    continue;
+                }
+
+                if (response != null && response.isSuccess()) {
+                    success++;
+                    updateConfirmedSplitAmount(item, confirmAmt, paymentId);
+                    markSplitResult(paymentId, "SUCCESS");
+                    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");
+                }
+            }
+
+            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 表中缺失字段（独立入口，可单独作为定时任务调用）
+     * 以指定时间范围内的未分账记录为目标，补齐 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.insertOrUpdateSelective(updateRecord);
+    }
+
+    private void markSplitResult(String paymentId, String splitFlag) {
+        AdapayUnsplitRecord updateRecord = new AdapayUnsplitRecord();
+        updateRecord.setPaymentId(paymentId);
+        updateRecord.setSplitFlag(splitFlag);
+        updateRecord.setUpdateTime(DateUtils.getNowDate());
+        adapayUnsplitRecordService.insertOrUpdateSelective(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