Merge branch 'dev' of codeup.aliyun.com:67c68d4e484ca2f0a13ac3c1/ydc/jsowell-charger-web into dev

# Conflicts:
#	jsowell-quartz/src/main/java/com/jsowell/quartz/service/impl/AdapayUnsplitRecordHandleServiceImpl.java

.gitignore

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

docs/刷新FLAG.md

@@ -0,0 +1,203 @@
+## 需求概述
+
+针对 `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

@@ -0,0 +1,456 @@
+# 汇付开户 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

@@ -0,0 +1,41 @@
+# 汇付开户流程优化
+原来的开户流程不够清晰易用，现在打算重新理一遍逻辑，开发出汇付开户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

@@ -156,7 +156,7 @@ public class PaymentTestController {
      */
     @Test
     public void processUnsplitRecordToDefaultMemberTest() {
-        adapayUnsplitRecordHandleService.processUnsplitRecordToDefaultMember(wechatAppId1, 20);
+        adapayUnsplitRecordHandleService.processUnsplitRecordToDefaultMember(wechatAppId1, 2000);
     }
 
     /**
@@ -166,7 +166,9 @@ public class PaymentTestController {
     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.refreshAdapayUnsplitRecordHandleFlag(startTime, endTime, wechatAppId1, null);
+
+        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(startTime, endTime, wechatAppId1, null);
     }
 
     /**
@@ -174,8 +176,8 @@ public class PaymentTestController {
      */
     @Test
     public void refreshAdapayUnsplitRecordHandleFlagTestV2() {
-        String paymentId = "002212025100717133810821564090057555968";
-        adapayUnsplitRecordHandleService.refreshAdapayUnsplitRecordHandleFlag(paymentId, wechatAppId1);
+        String paymentId = "002212026021922271410870565370037276672";
+        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId1);
     }
 
     /**

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

@@ -756,7 +756,9 @@
       GREATEST(0, IFNULL(due_refund_amount, 0) - IFNULL(refund_amount, 0)) 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 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
   </select>
 </mapper>

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

@@ -12,9 +12,9 @@ public interface AdapayUnsplitRecordHandleService {
 
     int completeAdapayUnsplitRecordFields(String startTime, String endTime);
 
-    int refreshAdapayUnsplitRecordHandleFlag(String paymentId, String wechatAppId);
-
-    int refreshAdapayUnsplitRecordHandleFlag(String startTime, String endTime, String wechatAppId, Integer pageSize);
-
     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/service/impl/AdapayUnsplitRecordHandleServiceImpl.java

@@ -7,11 +7,11 @@ import com.jsowell.adapay.common.PaymentConfirmInfo;
 import com.jsowell.adapay.dto.PaymentConfirmParam;
 import com.jsowell.adapay.dto.QueryPaymentConfirmDTO;
 import com.jsowell.adapay.response.PaymentConfirmResponse;
+import com.jsowell.adapay.response.PaymentReverseResponse;
 import com.jsowell.adapay.response.QueryPaymentConfirmDetailResponse;
 import com.jsowell.adapay.service.AdapayService;
 import com.jsowell.common.YouDianUtils;
 import com.jsowell.common.constant.Constants;
-import com.jsowell.common.enums.adapay.AdapayStatusEnum;
 import com.jsowell.common.util.DateUtils;
 import com.jsowell.common.util.PageUtils;
 import com.jsowell.common.util.StringUtils;
@@ -21,17 +21,9 @@ import com.jsowell.pile.dto.ApplyRefundDTO;
 import com.jsowell.pile.service.AdapayUnsplitRecordService;
 import com.jsowell.pile.service.OrderBasicInfoService;
 import com.jsowell.pile.vo.AdapayUnsplitRecordVO;
-import com.jsowell.pile.vo.web.OrderDetailInfoVO;
 import com.jsowell.quartz.service.AdapayUnsplitRecordHandleService;
 import org.apache.commons.collections4.CollectionUtils;
-import org.apache.poi.ss.usermodel.Cell;
-import org.apache.poi.ss.usermodel.CellType;
-import org.apache.poi.ss.usermodel.DataFormatter;
-import org.apache.poi.ss.usermodel.DateUtil;
-import org.apache.poi.ss.usermodel.Row;
-import org.apache.poi.ss.usermodel.Sheet;
-import org.apache.poi.ss.usermodel.Workbook;
-import org.apache.poi.ss.usermodel.WorkbookFactory;
+import org.apache.poi.ss.usermodel.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -42,26 +34,22 @@ import java.math.BigDecimal;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 @Service
 public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecordHandleService {
 
     private static final int IMPORT_BATCH_SIZE = 500;
-    private static final int REFUND_WAIT_MAX_ATTEMPTS = 12;
+    private static final int REFUND_WAIT_MAX_ATTEMPTS = 2;
     private static final long REFUND_WAIT_INTERVAL_MILLIS = 5000L;
+    private static final int SYNC_THREAD_POOL_SIZE = 10;
     private static final String HANDLE_FLAG_SUCCESS = "SUCCESS";
     private static final String HANDLE_FLAG_PROCESSING = "PROCESSING";
     private static final String HANDLE_FLAG_FAILED = "FAILED";
 
+    private final ExecutorService syncExecutor = Executors.newFixedThreadPool(SYNC_THREAD_POOL_SIZE);
+
     private final Logger log = LoggerFactory.getLogger(AdapayUnsplitRecordHandleServiceImpl.class);
 
     @Autowired
@@ -90,10 +78,10 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
     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;
+        AtomicInteger total = new AtomicInteger(0);
+        AtomicInteger success = new AtomicInteger(0);
+        AtomicInteger skipped = new AtomicInteger(0);
+        AtomicInteger failed = new AtomicInteger(0);
 
         while (true) {
             PageUtils.startPage(pageNum, size);
@@ -103,77 +91,31 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
             }
 
             log.info("处理未分账数据到默认账户, pageNum:{}, pageSize:{}, 当前页:{}条", pageNum, size, list.size());
-            for (AdapayUnsplitRecordVO item : list) {
-                total++;
-                String paymentId = item.getPaymentId();
-                String orderCode = item.getOrderCode();
-                // queryList 中 refundAmount 映射的是 due_refund_amount，即订单应退款金额。
-                BigDecimal dueRefundAmount = parseAmount(item.getRefundAmount());
-                BigDecimal waitSplitAmount = parseAmount(item.getWaitSplitAmount());
 
-                if (StringUtils.isBlank(paymentId) || StringUtils.isBlank(orderCode)) {
-                    skipped++;
-                    continue;
-                }
+            List<CompletableFuture<ItemResult>> futures = list.stream()
+                    .map(item -> CompletableFuture.supplyAsync(
+                            () -> processOneItem(item, wechatAppId), syncExecutor))
+                    .collect(Collectors.toList());
 
-                // 有应退款金额时，必须先确认退款已足额成功；未退足会先发起差额退款并等待，未足额则本轮不分账。
-                if (dueRefundAmount.compareTo(BigDecimal.ZERO) > 0 && !ensureRefundBeforeSplit(item, wechatAppId)) {
-                    refreshHandleFlagQuietly(paymentId, wechatAppId);
-                    skipped++;
-                    continue;
-                }
-
-                if (waitSplitAmount.compareTo(BigDecimal.ZERO) <= 0) {
-                    refreshHandleFlagQuietly(paymentId, wechatAppId);
-                    skipped++;
-                    continue;
-                }
-
-                BigDecimal confirmAmt = getLatestConfirmAmount(waitSplitAmount, item.getPayAmount(), item.getRefundAmount(), paymentId, wechatAppId);
-                if (confirmAmt.compareTo(BigDecimal.ZERO) <= 0) {
-                    refreshHandleFlagQuietly(paymentId, wechatAppId);
-                    skipped++;
-                    continue;
-                }
-
-                PaymentConfirmResponse response;
+            for (CompletableFuture<ItemResult> future : futures) {
                 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);
+                    ItemResult result = future.get();
+                    total.incrementAndGet();
+                    switch (result) {
+                        case SUCCESS:
+                            success.incrementAndGet();
+                            break;
+                        case SKIPPED:
+                            skipped.incrementAndGet();
+                            break;
+                        case FAILED:
+                            failed.incrementAndGet();
+                            break;
+                    }
                 } catch (Exception e) {
-                    failed++;
-                    log.error("处理未分账数据到默认账户异常, paymentId:{}, orderCode:{}, confirmAmt:{}",
-                            paymentId, orderCode, confirmAmt, e);
-                    markSplitResult(paymentId, HANDLE_FLAG_FAILED);
-                    refreshHandleFlagQuietly(paymentId, wechatAppId);
-                    continue;
-                }
-
-                if (response != null && response.isSuccess()) {
-                    success++;
-                    updateConfirmedSplitAmount(item, confirmAmt, paymentId);
-                    refreshHandleFlagQuietly(paymentId, wechatAppId);
-                    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, HANDLE_FLAG_FAILED);
-                    refreshHandleFlagQuietly(paymentId, wechatAppId);
+                    failed.incrementAndGet();
+                    total.incrementAndGet();
+                    log.warn("处理未分账数据异常", e);
                 }
             }
 
@@ -184,7 +126,72 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
         }
 
         log.info("处理未分账数据到默认账户结束, total:{}, success:{}, skipped:{}, failed:{}",
-                total, success, skipped, failed);
+                total.get(), success.get(), skipped.get(), failed.get());
+    }
+
+    private enum ItemResult {SUCCESS, SKIPPED, FAILED}
+
+    private ItemResult processOneItem(AdapayUnsplitRecordVO item, String wechatAppId) {
+        String paymentId = item.getPaymentId();
+        String orderCode = item.getOrderCode();
+        BigDecimal dueRefundAmount = parseAmount(item.getRefundAmount());
+        BigDecimal waitSplitAmount = parseAmount(item.getWaitSplitAmount());
+
+        if (StringUtils.isBlank(paymentId) || StringUtils.isBlank(orderCode)) {
+            return ItemResult.SKIPPED;
+        }
+
+        if (dueRefundAmount.compareTo(BigDecimal.ZERO) > 0 && !ensureRefundBeforeSplit(item, wechatAppId)) {
+            syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
+            return ItemResult.SKIPPED;
+        }
+
+        if (waitSplitAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
+            return ItemResult.SKIPPED;
+        }
+
+        BigDecimal confirmAmt = getLatestConfirmAmount(waitSplitAmount, item.getPayAmount(), item.getRefundAmount(), paymentId, wechatAppId);
+        if (confirmAmt.compareTo(BigDecimal.ZERO) <= 0) {
+            syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
+            return ItemResult.SKIPPED;
+        }
+
+        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) {
+            log.error("处理未分账数据到默认账户异常, paymentId:{}, orderCode:{}, confirmAmt:{}",
+                    paymentId, orderCode, confirmAmt, e);
+            syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
+            return ItemResult.FAILED;
+        }
+
+        if (response != null && response.isSuccess()) {
+            log.info("处理未分账数据成功, paymentId:{}, orderCode:{}, 本次分账金额:{}, response:{}",
+                    paymentId, orderCode, confirmAmt, JSON.toJSONString(response));
+            syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
+            return ItemResult.SUCCESS;
+        } else {
+            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);
+            syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
+            return ItemResult.FAILED;
+        }
     }
 
     @Override
@@ -228,23 +235,24 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
     }
 
     @Override
-    public int refreshAdapayUnsplitRecordHandleFlag(String paymentId, String wechatAppId) {
+    public int syncAndRefreshFlagsFromAdapay(String paymentId, String wechatAppId) {
         if (StringUtils.isBlank(paymentId)) {
             return 0;
         }
         List<AdapayUnsplitRecord> list = adapayUnsplitRecordService.selectByPaymentIds(Lists.newArrayList(paymentId));
         if (CollectionUtils.isEmpty(list)) {
-            log.warn("刷新未分账处理标识失败，记录不存在, paymentId:{}", paymentId);
+            log.warn("同步刷新未分账记录失败，记录不存在, paymentId:{}", paymentId);
             return 0;
         }
-        return refreshUnsplitRecordHandleFlag(list, StringUtils.isBlank(wechatAppId) ? Constants.DEFAULT_APP_ID : wechatAppId);
+        String appId = StringUtils.isBlank(wechatAppId) ? Constants.DEFAULT_APP_ID : wechatAppId;
+        return doSyncAndRefresh(list.get(0), appId) ? 1 : 0;
     }
 
     @Override
-    public int refreshAdapayUnsplitRecordHandleFlag(String startTime, String endTime, String wechatAppId, Integer pageSize) {
+    public int syncAndRefreshFlagsFromAdapay(String startTime, String endTime, String wechatAppId, Integer pageSize) {
         int size = pageSize == null || pageSize <= 0 ? 1000 : pageSize;
         int pageNum = 1;
-        int updatedCount = 0;
+        AtomicInteger updatedCount = new AtomicInteger(0);
         String appId = StringUtils.isBlank(wechatAppId) ? Constants.DEFAULT_APP_ID : wechatAppId;
 
         while (true) {
@@ -254,15 +262,209 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
                 break;
             }
 
-            updatedCount += refreshUnsplitRecordHandleFlag(list, appId);
+            List<CompletableFuture<Boolean>> futures = list.stream()
+                    .map(record -> CompletableFuture.supplyAsync(
+                            () -> doSyncAndRefresh(record, appId), syncExecutor))
+                    .collect(Collectors.toList());
+
+            for (CompletableFuture<Boolean> future : futures) {
+                try {
+                    if (Boolean.TRUE.equals(future.get())) {
+                        updatedCount.incrementAndGet();
+                    }
+                } catch (Exception e) {
+                    log.warn("同步刷新未分账记录异常", e);
+                }
+            }
+
             if (list.size() < size) {
                 break;
             }
             pageNum++;
         }
 
-        log.info("刷新未分账处理标识完成, startTime:{}, endTime:{}, 更新:{}条", startTime, endTime, updatedCount);
-        return updatedCount;
+        int total = updatedCount.get();
+        log.info("同步刷新未分账记录完成, startTime:{}, endTime:{}, 更新:{}条", startTime, endTime, total);
+        return total;
+    }
+
+    private boolean doSyncAndRefresh(AdapayUnsplitRecord record, String wechatAppId) {
+        if (record == null || StringUtils.isBlank(record.getPaymentId())) {
+            return false;
+        }
+
+        String paymentId = record.getPaymentId();
+        String orderCode = record.getOrderCode();
+        if (StringUtils.isBlank(orderCode)) {
+            orderCode = extractOrderCode(record.getOrderNo());
+            if (StringUtils.isNotBlank(orderCode)) {
+                record.setOrderCode(orderCode);
+            }
+        }
+
+        boolean needUpdate = false;
+
+        RefundAmountResult refundResult = queryRefundAmountFromAdapay(paymentId, wechatAppId);
+        SplitAmountResult splitResult = querySplitAmountFromAdapay(paymentId, wechatAppId);
+
+        if (StringUtils.isNotBlank(orderCode)) {
+            OrderBasicInfo orderBasicInfo = orderBasicInfoService.getOrderInfoByOrderCode(orderCode);
+            if (orderBasicInfo != null) {
+                BigDecimal orderDueRefund = defaultAmount(orderBasicInfo.getRefundAmount());
+                if (!isSameAmount(record.getDueRefundAmount(), orderDueRefund)) {
+                    record.setDueRefundAmount(orderDueRefund);
+                    needUpdate = true;
+                }
+                BigDecimal orderSettle = defaultAmount(orderBasicInfo.getSettleAmount());
+                if (!isSameAmount(record.getSettleAmount(), orderSettle)) {
+                    record.setSettleAmount(orderSettle);
+                    needUpdate = true;
+                }
+                String pileType = YouDianUtils.isEBikePileSn(orderBasicInfo.getPileSn()) ? "eBike" : "EV";
+                if (!StringUtils.equals(record.getPileType(), pileType)) {
+                    record.setPileType(pileType);
+                    needUpdate = true;
+                }
+            }
+        }
+
+        if (!isSameAmount(record.getRefundAmount(), refundResult.refundedAmount)) {
+            record.setRefundAmount(refundResult.refundedAmount);
+            needUpdate = true;
+        }
+        if (!isSameAmount(record.getConfirmedSplitAmount(), splitResult.confirmedSplitAmount)) {
+            record.setConfirmedSplitAmount(splitResult.confirmedSplitAmount);
+            needUpdate = true;
+        }
+        BigDecimal remaining = calculateRemainingSplitAmount(
+                defaultAmount(record.getPayAmount()),
+                defaultAmount(record.getDueRefundAmount()),
+                splitResult.confirmedSplitAmount,
+                splitResult.reservedSplitAmount);
+        if (!isSameAmount(record.getRemainingSplitAmount(), remaining)) {
+            record.setRemainingSplitAmount(remaining);
+            needUpdate = true;
+        }
+
+        BigDecimal dueRefundAmount = defaultAmount(record.getDueRefundAmount());
+        String refundFlag = calculateHandleFlag(dueRefundAmount, refundResult.refundedAmount, refundResult.acceptedRefundAmount);
+        if (!StringUtils.equals(record.getRefundFlag(), refundFlag)) {
+            record.setRefundFlag(refundFlag);
+            needUpdate = true;
+        }
+
+        BigDecimal expectedSplitAmount = defaultAmount(record.getPayAmount()).subtract(dueRefundAmount)
+                .setScale(2, BigDecimal.ROUND_HALF_UP);
+        if (expectedSplitAmount.compareTo(BigDecimal.ZERO) < 0) {
+            expectedSplitAmount = BigDecimal.ZERO;
+        }
+        BigDecimal acceptedSplitAmount = splitResult.confirmedSplitAmount.add(splitResult.reservedSplitAmount);
+        String splitFlag = calculateHandleFlag(expectedSplitAmount, splitResult.confirmedSplitAmount, acceptedSplitAmount);
+        if (!StringUtils.equals(record.getSplitFlag(), splitFlag)) {
+            record.setSplitFlag(splitFlag);
+            needUpdate = true;
+        }
+
+        if (needUpdate) {
+            record.setUpdateTime(DateUtils.getNowDate());
+            adapayUnsplitRecordService.insertOrUpdateSelective(record);
+            log.info("同步刷新未分账记录, paymentId:{}, orderCode:{}, dueRefundAmount:{}, refundedAmount:{}, "
+                            + "expectedSplitAmount:{}, confirmedSplitAmount:{}, remainingSplitAmount:{}, refundFlag:{}, splitFlag:{}",
+                    paymentId, orderCode, dueRefundAmount, refundResult.refundedAmount,
+                    expectedSplitAmount, splitResult.confirmedSplitAmount, remaining, refundFlag, splitFlag);
+            return true;
+        }
+        return false;
+    }
+
+    private RefundAmountResult queryRefundAmountFromAdapay(String paymentId, String wechatAppId) {
+        try {
+            List<PaymentReverseResponse> reverses =
+                    adapayService.queryPaymentReverse(paymentId, wechatAppId);
+            if (CollectionUtils.isEmpty(reverses)) {
+                return new RefundAmountResult(BigDecimal.ZERO, BigDecimal.ZERO);
+            }
+            BigDecimal refundedAmount = BigDecimal.ZERO;
+            BigDecimal acceptedRefundAmount = BigDecimal.ZERO;
+            for (PaymentReverseResponse reverse : reverses) {
+                if (reverse == null) {
+                    continue;
+                }
+                BigDecimal amt = parseAmount(reverse.getReverse_amt());
+                acceptedRefundAmount = acceptedRefundAmount.add(amt);
+                if (reverse.isSuccess()) {
+                    refundedAmount = refundedAmount.add(amt);
+                }
+            }
+            return new RefundAmountResult(
+                    refundedAmount.setScale(2, BigDecimal.ROUND_HALF_UP),
+                    acceptedRefundAmount.setScale(2, BigDecimal.ROUND_HALF_UP));
+        } catch (Exception e) {
+            log.warn("查询汇付支付撤销金额异常, paymentId:{}", paymentId, e);
+            return new RefundAmountResult(BigDecimal.ZERO, BigDecimal.ZERO);
+        }
+    }
+
+    private SplitAmountResult querySplitAmountFromAdapay(String paymentId, String wechatAppId) {
+        try {
+            QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
+            dto.setWechatAppId(wechatAppId);
+            dto.setPaymentId(paymentId);
+            QueryPaymentConfirmDetailResponse response = adapayService.queryPaymentConfirmList(dto);
+            if (response == null || CollectionUtils.isEmpty(response.getPaymentConfirms())) {
+                return new SplitAmountResult(BigDecimal.ZERO, BigDecimal.ZERO);
+            }
+            BigDecimal maxConfirmedAmount = BigDecimal.ZERO;
+            BigDecimal maxReservedAmount = BigDecimal.ZERO;
+            for (PaymentConfirmInfo confirm : response.getPaymentConfirms()) {
+                if (confirm == null) {
+                    continue;
+                }
+                BigDecimal confirmedAmount = parseAmount(confirm.getConfirmedAmt());
+                BigDecimal reservedAmount = parseAmount(confirm.getReservedAmt());
+                if (confirmedAmount.compareTo(maxConfirmedAmount) > 0) {
+                    maxConfirmedAmount = confirmedAmount;
+                }
+                if (reservedAmount.compareTo(maxReservedAmount) > 0) {
+                    maxReservedAmount = reservedAmount;
+                }
+            }
+            return new SplitAmountResult(
+                    maxConfirmedAmount.setScale(2, BigDecimal.ROUND_HALF_UP),
+                    maxReservedAmount.setScale(2, BigDecimal.ROUND_HALF_UP));
+        } catch (Exception e) {
+            log.warn("查询汇付支付确认金额异常, paymentId:{}", paymentId, e);
+            return new SplitAmountResult(BigDecimal.ZERO, BigDecimal.ZERO);
+        }
+    }
+
+    private BigDecimal calculateRemainingSplitAmount(BigDecimal payAmount, BigDecimal dueRefundAmount,
+                                                      BigDecimal confirmedSplitAmount, BigDecimal reservedSplitAmount) {
+        BigDecimal remaining = payAmount.subtract(dueRefundAmount)
+                .subtract(confirmedSplitAmount)
+                .subtract(reservedSplitAmount);
+        return remaining.compareTo(BigDecimal.ZERO) > 0
+                ? remaining.setScale(2, BigDecimal.ROUND_HALF_UP) : BigDecimal.ZERO;
+    }
+
+    private static class RefundAmountResult {
+        final BigDecimal refundedAmount;
+        final BigDecimal acceptedRefundAmount;
+
+        RefundAmountResult(BigDecimal refundedAmount, BigDecimal acceptedRefundAmount) {
+            this.refundedAmount = refundedAmount == null ? BigDecimal.ZERO : refundedAmount;
+            this.acceptedRefundAmount = acceptedRefundAmount == null ? BigDecimal.ZERO : acceptedRefundAmount;
+        }
+    }
+
+    private static class SplitAmountResult {
+        final BigDecimal confirmedSplitAmount;
+        final BigDecimal reservedSplitAmount;
+
+        SplitAmountResult(BigDecimal confirmedSplitAmount, BigDecimal reservedSplitAmount) {
+            this.confirmedSplitAmount = confirmedSplitAmount == null ? BigDecimal.ZERO : confirmedSplitAmount;
+            this.reservedSplitAmount = reservedSplitAmount == null ? BigDecimal.ZERO : reservedSplitAmount;
+        }
     }
 
     /**
@@ -529,160 +731,6 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
         return updatedCount;
     }
 
-    private int refreshUnsplitRecordHandleFlag(List<AdapayUnsplitRecord> list, String wechatAppId) {
-        if (CollectionUtils.isEmpty(list)) {
-            return 0;
-        }
-
-        Set<String> orderCodeSet = new HashSet<>();
-        for (AdapayUnsplitRecord record : list) {
-            String orderCode = record.getOrderCode();
-            if (StringUtils.isBlank(orderCode)) {
-                orderCode = extractOrderCode(record.getOrderNo());
-            }
-            if (StringUtils.isNotBlank(orderCode)) {
-                orderCodeSet.add(orderCode);
-            }
-        }
-
-        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) {
-            if (record == null || StringUtils.isBlank(record.getPaymentId())) {
-                continue;
-            }
-
-            boolean needUpdate = false;
-            String paymentId = record.getPaymentId();
-            String orderCode = record.getOrderCode();
-            if (StringUtils.isBlank(orderCode)) {
-                orderCode = extractOrderCode(record.getOrderNo());
-                if (StringUtils.isNotBlank(orderCode)) {
-                    record.setOrderCode(orderCode);
-                    needUpdate = true;
-                }
-            }
-
-            OrderBasicInfo orderBasicInfo = StringUtils.isBlank(orderCode) ? null : orderMap.get(orderCode);
-            if (orderBasicInfo != null) {
-                if (!isSameAmount(record.getDueRefundAmount(), orderBasicInfo.getRefundAmount())) {
-                    record.setDueRefundAmount(defaultAmount(orderBasicInfo.getRefundAmount()));
-                    needUpdate = true;
-                }
-                if (!isSameAmount(record.getSettleAmount(), orderBasicInfo.getSettleAmount())) {
-                    record.setSettleAmount(orderBasicInfo.getSettleAmount());
-                    needUpdate = true;
-                }
-                String pileType = YouDianUtils.isEBikePileSn(orderBasicInfo.getPileSn()) ? "eBike" : "EV";
-                if (!StringUtils.equals(record.getPileType(), pileType)) {
-                    record.setPileType(pileType);
-                    needUpdate = true;
-                }
-            }
-
-            BigDecimal dueRefundAmount = defaultAmount(record.getDueRefundAmount());
-            RefundAmountCheck refundAmountCheck = checkRefundAmount(orderBasicInfo, dueRefundAmount);
-            if (!isSameAmount(record.getRefundAmount(), refundAmountCheck.refundedAmount)) {
-                record.setRefundAmount(refundAmountCheck.refundedAmount);
-                needUpdate = true;
-            }
-            String refundFlag = calculateHandleFlag(dueRefundAmount, refundAmountCheck.refundedAmount, refundAmountCheck.acceptedRefundAmount);
-            if (!StringUtils.equals(record.getRefundFlag(), refundFlag)) {
-                record.setRefundFlag(refundFlag);
-                needUpdate = true;
-            }
-
-            BigDecimal expectedSplitAmount = defaultAmount(record.getPayAmount()).subtract(dueRefundAmount).setScale(2, BigDecimal.ROUND_HALF_UP);
-            if (expectedSplitAmount.compareTo(BigDecimal.ZERO) < 0) {
-                expectedSplitAmount = BigDecimal.ZERO;
-            }
-            SplitAmountCheck splitAmountCheck = checkSplitAmount(paymentId, wechatAppId);
-            BigDecimal confirmedSplitAmount = defaultAmount(record.getConfirmedSplitAmount()).max(splitAmountCheck.confirmedSplitAmount);
-            if (!isSameAmount(record.getConfirmedSplitAmount(), confirmedSplitAmount)) {
-                record.setConfirmedSplitAmount(confirmedSplitAmount);
-                needUpdate = true;
-            }
-            String splitFlag = calculateHandleFlag(expectedSplitAmount, confirmedSplitAmount, confirmedSplitAmount.add(splitAmountCheck.reservedSplitAmount));
-            if (!StringUtils.equals(record.getSplitFlag(), splitFlag)) {
-                record.setSplitFlag(splitFlag);
-                needUpdate = true;
-            }
-
-            if (needUpdate) {
-                record.setUpdateTime(now);
-                updateList.add(record);
-            }
-            log.info("刷新未分账处理标识, paymentId:{}, orderCode:{}, dueRefundAmount:{}, refundedAmount:{}, expectedSplitAmount:{}, confirmedSplitAmount:{}, refundFlag:{}, splitFlag:{}",
-                    paymentId, orderCode, dueRefundAmount, refundAmountCheck.refundedAmount, expectedSplitAmount, confirmedSplitAmount, refundFlag, splitFlag);
-        }
-
-        if (CollectionUtils.isNotEmpty(updateList)) {
-            adapayUnsplitRecordService.updateBatchSelective(updateList);
-            return updateList.size();
-        }
-        return 0;
-    }
-
-    private void refreshHandleFlagQuietly(String paymentId, String wechatAppId) {
-        try {
-            refreshAdapayUnsplitRecordHandleFlag(paymentId, wechatAppId);
-        } catch (Exception e) {
-            log.warn("刷新未分账处理标识异常，本轮继续处理后续记录, paymentId:{}", paymentId, e);
-        }
-    }
-
-    private RefundAmountCheck checkRefundAmount(OrderBasicInfo orderBasicInfo, BigDecimal dueRefundAmount) {
-        if (dueRefundAmount.compareTo(BigDecimal.ZERO) <= 0) {
-            return new RefundAmountCheck(BigDecimal.ZERO, BigDecimal.ZERO);
-        }
-        if (orderBasicInfo == null) {
-            return new RefundAmountCheck(BigDecimal.ZERO, BigDecimal.ZERO);
-        }
-        BigDecimal refundedAmount = getRefundedAmount(orderBasicInfo, false);
-        BigDecimal acceptedRefundAmount = getRefundedAmount(orderBasicInfo, true);
-        return new RefundAmountCheck(refundedAmount, acceptedRefundAmount);
-    }
-
-    private SplitAmountCheck checkSplitAmount(String paymentId, String wechatAppId) {
-        try {
-            QueryPaymentConfirmDTO dto = new QueryPaymentConfirmDTO();
-            dto.setWechatAppId(wechatAppId);
-            dto.setPaymentId(paymentId);
-            QueryPaymentConfirmDetailResponse response = adapayService.queryPaymentConfirmList(dto);
-            if (response == null || CollectionUtils.isEmpty(response.getPaymentConfirms())) {
-                return new SplitAmountCheck(BigDecimal.ZERO, BigDecimal.ZERO);
-            }
-
-            BigDecimal maxConfirmedAmount = BigDecimal.ZERO;
-            BigDecimal maxReservedAmount = BigDecimal.ZERO;
-            for (PaymentConfirmInfo confirm : response.getPaymentConfirms()) {
-                if (confirm == null) {
-                    continue;
-                }
-                BigDecimal confirmedAmount = parseAmount(confirm.getConfirmedAmt());
-                BigDecimal reservedAmount = parseAmount(confirm.getReservedAmt());
-                if (confirmedAmount.compareTo(maxConfirmedAmount) > 0) {
-                    maxConfirmedAmount = confirmedAmount;
-                }
-                if (reservedAmount.compareTo(maxReservedAmount) > 0) {
-                    maxReservedAmount = reservedAmount;
-                }
-            }
-            return new SplitAmountCheck(maxConfirmedAmount.setScale(2, BigDecimal.ROUND_HALF_UP),
-                    maxReservedAmount.setScale(2, BigDecimal.ROUND_HALF_UP));
-        } catch (Exception e) {
-            log.warn("刷新未分账处理标识时查询分账金额失败, paymentId:{}", paymentId, e);
-            return new SplitAmountCheck(BigDecimal.ZERO, BigDecimal.ZERO);
-        }
-    }
-
     private String calculateHandleFlag(BigDecimal expectedAmount, BigDecimal successAmount, BigDecimal acceptedAmount) {
         BigDecimal expected = defaultAmount(expectedAmount);
         BigDecimal success = defaultAmount(successAmount);
@@ -699,7 +747,6 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
     private boolean ensureRefundBeforeSplit(AdapayUnsplitRecordVO item, String wechatAppId) {
         String orderCode = item.getOrderCode();
         String paymentId = item.getPaymentId();
-        // VO 中 refundAmount 来源于 adapay_unsplit_record.due_refund_amount，表示分账前必须完成的应退款金额。
         BigDecimal dueRefundAmount = parseAmount(item.getRefundAmount());
         if (dueRefundAmount.compareTo(BigDecimal.ZERO) <= 0) {
             return true;
@@ -712,19 +759,30 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
             return false;
         }
 
-        // 先只统计成功退款金额；成功退款已足额时才允许继续后续分账。
-        BigDecimal refundedAmount = getRefundedAmount(orderBasicInfo, false);
+        // 以订单表最新退款金额为准，避免 VO 中的旧值导致误判
+        BigDecimal freshDueRefund = defaultAmount(orderBasicInfo.getRefundAmount());
+        if (!isSameAmount(dueRefundAmount, freshDueRefund)) {
+            dueRefundAmount = freshDueRefund;
+            AdapayUnsplitRecord syncRecord = buildUpdateRecordByPaymentId(paymentId);
+            syncRecord.setDueRefundAmount(freshDueRefund);
+            adapayUnsplitRecordService.insertOrUpdateSelective(syncRecord);
+        }
+
+        // 从汇付 API 查询实际退款状态，避免本地回调延迟导致数据滞后
+        RefundAmountResult refundResult = queryRefundAmountFromAdapay(paymentId, wechatAppId);
+        BigDecimal refundedAmount = refundResult.refundedAmount;
+        BigDecimal acceptedRefundAmount = refundResult.acceptedRefundAmount;
+
         updateRefundAmount(paymentId, refundedAmount);
         if (refundedAmount.compareTo(dueRefundAmount) >= 0) {
             markRefundResult(paymentId, HANDLE_FLAG_SUCCESS);
             return true;
         }
 
-        // 再统计已受理退款金额（成功 + 处理中），避免处理中退款未回调时重复发起退款。
-        BigDecimal acceptedRefundAmount = getRefundedAmount(orderBasicInfo, true);
+        // 已受理退款已足额，等待退款完成
         if (acceptedRefundAmount.compareTo(dueRefundAmount) >= 0) {
             markRefundResult(paymentId, HANDLE_FLAG_PROCESSING);
-            return waitRefundFullySucceeded(orderBasicInfo, paymentId, dueRefundAmount);
+            return waitRefundFullySucceeded(orderBasicInfo, paymentId, dueRefundAmount, wechatAppId);
         }
 
         // 已受理退款仍不足时，只补发差额退款；补发后等待成功退款金额达到应退款金额。
@@ -740,7 +798,7 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
             markRefundResult(paymentId, HANDLE_FLAG_PROCESSING);
             log.info("未分账数据先执行退款, paymentId:{}, orderCode:{}, dueRefundAmount:{}, refundedAmount:{}, refundAmount:{}",
                     paymentId, orderCode, dueRefundAmount, acceptedRefundAmount, refundAmount);
-            return waitRefundFullySucceeded(orderBasicInfo, paymentId, dueRefundAmount);
+            return waitRefundFullySucceeded(orderBasicInfo, paymentId, dueRefundAmount, wechatAppId);
         } catch (Exception e) {
             markRefundResult(paymentId, HANDLE_FLAG_FAILED);
             log.error("未分账数据执行退款失败, paymentId:{}, orderCode:{}, dueRefundAmount:{}, refundedAmount:{}, refundAmount:{}",
@@ -749,7 +807,8 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
         return false;
     }
 
-    private boolean waitRefundFullySucceeded(OrderBasicInfo orderBasicInfo, String paymentId, BigDecimal dueRefundAmount) {
+    private boolean waitRefundFullySucceeded(OrderBasicInfo orderBasicInfo, String paymentId,
+                                              BigDecimal dueRefundAmount, String wechatAppId) {
         for (int i = 1; i <= REFUND_WAIT_MAX_ATTEMPTS; i++) {
             try {
                 Thread.sleep(REFUND_WAIT_INTERVAL_MILLIS);
@@ -759,8 +818,7 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
                 return false;
             }
 
-            // 这里仍然只认成功退款金额，处理中退款不满足“退款足额后再分账”的条件。
-            BigDecimal refundedAmount = getRefundedAmount(orderBasicInfo, false);
+            BigDecimal refundedAmount = queryRefundAmountFromAdapay(paymentId, wechatAppId).refundedAmount;
             updateRefundAmount(paymentId, refundedAmount);
             if (refundedAmount.compareTo(dueRefundAmount) >= 0) {
                 markRefundResult(paymentId, HANDLE_FLAG_SUCCESS);
@@ -778,29 +836,6 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
         return false;
     }
 
-    private BigDecimal getRefundedAmount(OrderBasicInfo orderBasicInfo, boolean includeProcessing) {
-        List<OrderDetailInfoVO.OrderRefundInfo> refundInfoList = orderBasicInfoService.getOrderRefundInfoList(orderBasicInfo);
-        if (CollectionUtils.isEmpty(refundInfoList)) {
-            return BigDecimal.ZERO;
-        }
-
-        BigDecimal refundedAmount = BigDecimal.ZERO;
-        for (OrderDetailInfoVO.OrderRefundInfo refundInfo : refundInfoList) {
-            if (refundInfo == null) {
-                continue;
-            }
-            // includeProcessing=false：只累计成功退款；includeProcessing=true：成功 + 处理中，用于判断是否还需要补发差额退款。
-            String status = refundInfo.getStatus();
-            if (StringUtils.isNotBlank(status)
-                    && !StringUtils.equals(status, AdapayStatusEnum.SUCCEEDED.getValue())
-                    && !(includeProcessing && StringUtils.equals(status, AdapayStatusEnum.PENDING.getValue()))) {
-                continue;
-            }
-            refundedAmount = refundedAmount.add(parseAmount(refundInfo.getReverseAmt()));
-        }
-        return refundedAmount.setScale(2, BigDecimal.ROUND_HALF_UP);
-    }
-
     private BigDecimal getLatestConfirmAmount(BigDecimal waitSplitAmount, String payAmount, String refundAmount, String paymentId, String wechatAppId) {
         BigDecimal confirmAmt = waitSplitAmount;
         try {
@@ -842,37 +877,40 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
         return latestRemaining.compareTo(BigDecimal.ZERO) > 0 ? latestRemaining : BigDecimal.ZERO;
     }
 
+    private AdapayUnsplitRecord buildUpdateRecordByPaymentId(String paymentId) {
+        List<AdapayUnsplitRecord> existingRecords = adapayUnsplitRecordService.selectByPaymentIds(Lists.newArrayList(paymentId));
+        AdapayUnsplitRecord record = new AdapayUnsplitRecord();
+        record.setPaymentId(paymentId);
+        record.setUpdateTime(DateUtils.getNowDate());
+        if (CollectionUtils.isNotEmpty(existingRecords)) {
+            record.setId(existingRecords.get(0).getId());
+        }
+        return record;
+    }
+
     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);
+        AdapayUnsplitRecord updateRecord = buildUpdateRecordByPaymentId(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);
+        AdapayUnsplitRecord updateRecord = buildUpdateRecordByPaymentId(paymentId);
         updateRecord.setSplitFlag(splitFlag);
-        updateRecord.setUpdateTime(DateUtils.getNowDate());
         adapayUnsplitRecordService.insertOrUpdateSelective(updateRecord);
     }
 
     private void updateRefundAmount(String paymentId, BigDecimal refundAmount) {
-        AdapayUnsplitRecord updateRecord = new AdapayUnsplitRecord();
-        updateRecord.setPaymentId(paymentId);
+        AdapayUnsplitRecord updateRecord = buildUpdateRecordByPaymentId(paymentId);
         updateRecord.setRefundAmount(refundAmount.setScale(2, BigDecimal.ROUND_HALF_UP));
-        updateRecord.setUpdateTime(DateUtils.getNowDate());
         adapayUnsplitRecordService.insertOrUpdateSelective(updateRecord);
     }
 
     private void markRefundResult(String paymentId, String refundFlag) {
-        AdapayUnsplitRecord updateRecord = new AdapayUnsplitRecord();
-        updateRecord.setPaymentId(paymentId);
+        AdapayUnsplitRecord updateRecord = buildUpdateRecordByPaymentId(paymentId);
         updateRecord.setRefundFlag(refundFlag);
-        updateRecord.setUpdateTime(DateUtils.getNowDate());
         adapayUnsplitRecordService.insertOrUpdateSelective(updateRecord);
     }
 
@@ -1065,23 +1103,4 @@ public class AdapayUnsplitRecordHandleServiceImpl implements AdapayUnsplitRecord
         }
     }
 
-    private static class RefundAmountCheck {
-        private final BigDecimal refundedAmount;
-        private final BigDecimal acceptedRefundAmount;
-
-        private RefundAmountCheck(BigDecimal refundedAmount, BigDecimal acceptedRefundAmount) {
-            this.refundedAmount = refundedAmount == null ? BigDecimal.ZERO : refundedAmount;
-            this.acceptedRefundAmount = acceptedRefundAmount == null ? BigDecimal.ZERO : acceptedRefundAmount;
-        }
-    }
-
-    private static class SplitAmountCheck {
-        private final BigDecimal confirmedSplitAmount;
-        private final BigDecimal reservedSplitAmount;
-
-        private SplitAmountCheck(BigDecimal confirmedSplitAmount, BigDecimal reservedSplitAmount) {
-            this.confirmedSplitAmount = confirmedSplitAmount == null ? BigDecimal.ZERO : confirmedSplitAmount;
-            this.reservedSplitAmount = reservedSplitAmount == null ? BigDecimal.ZERO : reservedSplitAmount;
-        }
-    }
 }

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

@@ -529,20 +529,20 @@ public class JsowellTask {
     }
 
     /**
-     * 按 paymentId 刷新 adapay_unsplit_record 的退款/分账处理标识
-     * jsowellTask.refreshAdapayUnsplitRecordHandleFlag(paymentId, wechatAppId)
+     * 按 paymentId 从汇付同步并刷新 adapay_unsplit_record 的退款/分账标识
+     * jsowellTask.syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId)
      */
-    public void refreshAdapayUnsplitRecordHandleFlag(String paymentId, String wechatAppId) {
-        adapayUnsplitRecordHandleService.refreshAdapayUnsplitRecordHandleFlag(paymentId, wechatAppId);
+    public void syncAndRefreshFlagsFromAdapay(String paymentId, String wechatAppId) {
+        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(paymentId, wechatAppId);
     }
 
     /**
-     * 批量刷新 adapay_unsplit_record 的退款/分账处理标识
-     * jsowellTask.refreshAdapayUnsplitRecordHandleFlag(startTime, endTime, wechatAppId, pageSize)
-     * 示例：jsowellTask.refreshAdapayUnsplitRecordHandleFlag('2024-01-01 00:00:00', '2025-12-31 23:59:59', 'app_id', 500)
+     * 批量从汇付同步并刷新 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 refreshAdapayUnsplitRecordHandleFlag(String startTime, String endTime, String wechatAppId, Integer pageSize) {
-        adapayUnsplitRecordHandleService.refreshAdapayUnsplitRecordHandleFlag(startTime, endTime, wechatAppId, pageSize);
+    public void syncAndRefreshFlagsFromAdapay(String startTime, String endTime, String wechatAppId, Integer pageSize) {
+        adapayUnsplitRecordHandleService.syncAndRefreshFlagsFromAdapay(startTime, endTime, wechatAppId, pageSize);
     }
 
     /**