bugfix 首页数据查询超时

.gitignore

@@ -34,5 +34,6 @@ build/
 .mvn/
 /.claude/
 .ace-tool/
-opt/*
-
+opt/app/spring/logs/sys-error.log
+opt/app/spring/logs/sys-info.log
+opt/app/spring/logs/sys-user.log

docs/刷新FLAG.md

@@ -1,203 +0,0 @@
-## 需求概述
-
-针对 `adapay_unsplit_record` 表中的未分账/未退款记录，通过调用汇付（Adapay）API 查询最新的退款和分账数据，与本地数据库对比更新，并重新计算 `refund_flag` 和 `split_flag` 标识，确保数据一致性。
-
----
-
-## 数据模型
-
-### adapay_unsplit_record 表（核心字段）
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `id` | int | 主键 |
-| `payment_id` | varchar | 汇付支付对象ID（交易流水号） |
-| `order_code` | varchar | 订单编号 |
-| `order_no` | varchar | 交易订单号（汇付侧） |
-| `merchant_code` | varchar | 商户号 |
-| `pay_time` | datetime | 支付时间 |
-| `pay_amount` | decimal | 交易订单金额（支付金额） |
-| `settle_amount` | decimal | 结算金额（应分账金额，从订单表同步） |
-| `confirmed_split_amount` | decimal | 已确认分账金额（汇付实际已分账） |
-| `refund_amount` | decimal | 已撤销金额（汇付实际已退款） |
-| `due_refund_amount` | decimal | 应退金额（从订单表同步） |
-| `payment_revoke_amount` | decimal | 支付确认撤销金额（分账后又撤销） |
-| `remaining_split_amount` | decimal | 剩余未分账金额 |
-| `pile_type` | varchar | 桩类型（EV / eBike） |
-| **`refund_flag`** | varchar | **退款标识**（SUCCESS / PROCESSING / FAILED） |
-| **`split_flag`** | varchar | **分账标识**（SUCCESS / PROCESSING / FAILED） |
-| `update_time` | datetime | 更新时间 |
-
-> 实体类：`jsowell-pile/.../domain/AdapayUnsplitRecord.java`
-> 表只记录通过汇付支付的订单，`refund_flag` 和 `split_flag` 用于标识退款和分账是否已处理完成。
-
----
-
-## 汇付 API 查询（延时结算模式）
-
-> 所有订单均采用延时结算模式，无需处理实时结算模式。
-
-### 需要调用的 API
-
-| API | 方法 | 用途 |
-|-----|------|------|
-| 查询支付撤销对象列表 | `queryPaymentReverse(paymentId, wechatAppId)` | 获取已撤销/已退款金额 |
-| 查询支付确认对象列表 | `queryPaymentConfirmList(dto)` | 获取已确认分账金额、预留分账金额、剩余未分账金额 |
-| 查询支付对象详情 | `queryPaymentDetail(paymentId, wechatAppId)` | 获取支付对象完整信息 |
-
-> 服务类：`jsowell-pile/.../adapay/service/AdapayService.java`
-
-### API 返回的关键数据
-
-**支付撤销 API 返回（延时模式退款用）：**
-- `reverse_amt`：撤销金额（即退款金额）
-- `trans_status`：交易状态（pending / succeeded / failed）
-
-**支付确认列表 API 返回：**
-- `confirmed_amt`：已确认分账金额
-- `reserved_amt`：预留中金额（已发起但未确认）
-- 各分账对象的 `div_members`：分账成员及金额
-
----
-
-## 处理流程
-
-### 整体流程
-
-```
-取得 paymentId
-  │
-  ├─ 1. 调用汇付 API 查询最新数据
-  │     ├─ 查询支付撤销/退款 → 获取实际已退款金额
-  │     └─ 查询支付确认列表  → 获取实际已分账金额
-  │
-  ├─ 2. 与本地数据库对比更新
-  │     ├─ 对比 due_refund_amount（应退） vs refund_amount（实退）
-  │     ├─ 对比 settle_amount（应分） vs confirmed_split_amount（实分）
-  │     └─ 不一致则更新对应字段
-  │
-  └─ 3. 重新计算 refund_flag 和 split_flag
-        ├─ 退款标识：实际退款 >= 应退金额 → SUCCESS
-        ├─ 分账标识：实际分账 >= 应分金额 → SUCCESS
-        └─ 未达预期则标记 PROCESSING 或 FAILED
-```
-
-### 详细步骤
-
-#### 步骤 1：查询汇付最新数据
-
-1. **获取退款数据**：调用 `queryPaymentReverse`，查询该 `paymentId` 下所有支付撤销记录，汇总成功状态的撤销金额作为已退款金额
-2. **获取分账数据**：调用 `queryPaymentConfirmList`，获取所有分账确认对象的已确认金额和预留金额
-3. **获取剩余未分账金额**：`pay_amount - due_refund_amount - max(confirmed_amt) - max(reserved_amt)`
-
-#### 步骤 2：对比更新本地数据
-
-| 对比项 | 本地字段 | 汇付数据源 | 更新字段 |
-|--------|----------|------------|----------|
-| 应退金额 | `due_refund_amount` | 订单表 `refund_amount` | `due_refund_amount` |
-| 已退款金额 | `refund_amount` | 汇付退款/撤销 API汇总 | `refund_amount` |
-| 结算金额 | `settle_amount` | 订单表 `settle_amount` | `settle_amount` |
-| 已分账金额 | `confirmed_split_amount` | 汇付分账API汇总 | `confirmed_split_amount` |
-| 剩余未分账金额 | `remaining_split_amount` | 计算得出 | `remaining_split_amount` |
-
-> 仅在有差异时才更新，减少不必要的写库操作。
-
-#### 步骤 3：计算 flag 标识
-
-**flag 状态值：**
-
-| 值 | 含义 |
-|----|------|
-| `SUCCESS` | 处理完成（实际金额 >= 预期金额 或 预期金额 <= 0） |
-| `PROCESSING` | 处理中（已受理金额 >= 预期金额，但实际成功金额不足） |
-| `FAILED` | 处理失败（已受理金额 < 预期金额） |
-
-**退款标识计算：**
-```
-expected = due_refund_amount（应退金额）
-success  = 汇付实际成功退款金额
-accepted = 汇付已受理退款金额（成功 + 处理中）
-
-if expected <= 0 或 success >= expected → SUCCESS
-else if accepted >= expected → PROCESSING
-else → FAILED
-```
-
-**分账标识计算：**
-```
-expected = pay_amount - due_refund_amount（预期应分账金额）
-success  = 汇付实际已确认分账金额
-accepted = confirmed + reserved（已确认 + 预留中）
-
-if expected <= 0 或 success >= expected → SUCCESS
-else if accepted >= expected → PROCESSING
-else → FAILED
-```
-
----
-
-## 相关代码索引
-
-### 核心实现
-
-| 功能 | 文件路径 |
-|------|---------|
-| **flag 刷新主逻辑** | `jsowell-quartz/.../service/impl/AdapayUnsplitRecordHandleServiceImpl.java` |
-| 方法 `refreshUnsplitRecordHandleFlag()` | 第 532 行 — 核心刷新方法，查询汇付并对比更新 |
-| 方法 `calculateHandleFlag()` | 第 686 行 — flag 计算逻辑 |
-| 方法 `checkRefundAmount()` | 第 641 行 — 退款金额核对 |
-| 方法 `checkSplitAmount()` | 第 653 行 — 分账金额核对 |
-| 方法 `getRefundedAmount()` | 第 781 行 — 获取汇总退款金额 |
-
-### 汇付 API 调用
-
-| 功能 | 文件路径 |
-|------|---------|
-| **AdapayService** | `jsowell-pile/.../adapay/service/AdapayService.java` |
-| 查询支付撤销 | `queryPaymentReverse()` 第 1333 行 |
-| 查询退款列表 | `queryPaymentRefund()` 第 1417 行 |
-| 查询支付确认列表 | `queryPaymentConfirmList()` 第 1435 行 |
-| 查询支付详情 | `queryPaymentDetail()` 第 1351 行 |
-
-### 数据层
-
-| 功能 | 文件路径 |
-|------|---------|
-| **实体类** | `jsowell-pile/.../domain/AdapayUnsplitRecord.java` |
-| **Mapper XML** | `jsowell-pile/src/main/resources/mapper/pile/AdapayUnsplitRecordMapper.xml` |
-| **Service 接口** | `jsowell-pile/.../service/AdapayUnsplitRecordService.java` |
-| **VO 对象** | `jsowell-pile/.../vo/AdapayUnsplitRecordVO.java` |
-
-### 定时任务入口
-
-| 任务 | 文件路径 | 方法 |
-|------|---------|------|
-| 刷新 flag | `jsowell-quartz/.../task/JsowellTask.java` | — |
-| 处理未结算订单 | `AdapayUnsplitRecordHandleServiceImpl.java` | `processUnSettledOrder()` |
-| 补齐缺失字段 | `AdapayUnsplitRecordHandleServiceImpl.java` | `completeAdapayUnsplitRecordFields()` |
-
-### 订单退款服务
-
-| 功能 | 文件路径 |
-|------|---------|
-| 汇付退款 | `jsowell-pile/.../service/impl/OrderBasicInfoServiceImpl.java` → `refundOrderWithAdapay()` |
-| 退款信息查询 | `OrderBasicInfoServiceImpl.java` → `getOrderRefundInfoList()` |
-
----
-
-## 注意事项
-
-1. **统一模式**：所有订单均为延时结算模式，退款通过 `queryPaymentReverse`（支付撤销）处理，分账通过 `queryPaymentConfirmList` / `createPaymentConfirmRequest` 处理
-2. **触发时机**：该流程通常在定时任务中批量执行，也可针对单个 `paymentId` 手动触发
-3. **幂等性**：通过 `insertOrUpdateSelective` 保证更新幂等，重复执行不会产生脏数据
-4. **分账前置条件**：有应退金额时，必须先确认退款足额成功才能继续分账
-5. **金额精度**：所有金额计算使用 `BigDecimal`，保留 2 位小数，四舍五入
-6. **API 限流**：批量处理时注意汇付 API 调用频率限制
-
----
-
-## 汇付 API 文档
-
-- 查询支付撤销对象列表：https://docs.adapay.tech/api/trade.html#id76
-- 查询支付确认对象列表：https://docs.adapay.tech/api/trade.html#id62
-- 汇付开发文档首页：https://docs.adapay.tech/api/introduce.html

docs/汇付开户V2流程计划.md

@@ -1,456 +0,0 @@
-# 汇付开户 V2 流程与落地计划
-
-## 背景
-
-现有开户页已经从旧组件切到了 `jsowell-charge-ui/src/views/financial/accountUserInfo.vue`，但整体仍偏向“资料展示 + 操作按钮”。新版开户流程需要按汇付官方账户体系重新梳理为状态驱动的流程，明确个人用户、企业用户、结算账户三个对象之间的关系。
-
-官方文档来源：
-
-- 个人用户：<https://docs.adapay.tech/api/trade.html#member-create>
-- 企业用户：<https://docs.adapay.tech/api/trade.html#corpmember>
-- 结算账户：<https://docs.adapay.tech/api/trade.html#settle-account-create>
-
-## 官方约束摘要
-
-### 个人用户 Member
-
-- 创建用户对象用于将商户侧 `member_id` 与 Adapay 系统关联，`member_id` 需在同一个 `app_id` 下唯一。
-- 创建成功后可创建结算账户，用于用户分账。
-- 若创建用户对象用于分账功能，官方文档说明 `tel_no`、`user_name`、`cert_type`、`cert_id` 不应上送。
-- 当前项目个人开户只上送 `location`、`email`、`gender`、`nickname`，符合分账场景的轻量开户模型。
-
-### 企业用户 CorpMember
-
-- 创建企业用户对象本质是提交企业开户申请，同步返回 `pending` 表示申请已受理。
-- 企业开户结果由异步通知返回。审核成功后企业用户创建成功；审核失败后可根据失败原因重新提交。
-- 企业开户若同时上送 `bank_code`、`bank_acct_type`、`card_no`、`card_name`，审核成功后汇付会自动创建结算账户。
-- 若企业开户未上送银行要素，不会自动创建结算账户，需要后续单独调用结算账户创建接口。
-- 企业更新同样同步返回 `pending`，审核结果通过异步通知返回。
-- 企业更新不支持修改银行代码、银行账户类型、银行卡号、银行卡开户姓名。结算账户信息变更应先删除结算账户，再使用原 `member_id` 重新创建。
-
-### 结算账户 SettleAccount
-
-- 结算账户用于承接用户分账金额结算，目前仅支持银行卡。
-- 创建对私结算账户时会校验银行卡号、银行卡开户姓名、身份证号三要素。
-- 结算账户由汇付生成唯一 `id`，用于查询和删除。
-- 银行账户类型为 `2-对私` 时，建议绑定 I 类银行卡，否则单次结算超过 10000 元可能失败。
-- 22:30 后创建成功的结算账户，结算会延后一个结算日。
-- 更新银行卡必须删除原结算账户后重新创建，且需与原结算账户使用的身份证和银行卡户名保持一致。
-
-## V2 产品流程
-
-### 页面入口
-
-入口保持不变：
-
-- 路由：`/financial/merchant/index/:merchantId`
-- 页面：`jsowell-charge-ui/src/views/financial/accountUserInfo.vue`
-
-页面进入后只关心一个业务状态：当前运营商的汇付开户进度。
-
-### 状态机
-
-| V2 状态 | 来源判断 | 页面主状态 | 允许操作 |
-| --- | --- | --- | --- |
-| `NONE` | 无有效 `adapay_member_account` | 未开户 | 创建个人用户、创建企业用户 |
-| `PERSONAL_OPENED_NO_SETTLE` | 个人用户已创建，未查询到结算账户 | 个人已开户，待创建结算账户 | 更新个人资料、创建对私结算账户 |
-| `PERSONAL_COMPLETED` | 个人用户已创建，且存在结算账户 | 个人开户完成 | 更新个人资料、查看/删除结算账户 |
-| `CORP_AUDITING` | 企业用户提交后，汇付 `audit_state=A` 或本地状态待审核 | 企业审核中 | 刷新、查看资料 |
-| `CORP_FAILED` | 汇付 `audit_state=B/C` 或本地状态失败 | 企业开户失败 | 查看失败原因、重新提交企业开户 |
-| `CORP_OPENED_NO_SETTLE` | 企业 `audit_state=D`，或企业审核通过但无结算账户 | 企业已开户，待创建结算账户 | 更新企业资料、创建对公结算账户 |
-| `CORP_COMPLETED` | 企业 `audit_state=E` 或存在结算账户 | 企业开户完成 | 更新企业资料、查看/删除结算账户 |
-
-企业审核状态沿用项目已有枚举：
-
-| 汇付 `audit_state` | 含义 | V2 归类 |
-| --- | --- | --- |
-| `A` | 待审核 | `CORP_AUDITING` |
-| `B` | 审核失败 | `CORP_FAILED` |
-| `C` | 开户失败 | `CORP_FAILED` |
-| `D` | 开户成功但未创建结算账户 | `CORP_OPENED_NO_SETTLE` |
-| `E` | 开户和创建结算账户成功 | `CORP_COMPLETED` |
-
-### 用户可见流程
-
-```mermaid
-flowchart TD
-  A["进入开户页"] --> B["查询开户聚合详情"]
-  B --> C{"是否已开户"}
-  C -->|否| D["选择个人/企业开户"]
-  D -->|个人| E["提交个人资料"]
-  E --> F["个人开户成功"]
-  F --> G["创建对私结算账户"]
-  G --> H["开户完成"]
-  D -->|企业| I["提交企业资料和附件"]
-  I --> J["企业审核中"]
-  J --> K{"审核结果"}
-  K -->|失败| L["展示失败原因并重新提交"]
-  L --> J
-  K -->|成功| M["创建对公结算账户"]
-  M --> H
-  C -->|是| N["按状态展示下一步动作"]
-```
-
-## 字段映射
-
-### 个人用户创建
-
-当前接口：
-
-- 前端：`createAdapayMember`
-- 后端：`POST /adapay/member/createAdapayMember`
-- DTO：`CreatePersonalMemberDTO`
-- 汇付 SDK：`Member.create`
-
-| 页面字段 | 后端 DTO | 汇付字段 | 必填 | 说明 |
-| --- | --- | --- | --- | --- |
-| 运营商 ID | `merchantId` | 不直接传汇付 | Y | 后端根据运营商查询 `wechatAppId` 和 `app_id` |
-| 昵称 | `nickname` | `nickname` | N | 当前页面设为必填，便于运营识别 |
-| 性别 | `gender` | `gender` | N | 取值 `MALE` / `FEMALE` |
-| 邮箱 | `email` | `email` | N | 当前页面校验邮箱格式 |
-| 地址 | `location` | `location` | N | 当前页面设为必填 |
-| 汇付会员 ID | 后端生成 | `member_id` | Y | 当前使用 `Constants.ADAPAY_MEMBER_PREFIX + IdUtils.getMemberId()` |
-| 应用 ID | 后端配置 | `app_id` | Y | 从 `AdapayConfigFactory` 获取 |
-
-V2 处理原则：
-
-- 保持轻量个人开户，不新增实名字段。
-- 个人用户创建成功后，本地 `adapay_member_account.status` 记为成功。
-- 页面下一步引导创建对私结算账户。
-
-### 企业用户创建
-
-当前接口：
-
-- 前端：`createCorpMember`
-- 后端：`POST /adapay/member/createCorpMember`
-- DTO：`CreateCorpMemberDTO`
-- 汇付 SDK：`CorpMember.create`
-
-| 页面字段 | 后端 DTO | 汇付字段 | 必填 | 说明 |
-| --- | --- | --- | --- | --- |
-| 运营商 ID | `merchantId` | 不直接传汇付 | Y | 后端根据运营商查询配置 |
-| 企业名称 | `name` | `name` | Y | 长度不超过 50 |
-| 省份编码 | `provCode` | `prov_code` | Y | 四位省市编码 |
-| 地区编码 | `areaCode` | `area_code` | Y | 四位省市编码 |
-| 统一社会信用码 | `socialCreditCode` | `social_credit_code` | Y | 长度 18 |
-| 统一社会信用证有效期 | `socialCreditCodeExpires` | `social_credit_code_expires` | Y | `YYYYMMDD` |
-| 经营范围 | `businessScope` | `business_scope` | Y | 长度不超过 200 |
-| 法人姓名 | `legalPerson` | `legal_person` | Y | 长度不超过 20 |
-| 法人身份证号 | `legalCertId` | `legal_cert_id` | Y | 长度不超过 20 |
-| 法人身份证有效期 | `legalCertIdExpires` | `legal_cert_id_expires` | Y | `YYYYMMDD` |
-| 法人手机号 | `legalMp` | `legal_mp` | Y | 11 位手机号 |
-| 企业地址 | `address` | `address` | Y | 长度不超过 256 |
-| 邮编 | `zipCode` | `zip_code` | N | 长度 6 |
-| 企业电话 | `telphone` | `telphone` | N | 长度不超过 30 |
-| 企业邮箱 | `email` | `email` | N | 长度不超过 40 |
-| 附件列表 | `imgList` | `attach_file` | Y | 后端压缩为 zip 上传，最大 9 MB |
-| 汇付会员 ID | 后端生成 | `member_id` | Y | 当前使用 `Constants.ADAPAY_CORP_MEMBER_PREFIX + IdUtils.getMemberId()` |
-| 请求订单号 | 后端生成 | `order_no` | Y | 需保证同 `app_id` 下唯一 |
-| 异步通知地址 | 后端配置 | `notify_url` | N | 当前使用 `ADAPAY_CALLBACK_URL` |
-
-企业附件要求：
-
-| 附件 | 当前页面 upload key | 汇付要求 |
-| --- | --- | --- |
-| 法人身份证正面 | `idCardFace` | 法人身份证正面照 |
-| 法人身份证反面 | `idCardBack` | 法人身份证反面照 |
-| 开户许可证 | `bankLicense` | 开户银行许可证照 |
-| 营业执照 | `businessLicense` | 三证合一证件照 |
-
-V2 处理原则：
-
-- 企业开户阶段不随开户上送银行字段，避免审核成功后自动创建结算账户，统一改为审核通过后手动创建结算账户。
-- 提交成功后页面展示“审核中”，不提示开户完成。
-- 异步回调成功后再进入“待创建结算账户”或“已完成”状态。
-
-### 结算账户创建
-
-当前接口：
-
-- 前端：`createSettleAccount`
-- 后端：`POST /adapay/member/createSettleAccount`
-- DTO：`CreateSettleAccountDTO`
-- 汇付 SDK：`SettleAccount.create`
-
-| 页面字段 | 后端 DTO | 汇付字段 | 必填 | 说明 |
-| --- | --- | --- | --- | --- |
-| 运营商 ID | `merchantId` | 不直接传汇付 | Y | 后端查询当前汇付会员 |
-| 账户类型 | `bankAcctType` | `account_info.bank_acct_type` | Y | `1-对公`，`2-对私` |
-| 银行卡号 | `cardId` | `account_info.card_id` | Y | 当前后端同时保留 `cardNo`，V2 统一使用 `cardId` |
-| 户名 | `cardName` | `account_info.card_name` | Y | 对公时必须与企业名称一致 |
-| 身份证号 | `certId` | `account_info.cert_id` | 对私必填 | 对私三要素认证使用 |
-| 证件类型 | `certType` | `account_info.cert_type` | N | 默认 `00-身份证` |
-| 手机号 | `telNo` | `account_info.tel_no` | Y | 银行预留手机号 |
-| 银行编码 | `bankCode` | `account_info.bank_code` | Y | 取银行编码列表 |
-| 省份编码 | `provCode` | `account_info.prov_code` | Y | 开户银行省份 |
-| 地区编码 | `areaCode` | `account_info.area_code` | Y | 开户银行地区 |
-| 渠道 | 后端固定 | `channel` | Y | 固定 `bank_account` |
-| 汇付会员 ID | 后端查询 | `member_id` | Y | 当前运营商绑定的汇付会员 |
-| 应用 ID | 后端配置 | `app_id` | Y | 从汇付配置获取 |
-
-V2 处理原则：
-
-- 个人用户默认创建 `2-对私` 结算账户。
-- 企业用户默认创建 `1-对公` 结算账户。
-- 按官方 account_info 字段说明，V2 前端应收集 `bankCode`、`provCode`、`areaCode`，包括对私账户也建议保留，减少生产环境参数不完整风险。
-- 创建前后端都校验“当前会员不能已有结算账户”。
-
-### 企业用户更新
-
-当前接口：
-
-- 前端：`updateAdapayMember`
-- 后端：`POST /adapay/member/updateAdapayMember`
-- DTO：`UpdateCorpMemberDTO`
-- 汇付功能号：`corp_members.update`
-
-| 页面字段 | 汇付字段 | 必填 | V2 说明 |
-| --- | --- | --- | --- |
-| 企业基础信息 | `name`、`prov_code`、`area_code`、`business_scope` 等 | N | 仅用于企业资料变更 |
-| 法人信息 | `legal_person`、`legal_cert_id`、`legal_cert_id_expires`、`legal_mp` | N | 更新后进入审核流程 |
-| 附件 | `attach_file` | N | 当前实现要求重新上传四张附件；V2 可继续要求，降低资料不一致风险 |
-| 通知地址 | `notify_url` | N | 建议补齐，确保更新审核结果也能回调 |
-
-V2 处理原则：
-
-- 企业资料更新不处理银行卡信息。
-- 若要换银行卡，走“删除结算账户 -> 重新创建结算账户”流程。
-- 企业更新提交成功后页面进入 `CORP_AUDITING`，等待回调或主动刷新。
-
-### 个人用户更新
-
-当前接口：
-
-- 前端：`updateAdapayMember`
-- 后端根据 `adapayMemberId` 前缀判断后调用 `Member.update`
-
-| 页面字段 | 汇付字段 | V2 说明 |
-| --- | --- | --- |
-| 昵称 | `nickname` | 保留 |
-| 性别 | `gender` | 保留 |
-| 邮箱 | `email` | 保留 |
-| 地址 | `location` | 保留 |
-
-V2 处理原则：
-
-- 个人更新不改变开户状态。
-- 若未来引入禁用用户，需单独设计 `disabled` 操作，不混入普通资料更新。
-
-## 后端落地计划
-
-### 1. 新增 V2 聚合响应模型
-
-建议新增：
-
-- `AdapayMemberOpenV2VO`
-- `AdapayOpenStatusEnum`
-- `AdapayOpenActionEnum`
-
-响应结构建议：
-
-```json
-{
-  "merchantId": "1",
-  "status": "CORP_OPENED_NO_SETTLE",
-  "memberType": "CORP",
-  "adapayMemberId": "ACM29102732",
-  "auditState": "D",
-  "auditDesc": "",
-  "settleAccountStatus": "NONE",
-  "primaryAction": "CREATE_SETTLE_ACCOUNT",
-  "actions": [
-    "REFRESH",
-    "UPDATE_CORP_MEMBER",
-    "CREATE_SETTLE_ACCOUNT"
-  ],
-  "member": {},
-  "settleAccount": null,
-  "tips": []
-}
-```
-
-### 2. 新增 V2 查询接口
-
-建议新增接口，不破坏现有页面调用：
-
-- `POST /adapay/member/v2/detail`
-
-职责：
-
-- 查询 `adapay_member_account` 当前有效记录。
-- 判断个人/企业用户类型。
-- 查询汇付会员详情。
-- 查询结算账户详情。
-- 汇总 V2 状态、主操作、可用动作、提示信息。
-
-### 3. 状态计算集中到后端
-
-当前前端通过 `memberType`、`auditState`、`settleAccountList` 自行判断，V2 改为后端统一计算。
-
-建议规则：
-
-- 无本地记录：`NONE`
-- 个人 + 无结算账户：`PERSONAL_OPENED_NO_SETTLE`
-- 个人 + 有结算账户：`PERSONAL_COMPLETED`
-- 企业 + `audit_state=A`：`CORP_AUDITING`
-- 企业 + `audit_state=B/C` 或本地 `status=2`：`CORP_FAILED`
-- 企业 + `audit_state=D` 或审核通过但无结算账户：`CORP_OPENED_NO_SETTLE`
-- 企业 + `audit_state=E` 或有结算账户：`CORP_COMPLETED`
-
-### 4. 本地表状态增强
-
-当前 `adapay_member_account.status` 只有：
-
-- `0` 待审核
-- `1` 审核通过
-- `2` 创建失败
-
-V2 建议新增字段，避免只靠 `remark` 存失败信息：
-
-```sql
-alter table adapay_member_account
-  add column audit_state varchar(8) null comment '汇付企业审核状态 A/B/C/D/E',
-  add column audit_desc varchar(512) null comment '汇付企业审核说明',
-  add column last_order_no varchar(64) null comment '最近一次企业开户/更新请求订单号';
-```
-
-兼容策略：
-
-- 不强制迁移历史数据。
-- 查询时优先使用汇付实时查询结果。
-- 若汇付查询失败，再使用本地 `status`、`remark` 兜底。
-
-### 5. 企业回调更新
-
-现有回调处理在 `OrderService.corpMemberFailed`、`OrderService.corpMemberSucceeded`。
-
-V2 调整：
-
-- 成功回调：写入 `audit_state`、`audit_desc`、`status=1`。
-- 失败回调：写入 `audit_state`、`audit_desc`、`status=2`。
-- 若回调中包含结算账户 ID，同步写入 `settle_account_id`。
-- 清理 `ADAPAY_MEMBER_ACCOUNT + merchantId` 缓存。
-
-### 6. 创建/更新动作校验
-
-后端服务层统一校验：
-
-- `CREATE_PERSONAL_MEMBER`：仅 `NONE` 可执行。
-- `CREATE_CORP_MEMBER`：仅 `NONE` 或 `CORP_FAILED` 可执行。
-- `UPDATE_PERSONAL_MEMBER`：仅个人已开户状态可执行。
-- `UPDATE_CORP_MEMBER`：仅企业非审核中状态可执行。
-- `CREATE_SETTLE_ACCOUNT`：仅已开户且无结算账户可执行；企业必须非审核中、非失败。
-- `DELETE_SETTLE_ACCOUNT`：仅已有结算账户可执行，且需确认不会影响未结算分账。
-
-## 前端落地计划
-
-### 1. API 封装
-
-在 `jsowell-charge-ui/src/api/adapayMember/adapayMember.js` 增加：
-
-```js
-export function getAdapayOpenDetailV2(data) {
-  return request({
-    url: '/adapay/member/v2/detail',
-    method: 'post',
-    data
-  })
-}
-```
-
-### 2. 页面结构
-
-`accountUserInfo.vue` 调整为：
-
-1. 顶部状态总览：显示当前 V2 状态、汇付会员 ID、审核状态、结算账户状态。
-2. 流程步骤条：未开户、提交资料、审核、结算账户、完成。
-3. 主操作区：只渲染后端返回的 `primaryAction` 和 `actions`。
-4. 会员资料区：个人/企业按字段分组展示。
-5. 结算账户区：独立展示，包含删除后重建提示。
-6. 失败原因区：企业失败时展示 `auditDesc`，并给出重新提交入口。
-
-### 3. 表单调整
-
-个人开户表单：
-
-- 昵称
-- 性别
-- 邮箱
-- 地址
-
-企业开户表单：
-
-- 企业主体
-- 法人信息
-- 联系信息
-- 附件上传
-
-结算账户表单：
-
-- 账户类型
-- 银行卡号
-- 户名
-- 身份证号
-- 手机号
-- 银行编码
-- 省份/地区
-
-### 4. 交互规则
-
-- 状态由后端响应驱动，前端不再手写复杂判断。
-- 企业审核中：禁用更新、结算账户创建、重复提交。
-- 企业失败：主按钮为“重新提交企业开户”。
-- 企业成功但无结算账户：主按钮为“创建对公结算账户”。
-- 个人无结算账户：主按钮为“创建对私结算账户”。
-- 结算账户删除前提示：删除后支付分账将不可用，需重新创建后恢复。
-
-## 分阶段实施清单
-
-### 阶段一：后端状态与接口
-
-- [ ] 新增 `AdapayOpenStatusEnum`、`AdapayOpenActionEnum`。
-- [ ] 新增 V2 聚合 VO。
-- [ ] 新增 `/adapay/member/v2/detail` 接口。
-- [ ] 在 `AdapayService` 中增加状态计算方法。
-- [ ] 后端统一动作校验，避免前端绕过状态限制。
-
-### 阶段二：企业审核状态持久化
-
-- [ ] 新增数据库字段 `audit_state`、`audit_desc`、`last_order_no`。
-- [ ] 更新 `AdapayMemberAccount` domain、mapper、XML。
-- [ ] 调整企业创建、企业更新逻辑，记录 `last_order_no`。
-- [ ] 调整回调处理，写入审核状态和说明。
-- [ ] 清理相关 Redis 缓存。
-
-### 阶段三：前端 V2 页面
-
-- [ ] 新增 V2 聚合查询 API。
-- [ ] 改造 `accountUserInfo.vue` 数据源为 V2 detail。
-- [ ] 增加状态步骤条和主操作区。
-- [ ] 按 `actions` 渲染按钮。
-- [ ] 调整结算账户表单，补齐银行编码、省份、地区采集。
-- [ ] 企业失败态展示审核说明并支持重新提交。
-
-### 阶段四：回归与联调
-
-- [ ] 无开户记录 -> 创建个人用户 -> 创建对私结算账户。
-- [ ] 无开户记录 -> 创建企业用户 -> 审核中展示。
-- [ ] 企业审核失败 -> 展示失败原因 -> 重新提交。
-- [ ] 企业审核成功但无结算账户 -> 创建对公结算账户。
-- [ ] 已有结算账户 -> 禁止重复创建。
-- [ ] 删除结算账户 -> 重新创建结算账户。
-- [ ] 个人资料更新后刷新展示一致。
-- [ ] 企业资料更新后进入审核中，回调后状态正确。
-
-## 需要确认的问题
-
-1. 企业开户 V2 是否确定不使用汇付“开户时自动创建结算账户”的能力？本计划建议不使用，统一手动创建，流程更清晰。
-回答：确定不使用。
-2. 企业资料更新后是否必须重新上传四张附件？官方为非必填，但当前系统要求重传；本计划建议继续重传。
-回答：确定继续重传。
-3. 个人结算账户是否也强制填写银行编码、省份、地区？官方 account_info 字段说明为非空字段，本计划建议 V2 补齐采集。
-回答：确定补齐采集。
-4. 删除结算账户前是否需要校验未结算分账/在途提现？本计划建议后续补一层业务校验。
-回答：需要校验 。
-

docs/汇付开户流程优化.md

@@ -1,41 +0,0 @@
-# 汇付开户流程优化
-原来的开户流程不够清晰易用，现在打算重新理一遍逻辑，开发出汇付开户V2版本，下面我列一下基本逻辑以及需求
-
-## 创建用户
-汇付的用户分两个类型，个人用户和企业用户
-
-个人用户为对私的，不需要审核
-
-企业用户为对公的，需要审核
-
-### 个人用户
-文档地址：https://docs.adapay.tech/api/trade.html#member-create
-#### 创建个人用户对象
-创建用户对象用于将商户 member_id 与 Adapay 系统做关联，商户需要保证 member_id 在应用 app_id 下唯一。关联完成后， 可以创建结算账户用于用户分账功能。
-
-注：若历史已创建结算账户成功的 member_id，则可以直接使用收银台对象功能。
-
-### 企业用户
-文档地址：https://docs.adapay.tech/api/trade.html#corpmember
-#### 创建企业用户对象
-创建企业用户对象是将商户 member_id 与 Adapay 系统做关联，商户需要保证 member_id 在应用 id 下唯一。 创建企业用户对象实际是发起企业用户申请，同步返回 pending 状态表示申请已受理，人工审核后，审核成功或失败结果会 异步消息通知 告知。
-
-审核成功，则创建企业用户对象成功；审核失败，您可根据审核失败原因修改对应要素，重新调用创建企业用户对象发起申请。
-
-创建企业用户对象若上送了银行代码、银行账户类型、银行卡号、银行卡开户姓名要素时，人工审核成功后，Adapay 系统自动创建企业用户结算账户对象；若未上送，则不会自动创建结算账户对象，但您可调用创建结算账户对象单独创建结算账户。
-
-注：当银行账户类型为2-对私时，请务必绑定一张 Ⅰ类 银行卡，若绑定了一张 Ⅱ类 银行卡时，当结算金额超过10000元时，银行会提示金额超限导致结算失败。
-
-### 结算账户
-#### 创建结算账户对象
-创建结算账户对象是为一个已创建用户对象创建结算账户，用于对用户分账金额的结算，目前仅支持绑定银行卡结算账户。
-
-用户创建对私结算账户时，会对银行卡号、银行卡开户姓名、身份证号三要素认证，若认证失败，则创建结算账户失败。
-
-每个结算账户对象 Adapay 系统会生成一个唯一的 id，可用于查询结算账户对象，或者删除结算账户对象。
-
-注：当银行账户类型为2-对私时，请务必绑定一张 Ⅰ类 银行卡，若绑定了一张 Ⅱ类 银行卡时，当结算金额超过10000元时，银行会提示金额超限导致结算失败。
-
-注：若创建结算账户对象是在22：30分之后创建成功的，那么该用户的结算会延后一个结算日结算；若是在22：30分之前，用户会正常结算。
-
-注：若用户想更新银行卡，则需要先调用删除结算账户对象，再使用原 member_id 重新创建结算账户对象，且必须与原创建结算账户使用的身份证和银行卡户名保持一致。

jsowell-admin/src/test/java/PaymentTestController.java

@@ -46,7 +46,6 @@ import com.jsowell.pile.service.AdapayUnsplitRecordService;
 import com.jsowell.pile.service.OrderBasicInfoService;
 import com.jsowell.pile.service.OrderUnsplitRecordService;
 import com.jsowell.pile.vo.AdapayUnsplitRecordVO;
-import com.jsowell.quartz.service.AdapayUnsplitRecordHandleService;
 import org.apache.commons.collections4.CollectionUtils;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -86,9 +85,6 @@ public class PaymentTestController {
     @Autowired
     private OrderUnsplitRecordService orderUnsplitRecordService;
 
-    @Autowired
-    private AdapayUnsplitRecordHandleService adapayUnsplitRecordHandleService;
-
     @Autowired
     private AdapayService adapayService;
 
@@ -149,37 +145,6 @@ public class PaymentTestController {
         return list;
     }
 
-
-
-    /**
-     * 批量分账
-     */
-    @Test
-    public void processUnsplitRecordToDefaultMemberTest() {
-        adapayUnsplitRecordHandleService.processUnsplitRecordToDefaultMember(wechatAppId1, 2000);
-    }
-
-    /**
-     * 校验是否已经退款和分账
-     */
-    @Test
-    public void refreshAdapayUnsplitRecordHandleFlagTest() {
-        String startTime = "2025-01-11 06:51:00";
-        String endTime = "2026-01-29 09:28:00";
-        // adapayUnsplitRecordHandleService.refreshAdapayUnsplitRecordHandleFlag(startTime, endTime, wechatAppId1, null);
-
-        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(startTime, endTime, wechatAppId1, null);
-    }
-
-    /**
-     * 校验是否已经退款和分账
-     */
-    @Test
-    public void refreshAdapayUnsplitRecordHandleFlagTestV2() {
-        String paymentId = "002212026021922271410870565370037276672";
-        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId1);
-    }
-
     /**
      * 提现方法
      *

jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/NotDelayMerchantProgramLogic.java

@@ -19,7 +19,6 @@ import com.jsowell.common.core.domain.ykc.TransactionRecordsData;
 import com.jsowell.common.enums.AcquirerEnum;
 import com.jsowell.common.enums.DelFlagEnum;
 import com.jsowell.common.enums.MemberWalletEnum;
-import com.jsowell.common.enums.adapay.AdapayStatusEnum;
 import com.jsowell.common.enums.adapay.MerchantDelayModeEnum;
 import com.jsowell.common.enums.ykc.*;
 import com.jsowell.common.exception.BusinessException;
@@ -717,14 +716,6 @@ public class NotDelayMerchantProgramLogic extends AbstractProgramLogic {
                 refundInfo.setReverseId(refund.getRefund_id());
                 refundInfo.setPaymentId(refund.getPayment_id());
                 refundInfo.setReverseAmt(refund.getRefund_amt());
-                String transStatus = refund.getTrans_status();
-                if (StringUtils.equalsIgnoreCase("S", transStatus)) {
-                    refundInfo.setStatus(AdapayStatusEnum.SUCCEEDED.getValue());
-                } else if (StringUtils.equalsIgnoreCase("F", transStatus)) {
-                    refundInfo.setStatus(AdapayStatusEnum.FAILED.getValue());
-                } else {
-                    refundInfo.setStatus(AdapayStatusEnum.PENDING.getValue());
-                }
                 // LocalDateTime createdTime = DateUtils.timestampToDatetime(Long.parseLong(refund.getCreated_time()));
                 // refundInfo.setCreatedTime(DateUtils.formatDateTime(createdTime));
                 // LocalDateTime succeedTime = DateUtils.timestampToDatetime(Long.parseLong(refund.getSucceed_time()));

jsowell-pile/src/main/resources/mapper/pile/AdapayUnsplitRecordMapper.xml

@@ -750,15 +750,13 @@
       pay_amount as payAmount,
       settle_amount as settleAmount,
       confirmed_split_amount as confirmedSplitAmount,
-      GREATEST(0, IFNULL(pay_amount, 0) - IFNULL(due_refund_amount, 0) - IFNULL(confirmed_split_amount, 0)) AS waitSplitAmount,
+      GREATEST(0, settle_amount - confirmed_split_amount - payment_revoke_amount) AS waitSplitAmount,
       due_refund_amount as refundAmount,
       refund_amount as paidAmount,
-      GREATEST(0, IFNULL(due_refund_amount, 0) - IFNULL(refund_amount, 0)) AS refundPayAmount
+      GREATEST(0, due_refund_amount - refund_amount) AS refundPayAmount
     FROM adapay_unsplit_record
     WHERE
-<!--      (refund_flag IS NULL OR refund_flag != 'SUCCESS')-->
-<!--       OR (split_flag IS NULL OR split_flag != 'SUCCESS')-->
-    refund_flag IS NULL OR split_flag IS NULL
-    order by pay_time
+      (settle_amount > confirmed_split_amount - payment_revoke_amount)
+       OR (due_refund_amount > refund_amount)
   </select>
-</mapper>
+</mapper>

jsowell-pile/src/main/resources/mapper/pile/PileBasicInfoMapper.xml

@@ -400,10 +400,10 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 
     <select id="getGeneralSituationInfo" resultType="com.jsowell.pile.vo.web.IndexGeneralSituationVO">
         select
-            t1.total_amount as totalChargingAmount,
-            t1.settle_amount as totalSettleAmount,
-            t1.use_electricity as totalChargingDegree,
-            t1.charge_num as totalChargingQuantity
+            ifnull(sum(t1.total_amount), 0) as totalChargingAmount,
+            ifnull(sum(t1.settle_amount), 0) as totalSettleAmount,
+            ifnull(sum(t1.use_electricity), 0) as totalChargingDegree,
+            ifnull(sum(t1.charge_num), 0) as totalChargingQuantity
         from
             settle_order_report t1
         where
@@ -418,6 +418,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                 #{item}
             </foreach>
         </if>
+        group by t1.station_id
     </select>
 
     <select id="getMaxNumPileInfo" resultMap="PileBasicInfoResult">

jsowell-quartz/src/main/java/com/jsowell/quartz/service/AdapayUnsplitRecordHandleService.java

@@ -1,20 +0,0 @@
-package com.jsowell.quartz.service;
-
-public interface AdapayUnsplitRecordHandleService {
-
-    void processUnsplitRecordToDefaultMember();
-
-    void processUnsplitRecordToDefaultMember(String wechatAppId, Integer pageSize);
-
-    void importAdapayUnsplitRecordAndCompleteFields();
-
-    void importAdapayUnsplitRecordAndCompleteFields(String filePath);
-
-    int completeAdapayUnsplitRecordFields(String startTime, String endTime);
-
-    void processUnSettledOrder();
-
-    int syncAndRefreshFlagsFromAdapay(String paymentId, String wechatAppId);
-
-    int syncAndRefreshFlagsFromAdapay(String startTime, String endTime, String wechatAppId, Integer pageSize);
-}

jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java

@@ -1,8 +1,16 @@
 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;
@@ -10,16 +18,21 @@ import com.jsowell.common.enums.SoftwareProtocolEnum;
 import com.jsowell.common.enums.thirdparty.ThirdPlatformTypeEnum;
 import com.jsowell.common.enums.ykc.PileChannelEntity;
 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.*;
-import com.jsowell.pile.domain.ykcCommond.ProofreadTimeCommand;
+import com.jsowell.pile.domain.AdapayUnsplitRecord;
+import com.jsowell.pile.domain.OrderBasicInfo;
+import com.jsowell.pile.domain.PileBasicInfo;
+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.ProofreadTimeCommand;
 import com.jsowell.pile.domain.ykcCommond.StartChargingCommand;
 import com.jsowell.pile.service.*;
+import com.jsowell.pile.vo.AdapayUnsplitRecordVO;
 import com.jsowell.pile.vo.base.StationInfoVO;
 import com.jsowell.pile.vo.web.BillingTemplateVO;
-import com.jsowell.quartz.service.AdapayUnsplitRecordHandleService;
 import com.jsowell.thirdparty.amap.service.AMapService;
 import com.jsowell.thirdparty.common.NotificationDTO;
 import com.jsowell.thirdparty.common.NotificationService;
@@ -30,7 +43,11 @@ 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.*;
@@ -81,7 +98,7 @@ public class JsowellTask {
     // private OrderUnsplitRecordService orderUnsplitRecordService;
 
     @Autowired
-    private AdapayUnsplitRecordHandleService adapayUnsplitRecordHandleService;
+    private AdapayUnsplitRecordService adapayUnsplitRecordService;
 
     private static final long YKC_DAILY_TIMECHECK_INTERVAL_MILLIS = 200L;
 
@@ -484,7 +501,11 @@ public class JsowellTask {
      * jsowellTask.processUnSettledOrder()
      */
     public void processUnSettledOrder() {
-        adapayUnsplitRecordHandleService.processUnSettledOrder();
+        // processUnSettledOrderOld(); // 旧方法
+        for (int i = 0; i < 35; i++) {
+            int batchNum = i + 1;
+            processUnSettledOrderV2(batchNum); // 新方法
+        }
     }
 
     /**
@@ -493,7 +514,7 @@ public class JsowellTask {
      * jsowellTask.processUnsplitRecordToDefaultMember()
      */
     public void processUnsplitRecordToDefaultMember() {
-        adapayUnsplitRecordHandleService.processUnsplitRecordToDefaultMember();
+        processUnsplitRecordToDefaultMember(Constants.DEFAULT_APP_ID, 500);
     }
 
     /**
@@ -501,7 +522,85 @@ public class JsowellTask {
      * jsowellTask.processUnsplitRecordToDefaultMember(wechatAppId, pageSize)
      */
     public void processUnsplitRecordToDefaultMember(String wechatAppId, Integer pageSize) {
-        adapayUnsplitRecordHandleService.processUnsplitRecordToDefaultMember(wechatAppId, 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);
     }
 
     /**
@@ -515,7 +614,7 @@ public class JsowellTask {
      * jsowellTask.importAdapayUnsplitRecordAndCompleteFields()
      */
     public void importAdapayUnsplitRecordAndCompleteFields() {
-        adapayUnsplitRecordHandleService.importAdapayUnsplitRecordAndCompleteFields();
+        importAdapayUnsplitRecordAndCompleteFields("doc/万车充小程序-未分账明细.xlsx");
     }
 
     /**
@@ -525,24 +624,8 @@ public class JsowellTask {
      * 示例：jsowellTask.completeAdapayUnsplitRecordFields('2024-01-01 00:00:00', '2025-12-31 23:59:59')
      */
     public void completeAdapayUnsplitRecordFields(String startTime, String endTime) {
-        adapayUnsplitRecordHandleService.completeAdapayUnsplitRecordFields(startTime, endTime);
-    }
-
-    /**
-     * 按 paymentId 从汇付同步并刷新 adapay_unsplit_record 的退款/分账标识
-     * jsowellTask.syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId)
-     */
-    public void syncAndRefreshFlagsFromAdapay(String paymentId, String wechatAppId) {
-        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
-    }
-
-    /**
-     * 批量从汇付同步并刷新 adapay_unsplit_record 的退款/分账标识
-     * jsowellTask.syncAndRefreshFlagsFromAdapay(startTime, endTime, wechatAppId, pageSize)
-     * 示例：jsowellTask.syncAndRefreshFlagsFromAdapay('2024-01-01 00:00:00', '2025-12-31 23:59:59', 'app_id', 500)
-     */
-    public void syncAndRefreshFlagsFromAdapay(String startTime, String endTime, String wechatAppId, Integer pageSize) {
-        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(startTime, endTime, wechatAppId, pageSize);
+        int updatedCount = completeUnsplitRecordMissingFields(startTime, endTime, 1000);
+        log.info("补齐未分账数据缺失字段完成, startTime:{}, endTime:{}, 更新:{}条", startTime, endTime, updatedCount);
     }
 
     /**
@@ -555,7 +638,565 @@ public class JsowellTask {
      * jsowellTask.importAdapayUnsplitRecordAndCompleteFields(文件路径)
      */
     public void importAdapayUnsplitRecordAndCompleteFields(String filePath) {
-        adapayUnsplitRecordHandleService.importAdapayUnsplitRecordAndCompleteFields(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) {
+                        flushImportBatch(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()) {
+                flushImportBatch(batch);
+                summary.successRows += batch.size();
+            }
+        } catch (Exception e) {
+            log.error("导入未分账数据失败, file:{}", filePath.toAbsolutePath(), e);
+        }
+
+        return summary;
+    }
+
+    /**
+     * 写入一批导入数据：以 paymentId 为业务唯一键，
+     *   - 数据库已存在相同 paymentId 的记录 -> 沿用其主键 id 走 updateBatchSelective 更新
+     *   - 数据库不存在的 -> 走 batchInsert 新增
+     * 同一批内若出现重复 paymentId，仅保留最后一条（与文件读取顺序一致）
+     */
+    private void flushImportBatch(List<AdapayUnsplitRecord> batch) {
+        if (CollectionUtils.isEmpty(batch)) {
+            return;
+        }
+
+        // 同批内按 paymentId 去重，保留最后一条
+        Map<String, AdapayUnsplitRecord> uniqueByPaymentId = new LinkedHashMap<>();
+        for (AdapayUnsplitRecord record : batch) {
+            if (StringUtils.isNotBlank(record.getPaymentId())) {
+                uniqueByPaymentId.put(record.getPaymentId(), record);
+            }
+        }
+        if (uniqueByPaymentId.isEmpty()) {
+            return;
+        }
+
+        List<String> paymentIds = new ArrayList<>(uniqueByPaymentId.keySet());
+        List<AdapayUnsplitRecord> existingList = adapayUnsplitRecordService.selectByPaymentIds(paymentIds);
+        Map<String, Integer> existingIdMap = new HashMap<>();
+        if (CollectionUtils.isNotEmpty(existingList)) {
+            for (AdapayUnsplitRecord existing : existingList) {
+                existingIdMap.put(existing.getPaymentId(), existing.getId());
+            }
+        }
+
+        List<AdapayUnsplitRecord> insertList = new ArrayList<>();
+        List<AdapayUnsplitRecord> updateList = new ArrayList<>();
+        for (AdapayUnsplitRecord record : uniqueByPaymentId.values()) {
+            Integer existingId = existingIdMap.get(record.getPaymentId());
+            if (existingId != null) {
+                record.setId(existingId);
+                updateList.add(record);
+            } else {
+                insertList.add(record);
+            }
+        }
+
+        if (!insertList.isEmpty()) {
+            adapayUnsplitRecordService.batchInsert(insertList);
+        }
+        if (!updateList.isEmpty()) {
+            adapayUnsplitRecordService.updateBatchSelective(updateList);
+        }
+    }
+
+    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
+     */
+    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() {
@@ -566,4 +1207,82 @@ public class JsowellTask {
         orderBasicInfoService.updateOrderReviewFlagTemp(start, end, null, null);
     }
 
+
+    // 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);
+    // }
+
 }