Merge remote-tracking branch 'origin/master'

- 导入java.sql.SQLException依赖用于数据库异常处理
- 在处理导入参数时对客户名称进行预修剪操作
- 将原有的复杂批处理逻辑提取到persistImportChunk方法中
- 简化了批量导入的核心处理流程，提高代码可读性
- 优化了重复键检测逻辑，支持多种数据库错误码识别
- 移除了冗长的内联批处理实现，改用统一的方法调用

.gitignore

@@ -42,3 +42,4 @@ ehthumbs.db
 Thumbs.db
 /file/
 /websoft-modules.log
+/tmp/

CONTEXT.md

@@ -1,43 +0,0 @@
-# 汇吉采标书购买平台
-
-汇吉采标书购买平台是一站式代理平台的交易出口：企业账号在此注册、通过资质审核后购买标书，平台内完成订单与支付，并把购买记录推送回一站式平台。
-
-## 核心实体
-
-**标书项目 (Bid Project)**:
-一条采购项目，同时也是可购买下载的标书，二者是**同一实体**（甲方确认：一个项目即一本标书）。携带项目编号、名称/分类、招标人、中标公司、中标金额与中标公告信息，以及标书价格（信息服务费）、标书附件、开售/停售时间与售卖方式。
-_Avoid_: 项目(单用), 标书(单用), tender
-
-**企业账号 (Enterprise Account)**:
-买家账号，用企业名称+密码登录，须通过资质审核才能购买标书。
-_Avoid_: 用户, 会员, buyer, hjc_user
-
-**资质认证 (Qualification)**:
-企业注册后提交、由平台审核的资质材料，状态为 待审核/已通过/已驳回（含驳回原因）。未通过不可下单。
-_Avoid_: 认证
-
-**订单 (Order)**:
-企业购买标书的记录，含标书信息/数量/金额/购买企业，需支付后完成。
-_Avoid_: 交易, purchase
-
-**信息服务费 (Service Fee)**:
-购买标书支付的金额，即「标书价格」。平台对每一本标书设定。
-_Avoid_: 标书价格, 标书费
-
-## 与一站式平台的关系
-
-**一站式代理平台 (One-stop Platform)**:
-上游系统，向本平台推送中标公告数据，并接收本平台推送的购买记录/订单落盘。
-_Avoid_: 甲方, 上游
-
-**中标公告 (Award Announcement)**:
-项目流程走到「发布中标公告」时由一站式平台推送的公告数据，含招标人/中标公司/中标金额/公告正文/公告附件。
-_Avoid_: 公告, bulletin
-
-**售卖方式 (Selling Method)**:
-标书的售卖渠道标识：1 公司财务 / 2 公众号 / 3 交易中心 / 4 政采云。
-_Avoid_: 渠道
-
-**推送 (Push)**:
-本平台与一站式平台之间交换数据的动作：接收中标公告（入），并在订单支付成功后推送购买记录（出）。
-_Avoid_: 同步, 对接

docs/SHOP_DEALER_REFEREE_BINDING.md

@@ -0,0 +1,26 @@
+# ShopDealerReferee 绑定接口规则与索引建议
+
+接口：`POST /api/shop/shop-dealer-referee`
+
+## 业务规则(后端)
+
+- 邀请人(dealerId)必须存在且有效：以 `shop_dealer_user` 记录存在且 `is_delete=0` 为准
+- 当前用户(userId)仅从 token 获取；若 body.userId 存在且与 token 不一致则拒绝
+- 禁止自己绑定自己：`dealerId == userId`
+- 仅首次绑定生效：若已存在(同一 tenant、同一 user、`level=1`)则直接返回成功(幂等，不改绑)
+- 记录溯源字段：`source`、`scene`
+
+## 并发幂等(数据库建议)
+
+建议在 `shop_dealer_referee` 增加溯源字段，并加唯一索引保证并发下不重复写入：
+
+```sql
+ALTER TABLE shop_dealer_referee
+  ADD COLUMN source VARCHAR(32) NULL COMMENT '来源(如 goods_share)',
+  ADD COLUMN scene  VARCHAR(255) NULL COMMENT '场景参数(溯源统计)';
+
+-- 约束：同一 tenant 下，一个用户每个 level 只能有一条推荐关系
+ALTER TABLE shop_dealer_referee
+  ADD UNIQUE KEY uk_shop_dealer_referee_tenant_user_level (tenant_id, user_id, level);
+```
+

docs/TICKET_PACKAGE_FEATURE_PLAN.md

@@ -0,0 +1,31 @@
+# 套票（冻结/可用、分期释放）功能开发计划
+
+## 目标
+- 为“买N送M（例如买1送4）、起售（例如20桶起售）、按月释放（例如每月释放10桶）、可用未用完叠加”的套票/权益，提供后端可配置、可发放、可释放、可消费的能力。
+
+## 核心概念
+- 套票模板：按商品(goodsId)配置买赠规则、起售/起送、释放规则（每期释放数或释放期数）、首期释放时机。
+- 用户套票账户：记录总量、可用量、冻结量、已用量、已释放量；绑定订单（用于幂等与追溯）。
+- 释放计划：每期一条，到期后把冻结转可用（可用未用完自然叠加）。
+- 变更流水：发放/释放/消费等都记录流水，便于对账与排查。
+
+## 关键默认规则（可在模板里改）
+- 仅赠送量进入套票账户（默认不包含“购买量”本身）；如需“买20送80=总100”，可在模板设置 `includeBuyQty=true`。
+- 首期释放：默认“支付成功当日/当刻”释放（`firstReleaseMode=0`）；如需“下个月同日释放”，设 `firstReleaseMode=1`。
+- 每期释放：默认按 `monthlyReleaseQty`；如配置了 `releasePeriods`，则平均分摊并处理余数。
+
+## 开发步骤（建议按顺序）
+1. 需求确认与接入点确认（订单哪个节点发放、桶票如何消费/核销、退款是否回滚、释放日期规则）。
+2. 数据表设计与SQL输出（模板/账户/释放计划/流水）。
+3. 实现套票模板后台CRUD接口。
+4. 支付成功接入：在订单支付成功后发放套票账户+生成释放计划（幂等）。
+5. 定时任务释放：扫描到期释放计划，执行“冻结->可用”转账（幂等）。
+6. 消费扣减：对用户可用量做扣减（支持跨多套票账户FIFO扣减），并落流水。
+7. 测试与验收：至少覆盖（买赠计算、分期拆分、叠加逻辑、幂等、并发扣减）。
+
+## 待确认点（不确认也可先按默认实现）
+- 套票数量=赠送量？还是（购买量+赠送量）？
+- “释放日期”是按支付时间的“日”还是固定每月某一天？（31号跨月如何处理？）
+- 退款/取消：是否回滚未使用的可用/冻结？已释放但未用如何处理？
+- 消费场景：在哪个业务点扣减（下单抵扣/提货核销/线下核销）？
+

docs/TICKET_PACKAGE_TABLES.sql

@@ -0,0 +1,121 @@
+-- 套票（冻结/可用、分期释放）相关表
+-- 说明：项目使用了 MyBatis-Plus 的 tenant 拦截；表内显式保留 tenant_id 字段并建议建立联合唯一索引。
+
+-- 1) 套票模板（按商品配置）
+CREATE TABLE IF NOT EXISTS shop_ticket_template (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  goods_id INT NOT NULL,
+  name VARCHAR(100) NOT NULL,
+
+  enabled TINYINT(1) NOT NULL DEFAULT 1,
+  unit_name VARCHAR(20) NOT NULL DEFAULT '桶',
+
+  -- 起售/起送
+  min_buy_qty INT NOT NULL DEFAULT 1,
+  start_send_qty INT NOT NULL DEFAULT 1,
+
+  -- 买赠：买1送4 => gift_multiplier=4
+  gift_multiplier INT NOT NULL DEFAULT 0,
+  -- 是否把购买量也计入套票总量（默认仅计入赠送量）
+  include_buy_qty TINYINT(1) NOT NULL DEFAULT 0,
+
+  -- 释放规则：二选一
+  -- A) 每期释放数量（默认每月释放10）
+  monthly_release_qty INT NOT NULL DEFAULT 10,
+  -- B) 总共释放多少期（若配置>0，则按期数平均分摊）
+  release_periods INT NULL,
+
+  -- 首期释放时机：0=支付成功当刻；1=下个月同日
+  first_release_mode INT NOT NULL DEFAULT 0,
+
+  comments VARCHAR(255) NULL,
+  sort_number INT NOT NULL DEFAULT 0,
+  user_id INT NULL,
+
+  deleted INT NOT NULL DEFAULT 0,
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  UNIQUE KEY uk_ticket_template_tenant_goods (tenant_id, goods_id),
+  KEY idx_ticket_template_tenant (tenant_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 2) 用户套票账户（一次购买通常生成一条）
+CREATE TABLE IF NOT EXISTS shop_user_ticket (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  template_id INT NOT NULL,
+  goods_id INT NOT NULL,
+
+  user_id INT NOT NULL,
+  order_id INT NULL,
+  order_no VARCHAR(64) NULL,
+  order_goods_id INT NULL,
+
+  total_qty INT NOT NULL DEFAULT 0,
+  available_qty INT NOT NULL DEFAULT 0,
+  frozen_qty INT NOT NULL DEFAULT 0,
+  used_qty INT NOT NULL DEFAULT 0,
+  released_qty INT NOT NULL DEFAULT 0,
+
+  status INT NOT NULL DEFAULT 0,
+
+  deleted INT NOT NULL DEFAULT 0,
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  KEY idx_user_ticket_user (tenant_id, user_id),
+  KEY idx_user_ticket_order (tenant_id, order_no),
+  UNIQUE KEY uk_user_ticket_order_goods (tenant_id, template_id, order_no, order_goods_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 3) 释放计划/释放记录（每期一条，幂等执行）
+CREATE TABLE IF NOT EXISTS shop_user_ticket_release (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  user_ticket_id BIGINT NOT NULL,
+  user_id INT NOT NULL,
+  period_no INT NOT NULL,
+
+  release_qty INT NOT NULL,
+  release_time DATETIME NOT NULL,
+
+  status INT NOT NULL DEFAULT 0, -- 0待释放 1已释放 2作废
+  released_time DATETIME NULL,
+
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  UNIQUE KEY uk_ticket_release_period (tenant_id, user_ticket_id, period_no),
+  KEY idx_ticket_release_due (status, release_time),
+  KEY idx_ticket_release_user (tenant_id, user_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 4) 套票变更流水（发放/释放/消费/回滚等）
+CREATE TABLE IF NOT EXISTS shop_user_ticket_log (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  user_ticket_id BIGINT NOT NULL,
+  user_id INT NOT NULL,
+
+  change_type INT NOT NULL, -- 10发放 20释放 30消费 40回滚/退款
+  change_available INT NOT NULL DEFAULT 0,
+  change_frozen INT NOT NULL DEFAULT 0,
+  change_used INT NOT NULL DEFAULT 0,
+
+  available_after INT NOT NULL DEFAULT 0,
+  frozen_after INT NOT NULL DEFAULT 0,
+  used_after INT NOT NULL DEFAULT 0,
+
+  order_id INT NULL,
+  order_no VARCHAR(64) NULL,
+  remark VARCHAR(255) NULL,
+
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  KEY idx_ticket_log_user (tenant_id, user_id),
+  KEY idx_ticket_log_ticket (tenant_id, user_ticket_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+

docs/adr/0001-one-stop-push-auth.md

@@ -1,3 +0,0 @@
-# 一站式推送鉴权：appKey + timestamp + sign，password 不进报文
-
-汇吉采 → 一站式平台的订单推送采用 `appKey + timestamp + sign` 请求头鉴权，`sign = MD5(appKey + password + timestamp)`（小写），`password` 只作为密钥参与签名、不放入任何报文字段；一站式侧校验 appKey 匹配、timestamp 与本地时间差 ≤ ±10 分钟（防重放）、以及重算 MD5 与 sign 不区分大小写比对。原始需求文字要求把 `password` 明文加入请求头，会泄露共享密钥，本方案保留其 appKey/password/年月日时分/MD5 全部要素，仅把 password 降级为纯签名密钥，是相对原始字面的有意偏离；若一站式平台已按原始明文方案实现，兼容退路见 `docs/一站式平台推送-接口鉴权规范.md` 附录 A。理由：这是对外契约，改动成本高，且偏离点是刻意且必须记录，否则后人会「修复」回明文方案。

docs/adr/0002-project-biddoc-onetomany.md

@@ -1,5 +0,0 @@
-# 项目与标书为同一实体：一个项目一本标书
-
-**Supersedes**: 早先「项目/标书两个实体、1 项目:N 标书」的假设——甲方已明确**项目与标书是一个东西，一个项目即一本标书**，故撤销该假设。
-
-项目（Project）与标书（BidDocument）建模为**同一个实体**（`标书项目`），单表承载。一站式推送的公告类字段（公告标题/招标人/中标公司/中标金额/公告正文/公告附件）与销售类字段（标书价格/附件/开售/停售/售卖方式/needSell）都落在这一张表上，由「推送入库 + 管理后台手工增删改查」双路填充。理由：既然甲方确认一个项目仅对应一本标书，两实体之间的 1:N 关系已不存在，拆表只会增加复杂度而无对应业务收益；等未来确实出现「一项目多标书」再演进（届时把标书款从主表抽出即可，主表结构无须预埋）。

docs/adr/0003-h5-wechat-jsapi-payment.md

@@ -1,12 +0,0 @@
-# H5 端（公众号内）支付采用微信 JSAPI 直接唤起
-
-汇吉采移动端 H5（`hjc-h5`，在微信「公众号」内打开）的支付采用**微信 JSAPI**（`PaymentType.WECHAT` + `openid`），由后端 `WechatJsapiStrategy` 用 `wechatpay-java` 的 `JsapiServiceExtension.prepayWithRequestPayment` 直接返回前端 `wx.chooseWXPay` 所需的 `appId/timeStamp/nonceStr/package/signType/paySign`；无 `openid`（非公众号环境）时**回退 Native 扫码**展示 `codeUrl`。
-
-选择理由：公众号内直接「唤起支付」免去另开微信扫二维码的操作，转化率与体验均优于 Native 扫码；后端支付组件（`PaymentRequest.openId`、`PaymentResponse.wechatJsapi`、`PaymentChannel.WECHAT_JSAPI`、`WechatPayType.JSAPI`）早已为 JSAPI 预留，只差一个策略实现，改造成本低。
-
-代价/偏离：
-- **需要用户 openid**，因此引入微信**网页授权**（静默 `snsapi_base`）：`/hjc/wechat/authorize` 生成授权地址，`/hjc/wechat/oauth/callback` 用 `code` 换 `openid` 后回跳 H5 并附带 `openid`。
-- **需要 `wx.config` 签名**：新增 `/hjc/wechat/jsapi-sign`（基于 `jsapi_ticket` 做 SHA1 签名），公众号配置（appId/appSecret）存于 Redis `cache{tenantId}:setting:wx-official`。
-- **不改 Native 扫码逻辑**：两者共用同一商户号/回调地址；`PaymentServiceImpl.getPaymentStrategy` 在 `WECHAT` 类型下按 `openid` 有无分流 JSAPI/Native，未破坏既有 Native 调用方。
-
-兼容与说明：本方案是「带 openid 走 JSAPI，否则 Native」的弹性分流，非公众号环境（如普通浏览器/开发联调）仍可扫码支付，便于无真实公众号配置时验证。

docs/sql/2026-02-06_glt_ticket_order_delivery_fields.sql

@@ -0,0 +1,14 @@
+-- 水票配送订单：配送流程字段（需在数据库执行）
+-- 表：glt_ticket_order
+
+ALTER TABLE glt_ticket_order2
+  ADD COLUMN delivery_status INT NULL DEFAULT 10 COMMENT '配送状态：10待配送、20配送中、30待客户确认、40已完成',
+  ADD COLUMN send_start_time DATETIME NULL COMMENT '开始配送时间',
+  ADD COLUMN send_end_time DATETIME NULL COMMENT '确认送达时间',
+  ADD COLUMN send_end_img VARCHAR(512) NULL COMMENT '送达拍照留档图片URL',
+  ADD COLUMN receive_confirm_time DATETIME NULL COMMENT '客户确认收货时间',
+  ADD COLUMN receive_confirm_type INT NULL COMMENT '确认方式：10手动、20照片、30超时';
+
+CREATE INDEX idx_glt_ticket_order_rider_status ON glt_ticket_order (tenant_id, rider_id, delivery_status, deleted);
+CREATE INDEX idx_glt_ticket_order_user_status ON glt_ticket_order (tenant_id, user_id, delivery_status, deleted);
+

docs/一站式平台对接-接口文档.md

@@ -1,260 +0,0 @@
-# 汇吉采 ↔ 一站式代理平台 对接接口文档
-
-> 版本：v1.0
-> 适用：汇吉采标书购买平台（下称「官方网」）与一站式代理平台（下称「一站式」）之间双向数据互通。
-> 相关：鉴权规则见 `docs/一站式平台推送-接口鉴权规范.md`；建表见 `src/main/resources/sql/hjc_init.sql`。
-
----
-
-## 0. 概述
-
-| 方向 | 触发时机 | 接口 | 位置 |
-|---|---|---|---|
-| **入向**（一站式 → 官方网） | 项目流程走到「发布中标公告」时 | `POST {官方网}/api/hjc/push/project` | 官方网接收标书/中标公告数据，按 `projectNo` upsert 落库 |
-| **出向**（官方网 → 一站式） | C 端购买标书**支付成功后** / 退款时 | `POST {一站式}/api/biz/createPurchaseDetails` | 官方网把购买记录/订单信息推送到一站式落盘 |
-
-**共享凭证**（双方约定，不通过网络传输明文密钥）：
-
-| 参数 | 值 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 调用方标识，明文放请求头 |
-| `password` | `vQ8$kR3#mW6@xP2!nF` | 签名密钥（Secret），仅参与签名，**不进报文** |
-
----
-
-## 1. 鉴权规范（双向通用）
-
-请求头携带：
-
-| Header | 示例 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 双方一致 |
-| `timestamp` | `202604080103` | 格式 `yyyyMMddHHmm`（24 小时，北京时区，精确到分） |
-| `sign` | `9f7c…（32位小写hex）` | 签名值 |
-
-**签名算法**：`sign = MD5(appKey + password + timestamp)`（无分隔符，小写 32 位）。
-
-**校验顺序**（任一步不过即拒绝，建议返回 `401`/`400`）：
-1. `appKey == HJC_Official_Website`
-2. `timestamp` 与接收方服务器当前时间差 **≤ ±10 分钟**（防重放）
-3. 用约定 `password` 重算 `MD5(appKey+password+timestamp)`，与 `sign` 不区分大小写比对
-
-> 完整规则、示例（Python/Java）与「明文 password 头」兼容退路见 `docs/一站式平台推送-接口鉴权规范.md`。
-
----
-
-## 2. 入向接口：一站式 → 官方网（接收标书/中标公告）
-
-### 2.1 接口地址
-
-```
-POST {官方网BaseUrl}/api/hjc/push/project
-```
-
-> 官方网侧需在 SecurityConfig 放行该路径（已内置，`/api/hjc/push/project` 为公开接口，鉴权由本接口的 appKey/sign 自行校验）。
-
-### 2.2 请求头
-
-| Header | 值 |
-|---|---|
-| `appKey` | `HJC_Official_Website` |
-| `timestamp` | `yyyyMMddHHmm` |
-| `sign` | `MD5(appKey+password+timestamp)` |
-| `tenantId` | `10626`（官方网当前固定租户，**必传**，作为落库租户） |
-| `Content-Type` | `application/json` |
-
-### 2.3 请求体字段
-
-| 字段 | 类型 | 必填 | 说明 | 对应内部字段 |
-|---|---|---|---|---|
-| `projectNo` | string | ✔ | 项目编号 | `project_no`（upsert 主键） |
-| `projectName` | string | ✔ | 项目名称 | `project_name` |
-| `tenderPrice` | number | | 标书价格/信息服务费 | `tender_price` |
-| `files` | string(JSON/逗号分隔) | | 标书附件 | `tender_file` |
-| `tenderOnsaleTime` | string | | 开售时间 `yyyy-MM-dd HH:mm:ss` | `onsale_time` |
-| `tenderOffsaleTime` | string | | 停售时间 `yyyy-MM-dd HH:mm:ss` | `offsale_time` |
-| `bulletinName` | string | | 公告标题 | `bulletin_title` |
-| `customerName` | string | | 招标人 | `tenderer` |
-| `supplierName` | string | | 中标公司 | `winner_supplier` |
-| `bidAmount` | number | | 中标金额 | `bid_amount` |
-| `content` | string | | 公告正文 | `bulletin_content` |
-| `fileList` | string(JSON/逗号分隔) | | 公告附件 | `bulletin_file_list` |
-| `needSellTender` | number | | 是否卖标书 0/1 | `need_sell` |
-| `sellingMethod` | number | | 售卖方式 1公司财务 2公众号 3交易中心 4政采云 | `selling_method` |
-
-### 2.4 响应
-
-```json
-{
-  "code": 0,
-  "message": "接收成功",
-  "data": { "id": 12, "projectNo": "ZB-2026-0001", "projectName": "xxx", "dataSource": "PUSH", "status": 1 }
-}
-```
-- `code == 0` 成功；`code != 0` 失败（如 `message=鉴权失败` / `租户ID不能为空` / `项目编号不能为空`）。
-
-### 2.5 落库规则（官方网侧）
-
-- 按 `projectNo` **upsert**：不存在则插入（`tenantId=请求头tenantId`，`status=1` 上架，`dataSource=PUSH`，`saleCount=0`）；已存在则更新推送到字段。
-- 兼容性：`tenderOnsaleTime`/`tenderOffsaleTime` 支持 `yyyy-MM-dd HH:mm:ss`、`yyyyMMddHHmmss`、ISO 带 `T` 三种格式解析；解析失败置空。
-- 其余标书项目字段（分类、上下架、人工维护数据）仍可在管理后台手工调整。
-
----
-
-## 3. 出向接口：官方网 → 一站式（推送购买记录/订单）
-
-### 3.1 接口地址
-
-```
-POST {一站式BaseUrl}/api/biz/createPurchaseDetails
-```
-
-### 3.2 触发时机
-
-- **支付成功后**（官方网 `PUT /api/hjc/order/mark-paid` 置已付）自动推送，请求状态 `status=PAID`。
-- **退款时**（官方网 `POST /api/hjc/order/refund` 置已退款）推送，请求状态 `status=REFUNDED`，**必须**携带 `refundTime`（退款时间）与 `refundReason`（退款原因）。
-  - `refundTime`：官方网记录退款动作发生时间（服务器时间），落库 `hjc_order.refund_time`。
-  - `refundReason`：后台退款弹窗填写（≤200 字），落库 `hjc_order.refund_reason`；未填写时取默认「管理员操作退款」。
-  - 推送失败进重试队列后，重试报文的退款时间/原因按订单落库值重建，不会丢失。
-
-### 3.3 请求头
-
-| Header | 值 |
-|---|---|
-| `appKey` | `HJC_Official_Website` |
-| `timestamp` | `yyyyMMddHHmm` |
-| `sign` | `MD5(appKey+password+timestamp)` |
-| `Content-Type` | `application/json` |
-
-> `password` 不进请求头；`sign` 每次发送须按新的 `timestamp` 重新计算。
-
-### 3.4 请求体字段
-
-| 字段 | 类型 | 说明 |
-|---|---|---|
-| `idempotencyKey` | string | 幂等键，`HJC_ORD_<orderNo>` |
-| `orderNo` | string | 官方网订单号（一站式去重键） |
-| `projectNo` | string | 项目编号 |
-| `projectName` | string | 项目名称 |
-| `tenderPrice` | number | 标书单价（信息服务费） |
-| `quantity` | number | 购买数量 |
-| `totalAmount` | number | 订单总额 |
-| `buyer.enterpriseName` | string | 购买企业名称 |
-| `buyer.creditCode` | string | 企业统一社会信用代码 |
-| `buyer.contactName` | string | 经办人姓名 |
-| `buyer.contactPhone` | string | 经办人手机号 |
-| `buyer.contactEmail` | string | 经办人邮箱 |
-| `paidAt` | string | 支付时间 `yyyy-MM-dd HH:mm:ss` |
-| `payMethod` | string | `WECHAT_NATIVE` / `ALIPAY` |
-| `status` | string | `PAID`（已支付）/ `REFUNDED`（已退款） |
-| `refundTime` | string | **退款时必传**，退款时间 `yyyy-MM-dd HH:mm:ss`（`status=REFUNDED` 时推送，其余状态不出现在报文中） |
-| `refundReason` | string | **退款时必传**，退款原因（≤255 字符；后台未填写时取默认「管理员操作退款」） |
-| `invoiceStatus` | string | `NONE` / `APPLIED` / `ISSUED` |
-
-请求体示例：
-
-```json
-{
-  "idempotencyKey": "HJC_ORD_HJC2026080101ABCD",
-  "orderNo": "HJC2026080101ABCD",
-  "projectNo": "ZB-2026-0001",
-  "projectName": "xxx采购项目",
-  "tenderPrice": 500.00,
-  "quantity": 1,
-  "totalAmount": 500.00,
-  "buyer": {
-    "enterpriseName": "某某科技有限公司",
-    "creditCode": "91110XXXX",
-    "contactName": "张三",
-    "contactPhone": "13800000000",
-    "contactEmail": "a@b.com"
-  },
-  "paidAt": "2026-08-01 10:30:00",
-  "payMethod": "WECHAT_NATIVE",
-  "status": "PAID",
-  "invoiceStatus": "NONE"
-}
-```
-
-退款推送请求体示例（`status=REFUNDED`，多出 `refundTime`/`refundReason`）：
-
-```json
-{
-  "idempotencyKey": "HJC_ORD_HJC2026080101ABCD",
-  "orderNo": "HJC2026080101ABCD",
-  "projectNo": "ZB-2026-0001",
-  "projectName": "xxx采购项目",
-  "tenderPrice": 500.00,
-  "quantity": 1,
-  "totalAmount": 500.00,
-  "buyer": {
-    "enterpriseName": "某某科技有限公司",
-    "creditCode": "91110XXXX",
-    "contactName": "张三",
-    "contactPhone": "13800000000",
-    "contactEmail": "a@b.com"
-  },
-  "paidAt": "2026-08-01 10:30:00",
-  "payMethod": "WECHAT_NATIVE",
-  "status": "REFUNDED",
-  "refundTime": "2026-08-03 09:15:00",
-  "refundReason": "项目终止，客户申请退款",
-  "invoiceStatus": "NONE"
-}
-```
-
-### 3.5 响应约定
-
-- 一站式按自身 `API` 返回；官方网侧把 `HTTP 2xx` 视为成功，否则记入推送日志（`hjc_order_push_log`）待重试。
-- **幂等**：建议一站式以 `orderNo`/`idempotencyKey` 去重，同单重复提交返回成功、不重复插入。
-
-### 3.6 重试策略（官方网侧）
-
-- 失败（非 2xx / 网络异常）写入 `push_status=2`，`next_retry_time = now + 30min`，`attempt_count + 1`。
-- 由定时任务 `retryPendingPush()` 扫描待推送/失败记录重发；重发时 `timestamp/sign` 重新计算。
-
----
-
-## 4. 字段映射总表
-
-| 一站式字段 | 含义 | 官方网内部字段 |
-|---|---|---|
-| `projectNo` | 项目编号 | `hjc_bid_project.project_no` |
-| `projectName` | 项目名称 | `project_name` |
-| `tenderPrice` | 标书价格 | `tender_price` |
-| `files` | 标书附件 | `tender_file` |
-| `tenderOnsaleTime` | 开售时间 | `onsale_time` |
-| `tenderOffsaleTime` | 停售时间 | `offsale_time` |
-| `bulletinName` | 公告标题 | `bulletin_title` |
-| `customerName` | 招标人 | `tenderer` |
-| `supplierName` | 中标公司 | `winner_supplier` |
-| `bidAmount` | 中标金额 | `bid_amount` |
-| `content` | 公告正文 | `bulletin_content` |
-| `fileList` | 公告附件 | `bulletin_file_list` |
-| `needSellTender` | 是否卖标书 | `need_sell` |
-| `sellingMethod` | 售卖方式 | `selling_method` |
-| `refundTime` | 退款时间（出向） | `hjc_order.refund_time` |
-| `refundReason` | 退款原因（出向） | `hjc_order.refund_reason` |
-
----
-
-## 5. 配置清单（待双方/部署方填写）
-
-| 项 | 值 | 位置 |
-|---|---|---|
-| 官方网 base-url | `http://<官方网域名>/api` | 一站式侧调用方配置 |
-| 一站式 base-url | `http://<一站式域名>` | `mp-java/application.yml` → `hjc.one-stop.base-url` |
-| createPurchaseDetails 路径 | `/api/biz/createPurchaseDetails` | `hjc.one-stop.create-purchase-details-path` |
-| `appKey` | `HJC_Official_Website` | 双方约定 |
-| `password` | `vQ8$kR3#mW6@xP2!nF` | 双方约定 |
-| 租户 ID | `10626` | 官方网请求头 `tenantId` |
-
----
-
-## 6. 待确认事项
-
-1. 出向 `sign` 拼接顺序（`appKey+password+timestamp`）与一站式既有算法是否一致；不一致请给出一站式现网签名规范。
-2. `timestamp` 格式、时区、±10min 窗口是否认可。
-3. `createPurchaseDetails` 字段名是否需与一站式现网入参完全一致（现按本表定义）；如需调整字段名请给出一站式入参清单。
-4. 入向：一站式调用官方网 `/api/hjc/push/project` 时是否也按同一套 `appKey/timestamp/sign` 鉴权（本表默认对称鉴权）。
-5. 退款字段名 `refundTime` / `refundReason` 与一站式现网入参是否一致；格式默认 `yyyy-MM-dd HH:mm:ss`，如一站式要求其他命名或时间格式请同步调整 `CreatePurchaseDetails`。

docs/一站式平台推送-接口鉴权规范.md

@@ -1,130 +0,0 @@
-# 汇吉采 → 一站式代理平台：标书订单推送接口鉴权规范
-
-> 用途：本文档是**本平台（汇吉采标书购买平台，下称「官方网」）调用一站式代理平台接口**时的鉴权规范，用于对接一站式平台开发人员，请对方按此规则在服务端做校验。
-> 目标接口：`POST /api/biz/createPurchaseDetails`（本平台推送购买记录与订单信息到一站式平台落盘）
-
----
-
-## 1. 共享凭证（双方提前约定，不通过网络传输）
-
-| 参数 | 值 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 调用方标识，明文放在请求头 |
-| `password` | `vQ8$kR3#mW6@xP2!nF` | **签名密钥（Secret）**，仅双方服务端持有，**不放在请求头、不出现于任何请求/日志/报文** |
-
-> ⚠️ 出于安全考虑，本规范**不把 `password` 明文放请求头**。原始需求中「把 password 明文字段加到请求头」的做法会泄露密钥，改为「用 password 参与签名、请求头只带签名结果」的等价且更安全的方案（见第 3 节）。如需严格沿用原始「明文 password 头」方案，见附录 A。
-
----
-
-## 2. 请求头（请求方——官方网——每次调用携带 3 个）
-
-| Header | 示例值 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 明文 appKey（固定值） |
-| `timestamp` | `202604080103` | 签名时间，格式 `yyyyMMddHHmm`（24 小时制，北京时区，精确到分钟） |
-| `sign` | `9f7c…（32 位小写十六进制）` | 签名值，算法见第 3 节 |
-
-另需：`Content-Type: application/json`。
-
----
-
-## 3. 签名算法
-
-```
-sign = MD5( appKey + password + timestamp )
-```
-
-- `+` 表示**字符串直接拼接**，中间无分隔符。
-- `timestamp` 使用与请求头 `timestamp` **完全相同**的值。
-- `MD5` 输出**小写** 32 位十六进制字符串。
-
-步骤：
-
-1. 取当前北京时间的分钟表示 `timestamp = yyyyMMddHHmm`（例：`2026-04-08 01:03` → `202604080103`）。
-2. 拼串：`HJC_Official_Website` + `vQ8$kR3#mW6@xP2!nF` + `202604080103`。
-3. 对该字符串做 MD5，转小写，得到 `sign`。
-4. 将 `appKey`、`timestamp`、`sign` 放入请求头发出。
-
----
-
-## 4. 校验规则（一站式平台服务端）
-
-收请求后按以下顺序校验，任一步不通过即拒绝（建议返回 `401` / `400`，并附错误码与说明，便于排查）：
-
-1. **校验 appKey**：`appKey` 是否等于已登记的应用标识 `HJC_Official_Website`。不等 → 拒绝。
-2. **校验 timestamp 时效（防重放）**：`timestamp` 与**一站式服务器当前时间**之差是否在 **±10 分钟**以内（统一按北京时区、分钟精度）。超出窗口 → 拒绝，提示「时间戳失效」。
-   - 该窗口同时限制了重放窗口；如需更严可协商收紧到 ±3 分钟。
-3. **校验签名**：用共享的 `password` 重算 `MD5(appKey + password + timestamp)`，与请求头 `sign` **不区分大小写**比较（统一小写后比较）。不一致 → 拒绝，提示「签名校验失败」。
-4. 校验通过后，按请求体 `createPurchaseDetails` 的字段约定解析并落盘（业务字段见单独一节的「createPurchaseDetails 请求体字段表」）。
-
----
-
-## 5. 幂等与重试约定（可选但强烈建议）
-
-`createPurchaseDetails` 是「落盘」类写操作，本平台侧会做失败重试，因此建议一站式平台按业务主键幂等处理，避免重复落盘：
-
-- 请求体需带唯一业务单号（如 `purchaseId` / `orderNo`），一站式平台以此作为去重键；**同一单号重复提交时应返回成功、不重复插入**（或返回「已存在」）。
-- 本平台对失败的推送会按 `attempt` 递增重试（建议：1/2/4/8 分钟间隔），重试时 `timestamp/sign` 需要**重新计算**（每次请求都要以新时间重签）。
-
----
-
-## 6. 双端示例
-
-**官方网（请求方）**——以 Python 为例：
-
-```python
-import hashlib, time, requests
-
-app_key = "HJC_Official_Website"
-password = "vQ8$kR3#mW6@xP2!nF"
-ts = time.strftime("%Y%m%d%H%M")            # 202604080103
-sign = hashlib.md5((app_key + password + ts).encode("utf-8")).hexdigest()
-
-resp = requests.post(
-    "https://<一站式域名>/api/biz/createPurchaseDetails",
-    json={ ... 业务字段 ... },
-    headers={
-        "appKey": app_key,
-        "timestamp": ts,
-        "sign": sign,
-        "Content-Type": "application/json",
-    },
-    timeout=15,
-)
-```
-
-**一站式（校验方）**——以 Java 为例：
-
-```java
-String appKey = req.getHeader("appKey");
-String ts     = req.getHeader("timestamp");
-String sign   = req.getHeader("sign");
-
-if (!"HJC_Official_Website".equals(appKey)) return 401;                       // 1
-if (Math.abs(System.currentTimeMillis() / 60000 - parseMinute(ts)) > 10)
-    return 401;                                                               // 2
-String expect = md5("HJC_Official_Website" + SECRET + ts);                   // 3
-if (!expect.equalsIgnoreCase(sign)) return 401;
-
-// 4. 解析 body，按 createPurchaseDetails 字段落盘（按 orderNo 幂等）
-```
-
----
-
-## 附录 A：若一站式平台坚持「明文 password 头」的原始方案
-
-原始需求表述为「请求头添加 appKey、password，appKey+年月日时分、password+年月日时分，MD5 加密」。若对方已按此固定算法实现，则采用：
-
-- 请求头：`appKey=HJC_Official_Website`、`password=vQ8$kR3#mW6@xP2!nF`、`sign=MD5(password + yyyyMMddHHmm)`（小写）。
-- 校验：`password` 需与约定值一致，且 `MD5(password + timestamp) == sign`，同时 `timestamp` 在 ±10 分钟内。
-
-> 该方案会把 `password` 以明文形式暴露在报文中，安全性差；**仅作兼容退路，不作为默认推荐**。若对方无法确认固定算法，请首选第 1–6 节的方案。
-
----
-
-## 附：需要一站式平台确认/提供的信息
-
-1. 上述 `sign` 拼接顺序是否与合作方既有算法一致（`appKey+password+timestamp`）。
-2. 时间戳格式 `yyyyMMddHHmm` 与北京时区是否认可。
-3. 校验窗口 ±10 分钟是否可接受。
-4. `createPurchaseDetails` 请求体字段表（本平台另一份文档，见需求/接口清单）的具体入参名与必填项，需对方给出或双方对齐，以免字段名不一致导致落盘失败。

docs/水票配送订单-后端提示词.md

@@ -0,0 +1,98 @@
+# 水票配送订单：后端提示词（可直接发给后端）
+
+> 目标：把“水票下单后 -> 配送员接单/配送 -> 用户确认 -> 自动确认”的闭环放到后端，用明确的字段 + 状态机校验保证不越权、不乱跳状态、并发不重复接单。
+>
+> 接口前缀：当前后端控制器为 `@RequestMapping("/api/glt/glt-ticket-order")`，下文默认都带 `/api` 前缀（如需兼容旧路径，可做网关转发或保留旧路由）。
+
+## 0) 角色与权限边界（务必在后端兜底）
+- 用户端（小程序用户）：只能看/操作自己的订单（`userId` = token userId）。
+- 配送员端：只能看/操作分配给自己的订单（`riderId` = token userId / rider userId）。
+- 管理端：按后台权限控制（可查询/派单/改状态，但仍需 tenantId 隔离）。
+
+建议：对“配送员端接口”忽略前端传入的 `riderId/userId/tenantId`，统一从登录态注入，避免越权。
+
+## 1) 订单查询（配送员端）
+建议提供配送员专用分页接口：`GET /api/glt/glt-ticket-order/rider/page`（避免与后台管理分页混用）。
+请支持以下筛选，并保证权限隔离：
+- `deliveryStatus`：10待配送、20配送中、30待客户确认、40已完成（配送员端必要；不传默认=10）
+- `keywords`：支持按地址/备注等模糊搜索（可选）
+- 排序：建议默认 `sendTime asc, createTime desc`（或沿用后端默认排序，但请告知前端）
+
+权限隔离要求（配送员端）：
+- 只返回当前登录配送员的订单：后端强制 `param.riderId = loginUserId`（前端传不传都一样）。
+- `tenantId/deleted` 等同样后端兜底（只查当前租户、只查未删除）。
+
+返回字段建议（配送员端用得上）：
+- 门店/仓库/用户/配送员的展示字段：`storeName/storeAddress/storePhone`、`warehouseName/warehouseAddress`、`nickname/phone/avatar`、`riderName/riderPhone`（现有 `pageRel/listRel` 已在做关联返回）。
+- 导航相关（详见第 5 节）：收货地址 `lat/lng`、门店/仓库 `lngAndLat`（可关联返回或做快照字段）。
+
+## 2) 配送流程字段（建议后端落库并回传）
+订单表建议确保有以下字段（当前前端已按这些字段做流程判断/展示）：
+- `riderId/riderName/riderPhone`：配送员信息
+- `deliveryStatus`：10/20/30/40
+- `sendStartTime`：配送员点击“开始配送”的时间（建议 datetime）
+- `sendEndTime`：配送员点击“确认送达”的时间（建议 datetime）
+- `sendEndImg`：送达拍照留档图片 URL（可选/必填由后端策略决定；建议 varchar(512)）
+- `receiveConfirmTime`：客户确认收货时间（建议 datetime）
+- `receiveConfirmType`：10客户手动确认、20配送照片自动确认、30超时自动确认
+
+数据库变更（示例SQL见：`docs/sql/2026-02-06_glt_ticket_order_delivery_fields.sql`）。
+
+强烈建议把“配送状态”与“业务状态(status=0/1、deleted=0/1)”分开，避免混用：
+- `status/deleted`：系统通用字段（现有逻辑）
+- `deliveryStatus`：配送流程状态（本需求新增）
+
+## 3) 状态流转与校验（强烈建议在后端做）
+请在更新订单时做状态机校验，避免前端绕过流程：
+- `10 -> 20`：仅允许订单属于当前配送员，且未开始/未送达
+- `20 -> 30`：配送员确认送达（可带 `sendEndImg`）
+- `20/30 -> 40`：完成；来源可能是
+  - 客户手动确认（写 `receiveConfirmTime` + `receiveConfirmType=10`）
+  - 配送照片直接完成（写 `receiveConfirmTime` + `receiveConfirmType=20`，并要求 `sendEndImg`）
+  - 超时自动确认（写 `receiveConfirmTime` + `receiveConfirmType=30`，建议由定时任务执行）
+
+并发/幂等建议（避免重复点击/重复请求带来的脏数据）：
+- 所有“状态变更接口”用条件更新实现原子校验：`UPDATE ... SET ... WHERE id=? AND rider_id=? AND delivery_status=? AND deleted=0`
+- 对重复调用做幂等：
+  - `start`：如果已是 20 则直接返回成功；如果已到 30/40 返回“状态不允许”
+  - `delivered`：如果已是 30/40 则返回成功（或提示已送达）；避免重复写 `sendEndTime`
+  - `confirm-receive`：如果已是 40 则返回成功（或提示已完成）
+
+## 4) 建议新增/明确的接口能力
+为了避免并发抢单/越权更新，建议新增更语义化的接口（或在 update 内做等价校验）：
+- 接单（抢单/派单）：`POST /api/glt/glt-ticket-order/{id}/accept`
+  - 配送员端：后端原子校验：仅当 `rider_id IS NULL`（或为 0）时才能写入当前 rider 信息
+  - 管理端派单：允许传 `riderId`，但需校验骑手归属门店/租户（如有该约束）
+- 开始配送：`POST /api/glt/glt-ticket-order/{id}/start`
+  - 写：`sendStartTime=now`、`deliveryStatus=20`
+  - 校验：必须 `riderId=当前登录配送员` 且当前 `deliveryStatus=10`
+- 确认送达：`POST /api/glt/glt-ticket-order/{id}/delivered`
+  - 入参：`sendEndImg`（可选/必填，按策略）
+  - 写：`sendEndTime=now`、`deliveryStatus=30`、`sendEndImg`
+  - 可选策略 A（推荐可配置）：若 `sendEndImg` 必填且存在，则可直接 `deliveryStatus=40` 并写 `receiveConfirmTime/Type=20`
+- 客户确认收货：`POST /api/glt/glt-ticket-order/{id}/confirm-receive`
+  - 校验：只能本人 `userId` 操作，且必须 `deliveryStatus=30`
+  - 写：`deliveryStatus=40`、`receiveConfirmTime=now`、`receiveConfirmType=10`
+
+接口返回建议：
+- 成功统一返回 `ApiResult.success(...)`
+- 失败请返回明确 msg（例如：`无权限`、`订单不存在`、`订单状态不允许`、`订单已被其他配送员接单`）
+
+## 5) 为了“导航到收货地址/取货点”的字段补充（建议）
+当前仅有 `address` 字符串，无法在小程序内 `openLocation` 精准导航；建议补充：
+- 收货地址（推荐至少返回）：`receiverName`、`receiverPhone`、`province/city/region/address/fullAddress`、`lat/lng`
+- 取货点（门店/仓库，推荐至少返回）：`store.lngAndLat`、`warehouse.lngAndLat`
+
+实现方式二选一：
+- 方式 A（更快）：查询时关联 `shop_user_address`、`shop_store`、`shop_warehouse`，把经纬度字段透出给前端。
+- 方式 B（更稳）：下单时把收货地址的 `name/phone/lat/lng/fullAddress` 以及门店/仓库 `lngAndLat` 做快照写入订单，避免后续数据变更影响历史订单导航。
+
+## 6)（可选但很有用）超时自动确认规则
+- 建议后端提供可配置项：`autoConfirmHours`（例如 24h/48h）
+- 定时任务扫描：`deliveryStatus=30` 且 `sendEndTime < now - autoConfirmHours` 的订单
+- 原子更新：只更新仍处于 30 的订单，写入 `deliveryStatus=40`、`receiveConfirmTime=now`、`receiveConfirmType=30`
+
+## 7)（可选）字段/枚举建议（便于前后端对齐）
+- `deliveryStatus`：10待配送、20配送中、30待客户确认、40已完成
+- `receiveConfirmType`：10客户手动确认、20配送照片自动确认、30超时自动确认
+- 时间字段统一返回格式：`yyyy-MM-dd HH:mm:ss`（与项目现有 `@JsonFormat` 风格一致）

pom.xml

@@ -38,6 +38,11 @@
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <scope>test</scope>
+    </dependency>
 
     <!-- spring-boot-web -->
     <dependency>
@@ -213,8 +218,6 @@
       <artifactId>aliyun-java-sdk-core</artifactId>
       <version>4.4.3</version>
     </dependency>
-    <!-- 证件 OCR（身份证/营业执照识别）已改用百度云 REST 接口，不再依赖 aliyun-java-sdk-ocr：
-         理由见 ADR-0003《证件 OCR 改用百度云》，调用封装在 com.gxwebsoft.hjc.ocr.HjcBaiduOcrClient -->
     <!--阿里支付 老版本 SDK-->
     <dependency>
       <groupId>com.alipay.sdk</groupId>

scripts/fix-chinese-font.sh

@@ -1,125 +0,0 @@
-#!/bin/bash
-
-###############################################################################
-# 捐款证书中文乱码修复脚本
-# 用途：在运行中的Docker容器内安装中文字体
-# 适用于：无法重新构建镜像的紧急情况
-###############################################################################
-
-set -e  # 遇到错误立即退出
-
-# 颜色输出
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 容器名称（可根据实际情况修改）
-CONTAINER_NAME="websoft-api-container"
-
-echo -e "${GREEN}================================${NC}"
-echo -e "${GREEN}中文字体修复脚本${NC}"
-echo -e "${GREEN}================================${NC}"
-echo ""
-
-# 检查容器是否存在
-echo -e "${YELLOW}步骤 1/6: 检查容器状态...${NC}"
-if ! docker ps | grep -q "$CONTAINER_NAME"; then
-    echo -e "${RED}错误：容器 $CONTAINER_NAME 未运行！${NC}"
-    echo "当前运行的容器："
-    docker ps --format "table {{.Names}}\t{{.Status}}"
-    echo ""
-    read -p "请输入正确的容器名称: " CONTAINER_NAME
-    if [ -z "$CONTAINER_NAME" ]; then
-        echo -e "${RED}容器名称不能为空，退出。${NC}"
-        exit 1
-    fi
-fi
-echo -e "${GREEN}✓ 容器正在运行${NC}"
-echo ""
-
-# 检查是否已安装字体
-echo -e "${YELLOW}步骤 2/6: 检查是否已安装中文字体...${NC}"
-if docker exec "$CONTAINER_NAME" fc-list :lang=zh 2>/dev/null | grep -q "WenQuanYi"; then
-    echo -e "${GREEN}✓ 中文字体已安装${NC}"
-    docker exec "$CONTAINER_NAME" fc-list :lang=zh
-    echo ""
-    read -p "是否重新安装？(y/N): " REINSTALL
-    if [[ ! "$REINSTALL" =~ ^[Yy]$ ]]; then
-        echo "跳过安装，退出。"
-        exit 0
-    fi
-else
-    echo -e "${YELLOW}未检测到中文字体，开始安装...${NC}"
-fi
-echo ""
-
-# 安装字体工具
-echo -e "${YELLOW}步骤 3/6: 安装字体工具...${NC}"
-docker exec -u root "$CONTAINER_NAME" sh -c "apk add --no-cache fontconfig ttf-dejavu wget" || {
-    echo -e "${RED}✗ 字体工具安装失败${NC}"
-    exit 1
-}
-echo -e "${GREEN}✓ 字体工具安装成功${NC}"
-echo ""
-
-# 下载中文字体
-echo -e "${YELLOW}步骤 4/6: 下载文泉驿微米黑字体...${NC}"
-echo "正在从GitHub下载（约10MB），请稍候..."
-docker exec -u root "$CONTAINER_NAME" sh -c "
-    wget -O /tmp/wqy-microhei.ttc https://github.com/anthonyfok/fonts-wqy-microhei/raw/master/wqy-microhei.ttc 2>&1 | grep -E 'Connecting|Length|saved' || true
-" || {
-    echo -e "${YELLOW}GitHub下载失败，尝试使用代理...${NC}"
-    docker exec -u root "$CONTAINER_NAME" sh -c "
-        wget -O /tmp/wqy-microhei.ttc https://ghproxy.com/https://github.com/anthonyfok/fonts-wqy-microhei/raw/master/wqy-microhei.ttc
-    " || {
-        echo -e "${RED}✗ 字体下载失败${NC}"
-        echo "请检查网络连接或手动下载字体文件。"
-        exit 1
-    }
-}
-echo -e "${GREEN}✓ 字体下载成功${NC}"
-echo ""
-
-# 安装字体
-echo -e "${YELLOW}步骤 5/6: 安装字体文件...${NC}"
-docker exec -u root "$CONTAINER_NAME" sh -c "
-    mkdir -p /usr/share/fonts/truetype/wqy && \
-    mv /tmp/wqy-microhei.ttc /usr/share/fonts/truetype/wqy/ && \
-    fc-cache -fv
-" || {
-    echo -e "${RED}✗ 字体安装失败${NC}"
-    exit 1
-}
-echo -e "${GREEN}✓ 字体安装成功${NC}"
-echo ""
-
-# 验证安装
-echo -e "${YELLOW}步骤 6/6: 验证字体安装...${NC}"
-FONT_COUNT=$(docker exec "$CONTAINER_NAME" fc-list :lang=zh | wc -l)
-if [ "$FONT_COUNT" -gt 0 ]; then
-    echo -e "${GREEN}✓ 中文字体验证成功！${NC}"
-    echo "已安装的中文字体："
-    docker exec "$CONTAINER_NAME" fc-list :lang=zh
-else
-    echo -e "${RED}✗ 字体验证失败${NC}"
-    exit 1
-fi
-echo ""
-
-# 完成提示
-echo -e "${GREEN}================================${NC}"
-echo -e "${GREEN}修复完成！${NC}"
-echo -e "${GREEN}================================${NC}"
-echo ""
-echo "后续步骤："
-echo "1. 不需要重启容器，字体已生效"
-echo "2. 重新生成捐款证书即可看到效果"
-echo "3. 如果仍有问题，请查看容器日志："
-echo "   docker logs -f $CONTAINER_NAME"
-echo ""
-echo -e "${YELLOW}注意：${NC}"
-echo "- 此修复方法在容器重启后会失效"
-echo "- 建议后续使用更新后的Dockerfile重新构建镜像"
-echo "- 详细文档请参考：docs/chinese-font-fix-guide.md"
-echo ""

scripts/generate-nanning-knowledge-seed.js

@@ -1,546 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const projectRoot = path.resolve(__dirname, '..');
-const sqlDirectory = path.join(projectRoot, 'src', 'main', 'resources', 'sql');
-const dataPath = path.join(sqlDirectory, '南宁房产知识库结构化表格.json');
-const seedPath = path.join(sqlDirectory, 'house_knowledge_seed.sql');
-const startMarker = '-- NANNING_STRUCTURED_DATA_START';
-const endMarker = '-- NANNING_STRUCTURED_DATA_END';
-const sourceNote = '本地业务资料《南宁房产知识库结构化表格.json》导入，待后台复核';
-
-const data = JSON.parse(fs.readFileSync(dataPath, 'utf8'));
-const offices = data['南宁写字楼信息表'] || [];
-const communities = data['南宁住宅小区信息表'] || [];
-const businessDistrictOverrides = {
-  '五象航洋城': '五象航洋城商圈'
-};
-const officialLocationEntries = [
-  {
-    region: '青秀区', businessDistrict: '青秀万达',
-    title: '滨湖路站连接青秀万达与南湖公共配套',
-    content: '南宁轨道交通3号线滨湖路站位于滨湖路与长湖路交汇处，北邻青秀万达、南近南湖公园。B口周边有南湖公园和南宁市卫生健康委员会，C口周边有南宁市第二妇幼保健院、南宁市口腔医院，D口周边有南宁市第五十四中学、埌东小学。',
-    tags: ['轨道交通', '商业配套', '公园绿地', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《滨湖路站》 http://www.nngdjt.com/html/service1c/line/0313.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '东盟商务区',
-    title: '万象城站的商业、办公与公园配套',
-    content: '南宁轨道交通1号线万象城站位于东盟商务区核心区，设置在民族大道与青秀路、景秀路交叉路口地下。运营方列示，A口连接水电大厦等办公区，C口可通向万象城购物消费中心，B口周边有石门森林公园和多个居住小区。',
-    tags: ['轨道交通', '商业配套', '商务办公', '公园绿地'],
-    sourceNote: '南宁轨道交通集团有限责任公司《万象城站》 http://www.nngdjt.com/html/service1c/line/0119.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '东盟商务区',
-    title: '东盟商务区站周边商业、金融与社区卫生服务',
-    content: '南宁轨道交通1号线东盟商务区站位于民族大道北侧。运营方列示，A、D口靠近凤岭儿童公园，B、C口周边有三祺广场、广西金融广场、东盟财经中心、东盟盛天地等商业和办公配套；D口周边有青秀区南湖凤岭北社区卫生服务中心。',
-    tags: ['轨道交通', '商业配套', '商务办公', '公园绿地', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《东盟商务区站》 http://www.nngdjt.com/html/service1c/line/0120.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '凤岭北',
-    title: '凤岭儿童公园的公园绿地与休闲配套',
-    content: '凤岭儿童公园位于南宁市青秀区凤岭片区北侧核心区，北临月湾路、南面云景路，与凤岭冲沟相邻，占地834亩。政府页面记载，公园建设包括园内道路、基础绿化、园林构筑、广场铺装、公共设施和配套服务设施。',
-    tags: ['公园绿地', '文化休闲', '运动健身'],
-    sourceNote: '南宁市人民政府《凤岭儿童公园》 https://www.nanning.gov.cn/zjnn/nnly/t2566232.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '凤岭北',
-    title: '凤岭站连接凤岭居住区、教育与公园',
-    content: '南宁轨道交通1号线凤岭站位于凤岭立交以东、民族大道北侧。运营方列示，B1口周边有南宁市第一幼儿园青林分园，B2口周边有南宁市翡翠园学校，C口通向埌东公园；埌东客运站位于车站以东约900米处。',
-    tags: ['轨道交通', '公共服务', '公园绿地'],
-    sourceNote: '南宁轨道交通集团有限责任公司《凤岭站》 http://www.nngdjt.com/html/service1c/line/0121.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '埌东客运站片区',
-    title: '埌东客运站的公路客运与地铁接驳',
-    content: '埌东客运站位于民族大道东端与仙葫大道交叉处，地面上方为埌东汽车客运站。站点B、C口对应客运站一侧，E口周边为市公交总站，可作为片区公路客运、公交与地铁接驳信息使用。',
-    tags: ['轨道交通', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《埌东客运站》 http://www.nngdjt.com/html/service1c/line/0122.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '会展中心',
-    title: '会展中心站与航洋国际城及会展配套',
-    content: '会展中心站位于民族大道与会展路交叉路口。B、B1口通往南宁国际会展中心，D口无缝连接航洋国际城；官方资料将该站周边规划概括为居住、商业及行政办公用地。',
-    tags: ['轨道交通', '商业配套', '商务办公', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《会展中心站》 http://www.nngdjt.com/html/service1c/line/0118.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '南湖片区',
-    title: '南湖站周边绿地、政务与金融办公配套',
-    content: '南湖站位于南湖大桥东端、南湖公园绿地内。A口周边有南宁市人民政府，B口通往南湖公园，C口周边列有自治区税务局、自治区发展和改革委员会及多家银行。',
-    tags: ['轨道交通', '公园绿地', '商务办公', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《南湖站》 http://www.nngdjt.com/html/service1c/line/0116.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '金湖片区',
-    title: '金湖广场站的双线换乘与民歌湖配套',
-    content: '金湖广场站位于金湖东环路与民族大道交叉口，是1号线与3号线换乘站。站点周边包括金湖广场、民歌湖、南宁书城、购物中心、金融机构、南宁市政务服务中心及南宁十四中埌东校区。',
-    tags: ['轨道交通', '商业配套', '文化休闲', '商务办公', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《金湖广场站》 http://www.nngdjt.com/html/service1c/line/0314.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '凤岭南-青秀山片区',
-    title: '青秀山站与青秀山西门、青秀湖公园',
-    content: '青秀山站设置4个出入口，B口位于青秀山风景区西门及青秀山管委会一侧；A1口周边包括青秀湖公园。A3口设置无障碍电梯，周边有多条公交线路。',
-    tags: ['轨道交通', '公园绿地', '文化休闲', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《青秀山站》 http://www.nngdjt.com/html/service1c/line/0317.html'
-  },
-  {
-    region: '良庆区', businessDistrict: '市博物馆片区',
-    title: '市博物馆站与文化艺术中心配套',
-    content: '市博物馆站位于博艺路与彩凤路交叉路口，A口周边为广西文化艺术中心，D口周边为南宁市博物馆、金龙路小学及良庆区金龙幼儿园。',
-    tags: ['轨道交通', '文化休闲', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《市博物馆》 http://www.nngdjt.com/html/service1c/line/0318.html'
-  },
-  {
-    region: '江南区', businessDistrict: '江南万达',
-    title: '亭洪路沿线的商业、文化与公园节点',
-    content: '南宁市公开报道将亭洪路描述为江南区城市商贸业和文化旅游的主轴线，并列示江南万达商圈、百益·上河城、华润江南中心、江南公园、广西海吉星、火车南站和国际铁路港等节点分布在亭洪路两侧及周边。报道同时记载，亭洪路延长线建成后将江南万达商圈与沙井商圈连接起来。',
-    tags: ['商业配套', '文化休闲', '公园绿地', '商务办公'],
-    sourceNote: '南宁市人民政府《江南区发达路网赋能产城高度融合发展》 https://www.nanning.gov.cn/ywzx/xqdt/2022xqdt/t5048033.html'
-  },
-  {
-    region: '江南区', businessDistrict: '江南公园片区',
-    title: '江南公园的生态与文化休闲节点',
-    content: '南宁市江南公园位于壮锦大道17号、紧邻江南区政府，西邻壮锦大道、东接金华路、北靠亭洪路延长线及湘桂铁路线。政府页面记载，公园总面积798亩，于2018年6月正式对外开放，以休闲、生态、文化为主旨，是市级综合性城市公园。',
-    tags: ['公园绿地', '文化休闲', '公共服务'],
-    sourceNote: '南宁市文化广电和旅游局《南宁市江南公园》 https://www.nanning.gov.cn/zjnn/nnly/t4137277.html'
-  },
-  {
-    region: '江南区', businessDistrict: '亭子码头片区',
-    title: '邕江亭子码头滨水公共空间',
-    content: '南宁市政府公开报道记载，邕江亭子码头于2019年1月正式对市民开放，码头岸线长约500米；报道将其定位为面向邕江观景的滨水码头节点。',
-    tags: ['文化休闲', '公共服务'],
-    sourceNote: '南宁市人民政府《邕江亭子码头正式开放》 https://www.nanning.gov.cn/ywzx/nnyw/2019nzwdt/t1593403.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '西乡塘大学东路',
-    title: '广西大学站的高校、社区与公共服务节点',
-    content: '南宁轨道交通1号线广西大学站位于大学东路与明秀西路交汇处下方。运营方列示，B1口周边有城市碧园、时代天骄和南宁高级技工学校，C口周边有南宁市第二小学，D口周边有西乡塘街道办事处和五里亭第一小学，F口周边有广西大学南门。',
-    tags: ['轨道交通', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《广西大学站》 http://www.nngdjt.com/html/service1c/line/0109.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '西乡塘大学东路',
-    title: '鲁班路站的学校、医疗与公园节点',
-    content: '南宁轨道交通1号线鲁班路站位于大学东路与鲁班路交汇处下方。运营方列示，A口周边有明月湖公园、南宁市第二十中学和南宁市公安局西乡塘分局，B口周边有广西大学。',
-    tags: ['轨道交通', '公园绿地', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《鲁班路站》 http://www.nngdjt.com/html/service1c/line/0108.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '相思湖片区',
-    title: '民族大学站的高校与基层医疗节点',
-    content: '南宁轨道交通1号线民族大学站位于大学东路与新村大道交叉路口，沿大学东路设置。运营方列示，车站西北侧有西乡塘卫生院，东北侧有广西民族大学和相思湖国际大酒店，西南侧有广西交通运输学校、广西外国语学校，东南侧有广西机电职业技术学院、广西社会主义学院和西乡塘派出所。',
-    tags: ['轨道交通', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《民族大学站》 http://www.nngdjt.com/html/service1c/line/0105.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '南宁动物园片区',
-    title: '动物园站的亲子科普主题公共空间',
-    content: '南宁市2026年公开报道记载，南宁地铁1号线动物园站毗邻南宁动物园，并由南宁市动物园与南宁地铁围绕动物文化、科普教育和儿童友好理念打造主题车站；站内设置动物IP科普墙、动物主题儿童休息区和小象主题母婴室等场景。',
-    tags: ['轨道交通', '文化休闲', '公共服务'],
-    sourceNote: '南宁市人民政府《IP内容+空间资源 南宁地铁1号线动物园站化身童趣乐园》 https://www.nanning.gov.cn/ywzx/tpxw/t6647075.html'
-  },
-  {
-    region: '兴宁区', businessDistrict: '兴宁老城区',
-    title: '三街两巷历史文化街区',
-    content: '南宁市三街两巷历史街区是南宁主城区规模最大的历史文化街区，由解放路、兴宁路、民生路三条老街和金狮巷、银狮巷两条古巷组成，汇聚文物保护单位及历史建筑，是近代南宁较集中的骑楼建筑片区。',
-    tags: ['文化休闲', '商业配套'],
-    sourceNote: '南宁市人民政府《历史文化街区“三街两巷”露芳容》 https://www.nanning.gov.cn/zjnn/mswh/t1526950.html'
-  },
-  {
-    region: '邕宁区', businessDistrict: '龙岗',
-    title: '轨道交通4号线后通段接入龙岗',
-    content: '南宁市公开报道记载，2025年9月轨道交通4号线一期工程后通段（楞塘村站至龙岗站）开通运营，龙岗站成为该后通段终点站，邕宁区由此接入轨道交通网络。',
-    tags: ['轨道交通'],
-    sourceNote: '邕宁区人民政府《喜大普奔！地铁4号线后通段开通运营，邕宁迈入“地铁时代”！》 https://www.nanning.gov.cn/ywzx/xqdt/2025nxqdt/t6428425.html'
-  },
-  {
-    region: '邕宁区', businessDistrict: '园博园片区',
-    title: '南宁园博园的园林与文化展示节点',
-    content: '南宁园博园是第十二届中国国际园林博览会举办地，位于邕宁区八尺江畔顶蛳山地块，占地276公顷，2018年12月建成开放。政府页面记载，园内有新石器时代文化遗址、丘陵与原生山林、湖塘和湿地，并设中华城市展园、东盟园、丝路园、广西园、设计师园和企业园等主题展园区。',
-    tags: ['公园绿地', '文化休闲'],
-    sourceNote: '南宁市人民政府《南宁园博园》 https://www.nanning.gov.cn/zjnn/nnly/t2566279.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '埌西片区',
-    title: '埌西站周边教育、人社与生活服务',
-    content: '埌西站位于金湖路与桂春路交叉路口。站点周边列有南宁市教育局、南宁市人力资源和社会保障局、南宁市民政局、广西疾病预防控制中心、埌西综合市场、人才市场及多所学校。',
-    tags: ['轨道交通', '公共服务', '商业配套'],
-    sourceNote: '南宁轨道交通集团有限责任公司《埌西站》 http://www.nngdjt.com/html/service1c/line/0315.html'
-  }
-];
-
-if (sourceNote.length > 500 || officialLocationEntries.some((item) => item.sourceNote.length > 500)) {
-  throw new Error('知识条目的来源说明超过数据库字段长度');
-}
-
-function sql(value) {
-  if (value === null || value === undefined) {
-    return 'NULL';
-  }
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-
-function known(value) {
-  return value !== undefined && value !== null && String(value).trim() !== ''
-    && String(value).trim() !== '待定';
-}
-
-function exactNumber(value) {
-  const text = String(value || '').trim();
-  return /^\d+(?:\.\d+)?$/.test(text) ? text : null;
-}
-
-function businessDistrictName(item) {
-  return businessDistrictOverrides[item['楼盘名称']] || item['所属商圈'];
-}
-
-function text(parts) {
-  return parts.filter(([_, value]) => known(value))
-    .map(([label, value]) => `${label}：${value}`)
-    .join('；');
-}
-
-function locationFilter(item) {
-  return [
-    'FROM house_knowledge_location community',
-    'JOIN house_knowledge_location business_district',
-    '  ON business_district.location_id = community.parent_location_id',
-    'WHERE community.tenant_id = @house_knowledge_tenant_id',
-    "  AND community.city = '南宁'",
-    "  AND community.location_type = 'community'",
-    `  AND community.location_name = ${sql(item['楼盘名称'])}`,
-    '  AND community.deleted = 0',
-    '  AND business_district.tenant_id = @house_knowledge_tenant_id',
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(businessDistrictName(item))}`,
-    '  AND business_district.deleted = 0'
-  ].join('\n');
-}
-
-function tagInsert(topic, item, tags) {
-  const values = [...tags].filter(Boolean).map(sql).join(', ');
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry_tag (entry_id, tag_id, tenant_id)',
-    'SELECT entry.entry_id, tag.tag_id, @house_knowledge_tenant_id',
-    'FROM house_knowledge_entry entry',
-    'JOIN house_knowledge_location community ON community.location_id = entry.location_id',
-    'JOIN house_knowledge_location business_district',
-    '  ON business_district.location_id = community.parent_location_id',
-    'JOIN house_knowledge_tag tag ON tag.tenant_id = @house_knowledge_tenant_id',
-    '  AND tag.deleted = 0',
-    'WHERE entry.tenant_id = @house_knowledge_tenant_id',
-    '  AND entry.deleted = 0',
-    '  AND entry.status = 0',
-    `  AND entry.topic = ${sql(topic)}`,
-    `  AND entry.source_note = ${sql(sourceNote)}`,
-    "  AND community.city = '南宁'",
-    "  AND community.location_type = 'community'",
-    `  AND community.location_name = ${sql(item['楼盘名称'])}`,
-    `  AND business_district.location_name = ${sql(businessDistrictName(item))}`,
-    `  AND tag.tag_name IN (${values});`
-  ].join('\n');
-}
-
-function entryInsert(item, topic, title, content, fields) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry (',
-    '    location_id, topic, title, content, property_company, property_fees,',
-    '    water_billing_type, water_unit_price, electricity_billing_type, electricity_unit_price,',
-    '    parking_available, parking_fee, verified_date, source_note, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    '    community.location_id,',
-    `    ${sql(topic)},`,
-    `    ${sql(title)},`,
-    `    ${sql(content || null)},`,
-    `    ${sql(fields.propertyCompany)},`,
-    `    ${fields.propertyFees || 'NULL'},`,
-    `    ${sql(fields.waterBillingType)},`,
-    `    ${fields.waterUnitPrice || 'NULL'},`,
-    `    ${sql(fields.electricityBillingType)},`,
-    `    ${fields.electricityUnitPrice || 'NULL'},`,
-    `    ${fields.parkingAvailable === null ? 'NULL' : fields.parkingAvailable ? '1' : '0'},`,
-    `    ${sql(fields.parkingFee)},`,
-    '    CURDATE(),',
-    `    ${sql(sourceNote)},`,
-    '    0, @house_knowledge_tenant_id, 0',
-    locationFilter(item) + ';'
-  ].join('\n');
-}
-
-function parkingAvailable(item) {
-  if (item['地下停车场'] === '有') {
-    return true;
-  }
-  if (item['地下停车场'] === '无') {
-    return false;
-  }
-  return known(item['停车位数量']) ? true : null;
-}
-
-function entryBlocks(item, type) {
-  const name = item['楼盘名称'];
-  const typeTag = type === 'office' ? '写字楼' : '住宅小区';
-  const propertyContent = text([
-    ['物业类型', item['物业类型']],
-    ['物业公司', item['物业公司']],
-    ['物业费标准', item['物业费标准(元/㎡/月)']],
-    ['物业服务时间', item['物业服务时间']],
-    ['内部配套', item['内部配套']],
-    ['总层数', item['总层数']],
-    ['建成年份', item['建成年份']],
-    ['产权年限', item['产权年限']],
-    ['备注', item['备注']]
-  ]);
-  const utilitiesContent = text([
-    ['水电类型', item['水电类型']],
-    ['水费标准', item['水费标准(元/吨)']],
-    ['电费标准', item['电费标准(元/度)']],
-    ['24小时供水供电', item['24小时供水供电']]
-  ]);
-  const parkingContent = text([
-    ['停车位数量', item['停车位数量']],
-    ['车位配比', item['车位配比']],
-    ['地下停车场', item['地下停车场']],
-    ['充电桩配置', item['充电桩配置']],
-    ['临停收费标准', item['临停收费标准']],
-    ['月保收费标准', item['月保收费标准']]
-  ]);
-  const otherContent = text([
-    ['所属区域', item['所属区域']],
-    ['详细地址', item['详细地址']],
-    ['所属商圈', businessDistrictName(item)],
-    ['周边配套', item['周边配套']]
-  ]);
-  const propertyTags = new Set(['物业服务', typeTag]);
-  const utilitiesTags = new Set(['水电计费', typeTag]);
-  const parkingTags = new Set(['停车信息', typeTag]);
-  const otherTags = new Set(['商业配套', typeTag]);
-  if (item['物业服务时间'] === '24小时') {
-    propertyTags.add('24小时服务');
-  }
-  if (item['充电桩配置'] === '有') {
-    parkingTags.add('充电设施');
-  }
-  if (String(item['周边配套'] || '').includes('地铁')) {
-    otherTags.add('轨道交通');
-    otherTags.add('地铁出行');
-  }
-  if (type === 'office') {
-    otherTags.add('商务办公');
-  }
-
-  return [
-    entryInsert(item, 'property', `${name}的物业服务`, propertyContent, {
-      propertyCompany: known(item['物业公司']) ? item['物业公司'] : null,
-      propertyFees: exactNumber(item['物业费标准(元/㎡/月)']),
-      waterBillingType: null,
-      waterUnitPrice: null,
-      electricityBillingType: null,
-      electricityUnitPrice: null,
-      parkingAvailable: null,
-      parkingFee: null
-    }),
-    tagInsert('property', item, propertyTags),
-    entryInsert(item, 'utilities', `${name}的水电计费`, utilitiesContent, {
-      propertyCompany: null,
-      propertyFees: null,
-      waterBillingType: known(item['水电类型']) ? item['水电类型'] : null,
-      waterUnitPrice: exactNumber(item['水费标准(元/吨)']),
-      electricityBillingType: known(item['水电类型']) ? item['水电类型'] : null,
-      electricityUnitPrice: exactNumber(item['电费标准(元/度)']),
-      parkingAvailable: null,
-      parkingFee: null
-    }),
-    tagInsert('utilities', item, utilitiesTags),
-    entryInsert(item, 'parking', `${name}的停车与充电`, parkingContent, {
-      propertyCompany: null,
-      propertyFees: null,
-      waterBillingType: null,
-      waterUnitPrice: null,
-      electricityBillingType: null,
-      electricityUnitPrice: null,
-      parkingAvailable: parkingAvailable(item),
-      parkingFee: text([
-        ['临停', item['临停收费标准']],
-        ['月保', item['月保收费标准']]
-      ]) || null
-    }),
-    tagInsert('parking', item, parkingTags),
-    entryInsert(item, 'other', `${name}的地段与周边配套`, otherContent, {
-      propertyCompany: null,
-      propertyFees: null,
-      waterBillingType: null,
-      waterUnitPrice: null,
-      electricityBillingType: null,
-      electricityUnitPrice: null,
-      parkingAvailable: null,
-      parkingFee: null
-    }),
-    tagInsert('other', item, otherTags)
-  ];
-}
-
-function officialLocationInsert(item) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    `    '南宁', 'business_district', ${sql(item.businessDistrict)}, region.location_id,`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location region',
-    'WHERE region.tenant_id = @house_knowledge_tenant_id',
-    "  AND region.city = '南宁'",
-    "  AND region.location_type = 'region'",
-    `  AND region.location_name = ${sql(item.region)}`,
-    '  AND region.deleted = 0',
-    '  AND NOT EXISTS (',
-    '      SELECT 1 FROM house_knowledge_location existing',
-    '      WHERE existing.tenant_id = @house_knowledge_tenant_id',
-    "        AND existing.city = '南宁'",
-    "        AND existing.location_type = 'business_district'",
-    `        AND existing.location_name = ${sql(item.businessDistrict)}`,
-    '        AND existing.deleted = 0',
-    '  );'
-  ].join('\n');
-}
-
-function officialEntryInsert(item) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry (',
-    '    location_id, topic, title, content, verified_date, source_note,',
-    '    status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    '    business_district.location_id,',
-    "    'other',",
-    `    ${sql(item.title)},`,
-    `    ${sql(item.content)},`,
-    "    '2026-08-02',",
-    `    ${sql(item.sourceNote)},`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location business_district',
-    'WHERE business_district.tenant_id = @house_knowledge_tenant_id',
-    "  AND business_district.city = '南宁'",
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(item.businessDistrict)}`,
-    '  AND business_district.deleted = 0;'
-  ].join('\n');
-}
-
-function officialTagInsert(item) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry_tag (entry_id, tag_id, tenant_id)',
-    'SELECT entry.entry_id, tag.tag_id, @house_knowledge_tenant_id',
-    'FROM house_knowledge_entry entry',
-    'JOIN house_knowledge_location business_district ON business_district.location_id = entry.location_id',
-    'JOIN house_knowledge_tag tag ON tag.tenant_id = @house_knowledge_tenant_id',
-    '  AND tag.deleted = 0',
-    'WHERE entry.tenant_id = @house_knowledge_tenant_id',
-    '  AND entry.deleted = 0',
-    '  AND entry.status = 0',
-    "  AND entry.topic = 'other'",
-    `  AND entry.source_note = ${sql(item.sourceNote)}`,
-    "  AND business_district.city = '南宁'",
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(item.businessDistrict)}`,
-    `  AND tag.tag_name IN (${item.tags.map(sql).join(', ')});`
-  ].join('\n');
-}
-
-const records = [
-  ...offices.map((item) => ({ item, type: 'office' })),
-  ...communities.map((item) => ({ item, type: 'community' }))
-];
-const regions = [...new Set(records.map(({ item }) => item['所属区域']).filter(known))];
-const districts = [...new Map(records
-  .filter(({ item }) => known(item['所属区域']) && known(businessDistrictName(item)))
-  .map(({ item }) => [`${item['所属区域']}\u0000${businessDistrictName(item)}`, item])).values()];
-
-const lines = [
-  '-- 以下数据由南宁房产知识库结构化表格.json 和官方公开资料生成。',
-  `-- 共 ${offices.length} 个写字楼、${communities.length} 个住宅小区和 ${officialLocationEntries.length} 条官方片区知识；来源说明仅后台可见。`,
-  ''
-];
-
-for (const region of regions) {
-  lines.push([
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ') VALUES (',
-    `    '南宁', 'region', ${sql(region)}, 0, 0, @house_knowledge_tenant_id, 0`,
-    ');',
-    ''
-  ].join('\n'));
-}
-
-for (const item of districts) {
-  lines.push([
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    `    '南宁', 'business_district', ${sql(businessDistrictName(item))}, region.location_id,`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location region',
-    'WHERE region.tenant_id = @house_knowledge_tenant_id',
-    "  AND region.city = '南宁'",
-    "  AND region.location_type = 'region'",
-    `  AND region.location_name = ${sql(item['所属区域'])}`,
-    '  AND region.deleted = 0',
-    '  AND NOT EXISTS (',
-    '      SELECT 1 FROM house_knowledge_location existing',
-    '      WHERE existing.tenant_id = @house_knowledge_tenant_id',
-    "        AND existing.city = '南宁'",
-    "        AND existing.location_type = 'business_district'",
-    `        AND existing.location_name = ${sql(businessDistrictName(item))}`,
-    '        AND existing.deleted = 0',
-    '  );',
-    ''
-  ].join('\n'));
-}
-
-for (const item of officialLocationEntries) {
-  lines.push(officialLocationInsert(item), '');
-}
-
-for (const { item } of records) {
-  lines.push([
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    `    '南宁', 'community', ${sql(item['楼盘名称'])}, business_district.location_id,`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location business_district',
-    'WHERE business_district.tenant_id = @house_knowledge_tenant_id',
-    "  AND business_district.city = '南宁'",
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(businessDistrictName(item))}`,
-    '  AND business_district.deleted = 0;',
-    ''
-  ].join('\n'));
-}
-
-for (const { item, type } of records) {
-  lines.push(...entryBlocks(item, type), '');
-}
-
-for (const item of officialLocationEntries) {
-  lines.push(officialEntryInsert(item), officialTagInsert(item), '');
-}
-
-const seed = fs.readFileSync(seedPath, 'utf8');
-const start = seed.indexOf(startMarker);
-const end = seed.indexOf(endMarker);
-if (start < 0 || end < 0 || end < start) {
-  throw new Error('未找到南宁结构化数据生成区段标记');
-}
-
-const generated = `${startMarker}\n${lines.join('\n')}${endMarker}`;
-fs.writeFileSync(seedPath, `${seed.slice(0, start)}${generated}${seed.slice(end + endMarker.length)}`, 'utf8');
-console.log(`已生成 ${records.length} 个地点的房源知识种子数据。`);

scripts/hjc_test_push.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-汇吉采 <-- 一站式：推送标书项目测试脚本（入向 POST /api/hjc/push/project）
-
-用法:
-    python hjc_test_push.py                     # 默认 http://uk.frp.one:62335
-    python hjc_test_push.py http://uk.frp.one:62335
-    python hjc_test_push.py --base http://uk.frp.one:62335 --project-no TEST-xxx
-
-无第三方依赖，仅标准库（hashlib + urllib）。时间用北京时间(UTC+8)。
-签名 sign = MD5(appKey + password + timestamp)，timestamp = yyyyMMddHHmm。
-"""
-import sys
-import json
-import hashlib
-import urllib.request
-import urllib.error
-import datetime
-
-APP_KEY = "HJC_Official_Website"
-PASSWORD = "vQ8$kR3#mW6@xP2!nF"
-DEFAULT_BASE = "http://uk.frp.one:62335"
-
-DEFAULT_PAYLOAD = {
-    "projectNo": "TEST-HJC-20260801",
-    "projectName": "测试标书项目·服务器采购",
-    "category": "货物类",
-    "tenderPrice": 500.00,
-    "files": "[{\"name\":\"招标文件.pdf\",\"url\":\"https://file.example.com/t.pdf\"}]",
-    "tenderOnsaleTime": "2026-08-01 09:00:00",
-    "tenderOffsaleTime": "2026-08-10 17:00:00",
-    "bulletinName": "中标公告-测试",
-    "customerName": "某招标单位",
-    "supplierName": "某中标公司",
-    "bidAmount": 128000.00,
-    "content": "测试公告正文。中标供应商：某中标公司，中标金额 128000 元。",
-    "fileList": "[{\"name\":\"中标通知书.pdf\",\"url\":\"https://file.example.com/n.pdf\"}]",
-    "needSellTender": 1,
-    "sellingMethod": 2
-}
-
-
-def bj_now() -> str:
-    """北京时间 yyyyMMddHHmm"""
-    return (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=8)).strftime("%Y%m%d%H%M")
-
-
-def main():
-    base = DEFAULT_BASE
-    payload = dict(DEFAULT_PAYLOAD)
-    args = sys.argv[1:]
-    i = 0
-    while i < len(args):
-        a = args[i]
-        if a in ("--base", "-b"):
-            base = args[i + 1]
-            i += 2
-        elif a in ("--project-no", "-p"):
-            payload["projectNo"] = args[i + 1]
-            i += 2
-        elif a == "--json":
-            with open(args[i + 1], encoding="utf-8") as f:
-                payload = json.load(f)
-            i += 2
-        else:
-            base = a  # 位置参数作为 baseUrl
-            i += 1
-
-    url = base.rstrip("/") + "/api/hjc/push/project"
-    ts = bj_now()
-    sign = hashlib.md5((APP_KEY + PASSWORD + ts).encode("utf-8")).hexdigest()
-    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-
-    req = urllib.request.Request(url, data=body, method="POST", headers={
-        "Content-Type": "application/json; charset=utf-8",
-        "appKey": APP_KEY,
-        "timestamp": ts,
-        "sign": sign,
-        "tenantId": "10626"
-    })
-
-    print("== 请求 ==")
-    print("URL:", url)
-    print("timestamp:", ts, "| sign:", sign)
-    print("body:", body.decode("utf-8"))
-    print()
-    print("== 响应 ==")
-    try:
-        with urllib.request.urlopen(req, timeout=20) as resp:
-            print("HTTP", resp.status)
-            print(resp.read().decode("utf-8"))
-    except urllib.error.HTTPError as e:
-        print("HTTP", e.code)
-        print(e.read().decode("utf-8"))
-    except Exception as e:
-        print("ERROR:", type(e).__name__, e)
-
-
-if __name__ == "__main__":
-    main()

scripts/hjc_test_push_out.py

@@ -1,657 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-汇吉采 → 一站式：**出向**推送联调探测脚本（POST {base-url}{create-purchase-details-path}）
-
-与同目录 hjc_test_push.py（入向：一站式 → 官方网 /api/hjc/push/project）互为反向。
-
-用途：一条命令回答「出向对接到底通没通、卡在哪一层」。
-脚本会自动做三件事：
-  1. 按文档约定的签名方案（sign = MD5(appKey + password + timestamp)）发起真实推送；
-  2. 额外遍历若干鉴权头变体（含 password 明文头等历史解读），用于区分「签名不对」与「根本没校验签名」；
-  3. 用对照探测把失败定位到具体一层：登录过滤器 / 路由不存在 / 验签失败 / 网络不可达。
-
-默认参数自动从仓库读取，避免与代码脱节：
-  - application.yml            → hjc.one-stop.base-url、create-purchase-details-path
-  - HjcOneStopAuthUtil.java    → APP_KEY、PASSWORD
-
-用法::
-
-    python hjc_test_push_out.py                      # 全量：约定方案 + 变体矩阵 + 对照探测
-    python hjc_test_push_out.py --quick              # 只打约定方案（日常回归用）
-    python hjc_test_push_out.py --repeat 3           # 约定方案连打 3 次（同一订单号，验幂等）
-    python hjc_test_push_out.py --base http://x:8810 --path /api/biz/createPurchaseDetails
-    python hjc_test_push_out.py --order-no HJC2026080101ABCD --json result.json
-    python hjc_test_push_out.py --dry-run            # 只打印将要发出的请求，不真的发
-
-订单号默认是固定值 ``TEST-HJC-ORDER-20260801``（不随时间变化）：它同时是一站式的幂等键，
-固定住才能重复验证幂等/状态流转，也不会每跑一次就在对方库里堆一条新订单；要换单号显式传 ``--order-no``。
-
-退款报文（status=REFUNDED，必带 refundTime + refundReason，见 docs/一站式平台对接-接口文档.md §3.4）::
-
-    python hjc_test_push_out.py --refund --dry-run   # 看退款报文长什么样
-    python hjc_test_push_out.py --refund --quick     # 打退款报文
-    python hjc_test_push_out.py --paid-then-refund   # 同一订单号先 PAID 再 REFUNDED（推荐的联调姿势）
-    python hjc_test_push_out.py --refund --order-no HJC2026080101ABCD \\
-        --refund-reason "项目终止，客户申请退款" --refund-time "2026-08-03 09:15:00"
-
-无第三方依赖，仅标准库。时间统一按北京时间（UTC+8）。
-
-退出码：0=出向推送成功（收到 2xx）；1=失败（并打印定位结论）。
-"""
-from __future__ import annotations
-
-import argparse
-import datetime as dt
-import hashlib
-import json
-import os
-import re
-import ssl
-import sys
-import time
-import urllib.error
-import urllib.parse
-import urllib.request
-
-try:  # Windows 控制台默认 GBK，强制 UTF-8 避免中文乱码
-    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-    sys.stderr.reconfigure(encoding="utf-8", errors="replace")
-except Exception:
-    pass
-
-# --------------------------------------------------------------------------- #
-# 默认值 / 配置读取
-# --------------------------------------------------------------------------- #
-HERE = os.path.dirname(os.path.abspath(__file__))
-MP_JAVA = os.path.dirname(HERE)
-APPLICATION_YML = os.path.join(MP_JAVA, "src", "main", "resources", "application.yml")
-AUTH_UTIL_JAVA = os.path.join(
-    MP_JAVA, "src", "main", "java", "com", "gxwebsoft", "hjc", "util", "HjcOneStopAuthUtil.java"
-)
-
-FALLBACK_BASE = "http://180.141.88.21:8810"
-FALLBACK_PATH = "/api/biz/createPurchaseDetails"
-FALLBACK_APP_KEY = "HJC_Official_Website"
-FALLBACK_PASSWORD = "vQ8$kR3#mW6@xP2!nF"
-
-TS_FMT = "%Y%m%d%H%M"
-DT_FMT = "%Y-%m-%d %H:%M:%S"
-# argparse 的 help 会对 % 做格式化，展示用的时间格式需转义
-DT_FMT_HELP = DT_FMT.replace("%", "%%")
-
-STATUS_PAID = "PAID"
-STATUS_REFUNDED = "REFUNDED"
-# 固定探测订单号：不随时间变化，重复运行始终命中一站式同一条记录。
-# 订单号同时是一站式幂等键（HJC_ORD_<orderNo>），固定值才能稳定验证幂等与状态流转，
-# 也不会每跑一次就在对方库里堆一条新订单。（与 hjc_test_push.py 固定 projectNo 同一思路）
-DEFAULT_ORDER_NO = "PROBE_202609111127"
-# 与 HjcBizServiceImpl.DEFAULT_REFUND_REASON 对齐：退款原因留空时官方网会兜底这个值
-DEFAULT_REFUND_REASON = "联调探测：客户申请退款"
-# 与 hjc_order.refund_reason 字段长度对齐（varchar(255)）
-REFUND_REASON_MAX = 255
-
-
-def _read_text(path: str) -> str:
-    try:
-        with open(path, encoding="utf-8") as f:
-            return f.read()
-    except OSError:
-        return ""
-
-
-def load_config() -> tuple[str, str]:
-    """从仓库读取 base-url / path，读不到则回退到内置值。"""
-    base, path = FALLBACK_BASE, FALLBACK_PATH
-    yml = _read_text(APPLICATION_YML)
-    if yml:
-        m = re.search(r'base-url:\s*"([^"]*)"', yml)
-        if m and m.group(1).strip():
-            base = m.group(1).strip()
-        m = re.search(r"create-purchase-details-path:\s*(\S+)", yml)
-        if m and m.group(1).strip():
-            path = m.group(1).strip().strip('"')
-    return base, path
-
-
-def load_credentials() -> tuple[str, str]:
-    """从 HjcOneStopAuthUtil.java 读取 APP_KEY / PASSWORD，读不到则回退。"""
-    app_key, password = FALLBACK_APP_KEY, FALLBACK_PASSWORD
-    java = _read_text(AUTH_UTIL_JAVA)
-    if java:
-        m = re.search(r'APP_KEY\s*=\s*"([^"]*)"', java)
-        if m:
-            app_key = m.group(1)
-        m = re.search(r'PASSWORD\s*=\s*"([^"]*)"', java)
-        if m:
-            password = m.group(1)
-    return app_key, password
-
-
-# --------------------------------------------------------------------------- #
-# 签名 / 时间
-# --------------------------------------------------------------------------- #
-def bj_now() -> dt.datetime:
-    return dt.datetime.now(dt.timezone.utc).astimezone(dt.timezone(dt.timedelta(hours=8)))
-
-
-def timestamp_str(now: dt.datetime) -> str:
-    return now.strftime(TS_FMT)
-
-
-def sign_of(app_key: str, password: str, ts: str) -> str:
-    return hashlib.md5((app_key + password + ts).encode("utf-8")).hexdigest()
-
-
-def md5(text: str) -> str:
-    return hashlib.md5(text.encode("utf-8")).hexdigest()
-
-
-# --------------------------------------------------------------------------- #
-# HTTP
-# --------------------------------------------------------------------------- #
-def post(url: str, body: bytes, headers: dict, timeout: float, insecure: bool = False):
-    """返回 (http_code, response_text, elapsed_ms, error)。http_code=0 表示网络层失败。"""
-    req = urllib.request.Request(url, data=body, method="POST", headers=headers)
-    ctx = ssl._create_unverified_context() if insecure else None
-    t0 = time.monotonic()
-    try:
-        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
-            text = resp.read().decode("utf-8", errors="replace")
-            return resp.status, text, (time.monotonic() - t0) * 1000, None
-    except urllib.error.HTTPError as e:
-        text = e.read().decode("utf-8", errors="replace")
-        return e.code, text, (time.monotonic() - t0) * 1000, None
-    except Exception as e:  # noqa: BLE001 - 网络层任何异常都归为不可达
-        return 0, "", (time.monotonic() - t0) * 1000, f"{type(e).__name__}: {e}"
-
-
-# --------------------------------------------------------------------------- #
-# 响应判定
-# --------------------------------------------------------------------------- #
-LOGIN_HINTS = ("token失效", "请重新登录", "未登录", "not login", "unauthorized")
-SIGN_HINTS = ("签名", "验签", "sign校验", "invalid signature", "signature")
-TS_HINTS = ("时间戳", "timestamp失效", "timestamp expired")
-
-VERDICT_LABEL = {
-    "OK": "✅ 通过",
-    "LOGIN_FILTER": "🔒 登录过滤器拦截",
-    "SIGN_REJECT": "❌ 验签被拒",
-    "TS_REJECT": "❌ 时间戳被拒",
-    "NOT_FOUND": "🚫 路由不存在(404)",
-    "UNREACHABLE": "🌐 网络不可达",
-    "OTHER": "❓ 其他",
-}
-
-
-def classify(status: int, body: str) -> str:
-    if status == 0:
-        return "UNREACHABLE"
-    if 200 <= status < 300:
-        return "OK"
-    low = (body or "").lower()
-    if any(h in low for h in TS_HINTS):
-        return "TS_REJECT"
-    if any(h in low for h in SIGN_HINTS):
-        return "SIGN_REJECT"
-    if any(h in low for h in LOGIN_HINTS):
-        return "LOGIN_FILTER"
-    if status == 404:
-        return "NOT_FOUND"
-    return "OTHER"
-
-
-def brief(body: str, limit: int = 160) -> str:
-    one = " ".join((body or "").split())
-    return one if len(one) <= limit else one[:limit] + "…"
-
-
-def fingerprint(status: int, body: str) -> str:
-    """响应的「错误语义指纹」：忽略每次都变的 timestamp/path 字段，只保留结论性字段。
-
-    用于判断两次响应是否表达同一个错误（例如真实接口与不存在路径都被同一个过滤器拒绝）。
-    """
-    try:
-        obj = json.loads(body)
-        if isinstance(obj, dict):
-            keep = {k: obj[k] for k in ("status", "error", "message") if k in obj}
-            if keep:
-                return json.dumps(keep, ensure_ascii=False, sort_keys=True)
-    except (ValueError, TypeError):
-        pass
-    return " ".join((body or "").split())[:200] or f"HTTP {status}"
-
-
-# --------------------------------------------------------------------------- #
-# 报文
-# --------------------------------------------------------------------------- #
-def default_payload(
-    order_no: str,
-    now: dt.datetime,
-    status: str = STATUS_PAID,
-    refund_reason: str | None = None,
-    refund_time: dt.datetime | None = None,
-) -> dict:
-    """构造 createPurchaseDetails 请求体。
-
-    status=REFUNDED 时追加 refundTime / refundReason（官方网侧同样只在退款单推这两个字段，
-    见 HjcBizServiceImpl#buildCreatePurchaseDetails）。
-    """
-    payload = {
-        "idempotencyKey": "HJC_ORD_" + order_no,
-        "orderNo": order_no,
-        "projectNo": "HJC-GXZCY2-2026002",
-        "projectName": "出向推送联调探测",
-        "tenderPrice": 0.01,
-        "quantity": 1,
-        "totalAmount": 0.01,
-        "buyer": {
-            "enterpriseName": "联调探测企业",
-            "creditCode": "91450000PROBE01",
-            "contactName": "联调",
-            "contactPhone": "13800000000",
-            "contactEmail": "probe@example.com",
-        },
-        "paidAt": now.strftime(DT_FMT),
-        "payMethod": "WECHAT_NATIVE",
-        "status": status,
-        "invoiceStatus": "NONE",
-    }
-    if status == STATUS_REFUNDED:
-        reason = (refund_reason or "").strip() or DEFAULT_REFUND_REASON
-        payload["refundTime"] = (refund_time or now).strftime(DT_FMT)
-        payload["refundReason"] = reason[:REFUND_REASON_MAX]
-    return payload
-
-
-def refund_payload_issues(payload: dict) -> list[str]:
-    """退款报文的本地自检：官方网/一站式都要求这两个字段非空，先在这里拦住低级错误。"""
-    issues: list[str] = []
-    if payload.get("status") != STATUS_REFUNDED:
-        return issues
-    for field in ("refundTime", "refundReason"):
-        value = payload.get(field)
-        if not isinstance(value, str) or not value.strip():
-            issues.append(f"{field} 缺失或为空（退款推送必带）")
-    rt = payload.get("refundTime")
-    if isinstance(rt, str) and rt.strip():
-        try:
-            dt.datetime.strptime(rt.strip(), DT_FMT)
-        except ValueError:
-            issues.append(f"refundTime 格式应为 {DT_FMT}（当前: {rt}）")
-    reason = payload.get("refundReason")
-    if isinstance(reason, str) and len(reason) > REFUND_REASON_MAX:
-        issues.append(f"refundReason 超过 {REFUND_REASON_MAX} 字符（当前: {len(reason)}）")
-    return issues
-
-
-def case_matrix(app_key: str, password: str, ts: str, sign: str) -> list[tuple[str, dict, str]]:
-    """返回 [(方案名, 请求头, 说明)]，方案 1 为文档约定方案。"""
-    return [
-        (
-            "1 文档约定方案",
-            {"appKey": app_key, "timestamp": ts, "sign": sign},
-            "appKey+timestamp+sign（sign=MD5(appKey+password+timestamp)）",
-        ),
-        (
-            "2 约定 + password 明文头",
-            {"appKey": app_key, "timestamp": ts, "sign": sign, "password": password},
-            "在原需求「明文 password 头」与现规范之间的折中",
-        ),
-        (
-            "3 仅 password 明文头",
-            {"password": password},
-            "只带密钥，不带 appKey/sign",
-        ),
-        (
-            "4 appKey + password 明文",
-            {"appKey": app_key, "password": password, "timestamp": ts},
-            "按原文需求字面实现（无 sign）",
-        ),
-        (
-            "5 双 MD5 解读",
-            {"appKey": md5(app_key + ts), "password": md5(password + ts), "timestamp": ts},
-            "原文「appKey+年月日时分，password+年月日时分，MD5加密」的另一种读法",
-        ),
-        (
-            "6 Authorization 头",
-            {"appKey": app_key, "timestamp": ts, "Authorization": sign},
-            "把签名放 Authorization，适配标准网关",
-        ),
-        (
-            "7 无任何鉴权头",
-            {},
-            "基准：对比有无鉴权头的响应差异",
-        ),
-    ]
-
-
-# --------------------------------------------------------------------------- #
-# 主流程
-# --------------------------------------------------------------------------- #
-def main() -> int:
-    ap = argparse.ArgumentParser(
-        description="汇吉采 → 一站式 出向推送联调探测",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    cfg_base, cfg_path = load_config()
-    cfg_key, cfg_pwd = load_credentials()
-
-    ap.add_argument("--base", default=cfg_base, help=f"一站式 base-url（默认读配置: {cfg_base}）")
-    ap.add_argument("--path", default=cfg_path, help=f"推送路径（默认读配置: {cfg_path}）")
-    ap.add_argument("--appkey", default=cfg_key, help="appKey")
-    ap.add_argument("--password", default=cfg_pwd, help="签名密钥 password")
-    ap.add_argument("--order-no", default=DEFAULT_ORDER_NO, help=f"订单号（默认固定值 {DEFAULT_ORDER_NO}）")
-    ap.add_argument("--payload", default=None, help="自定义请求体 JSON 文件")
-    ap.add_argument(
-        "--refund",
-        action="store_true",
-        help="推退款报文（status=REFUNDED，带 refundTime/refundReason）",
-    )
-    ap.add_argument(
-        "--paid-then-refund",
-        action="store_true",
-        help="同一订单号先推 PAID 基线、再推 REFUNDED（模拟真实退款状态流转）",
-    )
-    ap.add_argument(
-        "--refund-reason",
-        default=None,
-        help=f"退款原因（默认「{DEFAULT_REFUND_REASON}」，最长 {REFUND_REASON_MAX} 字符）",
-    )
-    ap.add_argument(
-        "--refund-time",
-        default=None,
-        help=f"退款时间，格式 {DT_FMT_HELP}（默认当前北京时间）",
-    )
-    ap.add_argument("--repeat", type=int, default=1, help="约定方案重复次数，用于验幂等（默认 1）")
-    ap.add_argument("--timeout", type=float, default=15.0, help="单请求超时秒数（默认 15）")
-    ap.add_argument("--quick", action="store_true", help="只跑约定方案，跳过变体矩阵与对照探测")
-    ap.add_argument("--no-control", action="store_true", help="跳过对照探测（不额外打扰对方服务）")
-    ap.add_argument("--dry-run", action="store_true", help="只打印请求，不发送")
-    ap.add_argument("--insecure", action="store_true", help="跳过 HTTPS 证书校验")
-    ap.add_argument("--json", dest="json_out", default=None, help="把完整结果写入 JSON 文件")
-    args = ap.parse_args()
-
-    now = bj_now()
-    ts = timestamp_str(now)
-    sign = sign_of(args.appkey, args.password, ts)
-    order_no = args.order_no
-    url = args.base.rstrip("/") + args.path
-
-    refund_time = None
-    if args.refund_time:
-        try:
-            refund_time = dt.datetime.strptime(args.refund_time.strip(), DT_FMT)
-        except ValueError:
-            print(f"❌ --refund-time 格式应为 {DT_FMT}，收到：{args.refund_time}", file=sys.stderr)
-            return 2
-
-    want_refund = args.refund or args.paid_then_refund
-    status = STATUS_REFUNDED if want_refund else STATUS_PAID
-    if not want_refund and not args.payload and (args.refund_reason or args.refund_time):
-        print(
-            "⚠️  --refund-reason/--refund-time 仅在 --refund 或 --paid-then-refund 下生效"
-            "（当前为 PAID 报文）",
-            file=sys.stderr,
-        )
-
-    if args.payload:
-        if want_refund:
-            print("⚠️  --payload 已指定，忽略 --refund/--paid-then-refund/--refund-reason/--refund-time", file=sys.stderr)
-        with open(args.payload, encoding="utf-8") as f:
-            payload = json.load(f)
-    else:
-        payload = default_payload(order_no, now, status, args.refund_reason, refund_time)
-
-    # 退款报文自检：本地先拦掉「必带字段缺失/时间格式错/超长」，避免白跑一轮联调
-    issues = refund_payload_issues(payload)
-    if issues:
-        print("❌ 退款报文自检未通过：", file=sys.stderr)
-        for it in issues:
-            print(f"   · {it}", file=sys.stderr)
-        return 2
-
-    # --paid-then-refund：同一订单号先落一条 PAID，再发 REFUNDED
-    paid_body = None
-    if args.paid_then_refund and not args.payload:
-        paid_body = json.dumps(
-            default_payload(order_no, now, STATUS_PAID), ensure_ascii=False
-        ).encode("utf-8")
-
-    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-
-    print("=" * 78)
-    print("汇吉采 → 一站式 出向推送探测" + ("（退款报文）" if payload.get("status") == STATUS_REFUNDED else ""))
-    print("=" * 78)
-    print(f"目标 URL   : {url}")
-    print(f"北京时间   : {now.strftime(DT_FMT)}  → timestamp={ts}")
-    print(f"appKey     : {args.appkey}")
-    print(f"sign       : {sign}")
-    print(f"订单号     : {order_no}")
-    print(f"订单状态   : {payload.get('status')}")
-    if payload.get("status") == STATUS_REFUNDED:
-        print(f"退款时间   : {payload.get('refundTime')}")
-        print(f"退款原因   : {payload.get('refundReason')}")
-    print(f"请求体     : {body.decode('utf-8')}")
-    if paid_body is not None:
-        print()
-        print("（--paid-then-refund：先发 PAID 基线）")
-        print(f"请求体     : {paid_body.decode('utf-8')}")
-    print()
-
-    if args.dry_run:
-        print("[dry-run] 未发送任何请求。等价 curl：")
-        if paid_body is not None:
-            print(
-                f"  # 1) 同一订单号先落 PAID\n"
-                f"  curl -i -X POST '{url}' \\\n"
-                f"    -H 'Content-Type: application/json' \\\n"
-                f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-                f"    -d '{paid_body.decode('utf-8')}'\n"
-                f"  # 2) 再推 REFUNDED（带退款时间/原因）"
-            )
-        print(
-            f"  curl -i -X POST '{url}' \\\n"
-            f"    -H 'Content-Type: application/json' \\\n"
-            f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-            f"    -d '{body.decode('utf-8')}'"
-        )
-        return 0
-
-    results: list[dict] = []
-
-    def run_case(name: str, headers: dict, note: str, target_url: str = url, use_body: bytes = body):
-        h = {"Content-Type": "application/json", **headers}
-        status_code, text, ms, err = post(target_url, use_body, h, args.timeout, args.insecure)
-        verdict = classify(status_code, text)
-        results.append(
-            {
-                "name": name,
-                "note": note,
-                "url": target_url,
-                "status": status_code,
-                "verdict": verdict,
-                "fingerprint": fingerprint(status_code, text),
-                "elapsed_ms": round(ms, 1),
-                "body": text,
-                "error": err,
-            }
-        )
-        shown = f"HTTP {status_code}" if status_code else "无响应"
-        print(f"  {name:<22} {shown:<9} {VERDICT_LABEL[verdict]:<18} {brief(err or text)}")
-        return results[-1]
-
-    matrix = case_matrix(args.appkey, args.password, ts, sign)
-
-    # ---------------- 阶段 0：（可选）PAID 基线 ----------------
-    # 退款推送要针对「已在一站式存在的订单」，故先用同一订单号落一条 PAID 记录。
-    if paid_body is not None:
-        print("── 阶段 0：PAID 基线（同一订单号，先建立已支付记录）──")
-        run_case("0 PAID 基线", matrix[0][1], "退款前先落一条已支付记录", use_body=paid_body)
-        print()
-
-    # ---------------- 阶段 1：约定方案（含 repeat 幂等验证） ----------------
-    print(f"── 阶段 1：文档约定方案{'（连打 %d 次验幂等）' % args.repeat if args.repeat > 1 else ''} ──")
-    primary = run_case(matrix[0][0], matrix[0][1], matrix[0][2])
-    for i in range(2, args.repeat + 1):
-        run_case(f"1 文档约定方案 #{i}", matrix[0][1], "幂等复打")
-
-    if not args.quick:
-        # ---------------- 阶段 2：鉴权头变体 ----------------
-        print()
-        print("── 阶段 2：鉴权头变体矩阵（用于区分「签名不对」与「未校验签名」）──")
-        for name, headers, note in matrix[1:]:
-            run_case(name, headers, note)
-
-        # query 参数形式单独处理（不带请求头）
-        q = urllib.parse.urlencode(
-            {"appKey": args.appkey, "password": args.password, "timestamp": ts, "sign": sign}
-        )
-        run_case("8 query 参数", {}, "凭据放 URL query", target_url=f"{url}?{q}")
-
-    # ---------------- 阶段 3：对照探测 ----------------
-    # 仅在失败时才有诊断价值；已成功就不再给对方发多余请求。
-    controls: list[dict] = []
-    if not args.no_control and primary["verdict"] != "OK":
-        print()
-        print("── 阶段 3：对照探测（定位失败发生在哪一层）──")
-        parts = [p for p in args.path.strip("/").split("/") if p]
-        if len(parts) >= 2:
-            protected_nope = "/" + "/".join(parts[:-1] + ["__probe_nope__"])
-            reference_nope = "/" + "/".join(parts[:1] + ["auth", "__probe_nope__"])
-            ctl_headers = matrix[0][1]
-            for label, p, note in (
-                ("C1 同前缀不存在路径", protected_nope, "若与目标接口响应一致 → 拦截发生在路由解析之前"),
-                ("C2 另一前缀不存在路径", reference_nope, "未受保护的参照组，应为干净的 404"),
-            ):
-                controls.append(
-                    run_case(label, ctl_headers, note, target_url=args.base.rstrip("/") + p)
-                )
-        else:
-            print("  （路径层级不足，跳过对照探测）")
-
-    # ---------------- 结论 ----------------
-    print()
-    print("=" * 78)
-    print("结论")
-    print("=" * 78)
-
-    primary_verdict = primary["verdict"]
-    success = primary_verdict == "OK"
-
-    # 与「同前缀不存在路径」对照：错误语义一致说明根本没走到路由
-    same_as_control = bool(
-        controls
-        and controls[0]["status"] == primary["status"]
-        and controls[0]["fingerprint"] == primary["fingerprint"]
-    )
-
-    if success:
-        print("✅ 出向对接成功：目标接口返回 2xx，对方已接受并（应已）落盘。")
-        if args.repeat > 1:
-            ok_all = all(r["verdict"] == "OK" for r in results if r["name"].startswith("1 "))
-            print(
-                f"   幂等复打 {args.repeat} 次：{'全部 2xx ✅' if ok_all else '存在非 2xx，请检查幂等处理 ❌'}"
-            )
-    else:
-        print(f"❌ 出向对接失败：约定方案判定为「{VERDICT_LABEL[primary_verdict]}」。")
-        print()
-        if primary_verdict == "LOGIN_FILTER":
-            print("定位：请求被对方的**登录态过滤器**拒绝，与签名无关。依据：")
-            if same_as_control:
-                print("  · 同一套凭据打「同前缀下不存在的路径」，响应与真实接口**完全一致**")
-                print("    → 拒绝发生在路由解析之前，接口是否存在、签名是否正确都影响不到它。")
-            print("  · 响应体是登录错误而非「签名校验失败」，说明对方的验签逻辑没有被执行。")
-            print()
-            print("需对方处理：把该接口加入免登录白名单并实现约定验签，或提供获取调用 Token 的方式。")
-        elif primary_verdict == "SIGN_REJECT":
-            print("定位：对方已放行到验签逻辑，但签名不通过 → 属于**算法/密钥不一致**。")
-            print("建议：让对方用下面这组固定值离线自证，无需部署：")
-            print(f"    appKey={args.appkey}  timestamp={ts}  sign={sign}")
-            print("    若对方算不出同一 sign，核对 password 取值与拼接顺序（是否含分隔符、大小写）。")
-        elif primary_verdict == "TS_REJECT":
-            print("定位：时间戳被拒 → 核对对方服务器时间与北京时区，以及允许窗口（约定 ±10 分钟）。")
-        elif primary_verdict == "NOT_FOUND":
-            print("定位：路由不存在 → 路径或 base-url 不对，需对方确认接口实际地址与端口。")
-        elif primary_verdict == "UNREACHABLE":
-            print(f"定位：网络不可达 → {primary['error']}")
-            print("建议：确认对方服务已启动、端口开放、本机到该地址无防火墙/白名单限制。")
-        else:
-            print("未能自动归类，请把上面的响应原文提供给对方排查。")
-
-        # 变体是否出现「与基准不同」的响应——若全一致，进一步佐证签名未被校验
-        if not args.quick:
-            variants = [
-                r
-                for r in results
-                if r["name"][0].isdigit() and not r["name"].startswith(("0 ", "1 "))
-            ]
-            distinct = {r["fingerprint"] for r in variants}
-            if len(distinct) <= 1 and variants:
-                print()
-                print("补充：全部鉴权头变体（含不带任何头的基准）响应**完全相同**")
-                print("      → 对方当前没有对请求头做任何区分，签名校验尚未生效。")
-
-    # 退款模式补充结论：PAID 基线 + REFUNDED 是否都通过（退款字段是否被对方接受）
-    if payload.get("status") == STATUS_REFUNDED:
-        print()
-        paid_base = next((r for r in results if r["name"].startswith("0 ")), None)
-        if paid_base is not None:
-            print(
-                f"PAID 基线    : {VERDICT_LABEL[paid_base['verdict']]}（同一订单号 {order_no}）"
-                + ("" if paid_base["verdict"] == "OK" else " ← 基线未通过，退款结果可能不可信")
-            )
-        print(
-            f"REFUNDED 报文: {VERDICT_LABEL[primary_verdict]}，"
-            f"refundTime={payload.get('refundTime')} / refundReason={payload.get('refundReason')}"
-        )
-
-    print()
-    print(f"复现命令（可直接发给对方）：")
-    if paid_body is not None:
-        print(
-            f"  # 1) 同一订单号先落 PAID\n"
-            f"  curl -i -X POST '{url}' -H 'Content-Type: application/json' \\\n"
-            f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-            f"    -d '{paid_body.decode('utf-8')}'\n"
-            f"  # 2) 再推 REFUNDED（带退款时间/原因）"
-        )
-    print(
-        f"  curl -i -X POST '{url}' \\\n"
-        f"    -H 'Content-Type: application/json' \\\n"
-        f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-        f"    -d '{body.decode('utf-8')}'"
-    )
-
-    if args.json_out:
-        with open(args.json_out, "w", encoding="utf-8") as f:
-            json.dump(
-                {
-                    "base": args.base,
-                    "path": args.path,
-                    "url": url,
-                    "timestamp": ts,
-                    "sign": sign,
-                    "appKey": args.appkey,
-                    "orderNo": order_no,
-                    "orderStatus": payload.get("status"),
-                    "refundTime": payload.get("refundTime"),
-                    "refundReason": payload.get("refundReason"),
-                    "paidThenRefund": args.paid_then_refund,
-                    "payload": payload,
-                    "results": results,
-                    "controls": controls,
-                    "verdict": primary_verdict,
-                    "success": success,
-                },
-                f,
-                ensure_ascii=False,
-                indent=2,
-            )
-        print(f"\n完整结果已写入：{args.json_out}")
-
-    return 0 if success else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/main/java/com/gxwebsoft/cms/controller/CmsNavigationController.java

@@ -1,13 +1,17 @@
 package com.gxwebsoft.cms.controller;
 
+import cn.afterturn.easypoi.excel.ExcelImportUtil;
+import cn.afterturn.easypoi.excel.entity.ImportParams;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.gxwebsoft.cms.entity.CmsDesign;
 import com.gxwebsoft.cms.entity.CmsModel;
+import com.gxwebsoft.cms.param.CmsNavigationImportParam;
 import com.gxwebsoft.cms.service.CmsDesignService;
 import com.gxwebsoft.cms.service.CmsModelService;
+import com.gxwebsoft.common.core.annotation.OperationLog;
 import com.gxwebsoft.common.core.utils.CommonUtil;
 import com.gxwebsoft.common.core.utils.RedisUtil;
 import com.gxwebsoft.common.core.web.BaseController;
@@ -21,11 +25,18 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.common.system.service.UserService;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import io.swagger.v3.oas.annotations.Operation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 网站导航记录表控制器
@@ -79,6 +90,7 @@ public class CmsNavigationController extends BaseController {
     return success(cmsNavigationService.getByIdRelByCodeRel(code));
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:save')")
   @Operation(summary = "添加网站导航记录表")
   @PostMapping()
   public ApiResult<?> save(@RequestBody CmsNavigation cmsNavigation) {
@@ -99,6 +111,7 @@ public class CmsNavigationController extends BaseController {
     return fail("添加失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:update')")
   @Operation(summary = "修改网站导航记录表")
   @PutMapping()
   public ApiResult<?> update(@RequestBody CmsNavigation cmsNavigation) {
@@ -111,6 +124,7 @@ public class CmsNavigationController extends BaseController {
     return fail("修改失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:remove')")
   @Operation(summary = "删除网站导航记录表")
   @DeleteMapping("/{id}")
   public ApiResult<?> remove(@PathVariable("id") Integer id) {
@@ -121,6 +135,7 @@ public class CmsNavigationController extends BaseController {
     return fail("删除失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:save')")
   @Operation(summary = "批量添加网站导航记录表")
   @PostMapping("/batch")
   public ApiResult<?> saveBatch(@RequestBody List<CmsNavigation> list) {
@@ -131,6 +146,7 @@ public class CmsNavigationController extends BaseController {
     return fail("添加失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:update')")
   @Operation(summary = "批量修改网站导航记录表")
   @PutMapping("/batch")
   public ApiResult<?> removeBatch(@RequestBody BatchParam<CmsNavigation> batchParam) {
@@ -141,6 +157,7 @@ public class CmsNavigationController extends BaseController {
     return fail("修改失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:remove')")
   @Operation(summary = "批量删除网站导航记录表")
   @DeleteMapping("/batch")
   public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
@@ -151,6 +168,173 @@ public class CmsNavigationController extends BaseController {
     return fail("删除失败");
   }
 
+  /**
+   * excel批量导入网站导航
+   */
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:save')")
+  @OperationLog
+  @Operation(summary = "批量导入网站导航")
+  @Transactional(rollbackFor = {Exception.class})
+  @PostMapping("/import")
+  public ApiResult<?> importBatch(@RequestParam("file") MultipartFile file) {
+    ImportParams importParams = new ImportParams();
+    try {
+      User loginUser = getLoginUser();
+      if (loginUser == null) {
+        return fail("请先登录");
+      }
+      Integer currentUserId = loginUser.getUserId();
+      Integer currentTenantId = loginUser.getTenantId();
+
+      // 1) 清理当前租户的历史数据：先清理 deleted=1，再把 deleted=0 标记为 deleted=1
+      List<CmsNavigation> undeleted = cmsNavigationService.list(new LambdaQueryWrapper<CmsNavigation>()
+          .eq(CmsNavigation::getTenantId, currentTenantId)
+          .eq(CmsNavigation::getDeleted, 0));
+      cmsNavigationService.remove(new LambdaQueryWrapper<CmsNavigation>()
+          .eq(CmsNavigation::getTenantId, currentTenantId)
+          .eq(CmsNavigation::getDeleted, 1));
+      if (!CollectionUtils.isEmpty(undeleted)) {
+        LambdaUpdateWrapper<CmsNavigation> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.eq(CmsNavigation::getTenantId, currentTenantId);
+        updateWrapper.eq(CmsNavigation::getDeleted, 0);
+        updateWrapper.set(CmsNavigation::getDeleted, 1);
+        cmsNavigationService.update(updateWrapper);
+      }
+
+      // 2) 读取Excel
+      List<CmsNavigationImportParam> list = ExcelImportUtil.importExcel(
+          file.getInputStream(), CmsNavigationImportParam.class, importParams);
+      if (CollectionUtils.isEmpty(list)) {
+        return fail("未读取到数据，请确认模板表头与示例格式一致");
+      }
+
+      // 3) 先全部落库（先按根节点保存），再尝试按“导入文件的 parentId -> 导入文件的 navigationId”映射回填层级。
+      // 这样即使 parentId 无法匹配（导入文件缺少导航ID/父节点缺失），也能把数据全部导入，无法还原层级的作为根节点处理。
+      Map<Integer, Integer> newIdByOldId = new HashMap<>();
+      List<Integer> newIds = new ArrayList<>(list.size());
+      List<Integer> oldIds = new ArrayList<>(list.size());
+      List<Integer> oldParentIds = new ArrayList<>(list.size());
+
+      for (CmsNavigationImportParam param : list) {
+        CmsNavigation nav = convertToNavigation(param, currentUserId, currentTenantId);
+        nav.setParentId(0);
+        cmsNavigationService.save(nav);
+        cmsNavigationService.saveAsync(nav);
+
+        Integer oldId = param.getNavigationId();
+        if (oldId != null) {
+          newIdByOldId.put(oldId, nav.getNavigationId());
+        }
+        newIds.add(nav.getNavigationId());
+        oldIds.add(oldId);
+        oldParentIds.add(param.getParentId() != null ? param.getParentId() : 0);
+      }
+
+      int orphanCount = 0;
+      int restoredCount = 0;
+      for (int i = 0; i < newIds.size(); i++) {
+        Integer oldParentId = oldParentIds.get(i);
+        if (oldParentId == null || oldParentId == 0) {
+          continue;
+        }
+        Integer oldId = oldIds.get(i);
+        Integer newId = newIds.get(i);
+        Integer newParentId = newIdByOldId.get(oldParentId);
+        // 无法匹配父节点（或出现自引用）就当作孤儿节点，保持根节点
+        if (newParentId == null || (oldId != null && oldParentId.equals(oldId)) || (newId != null && newParentId.equals(newId))) {
+          orphanCount++;
+          continue;
+        }
+        cmsNavigationService.update(new LambdaUpdateWrapper<CmsNavigation>()
+          .eq(CmsNavigation::getNavigationId, newId)
+          .set(CmsNavigation::getParentId, newParentId));
+        restoredCount++;
+      }
+
+      redisUtil.delete(SITE_INFO_KEY_PREFIX.concat(currentTenantId.toString()));
+      return success("成功导入" + list.size() + "条，恢复层级" + restoredCount + "条，无法还原层级的孤儿节点" + orphanCount + "条（已作为根节点导入）");
+    } catch (Exception e) {
+      e.printStackTrace();
+      return fail("导入失败: " + e.getMessage());
+    }
+  }
+
+  /**
+   * 递归创建子级导航
+   */
+  private void createChildNavigations(Map<Integer, List<CmsNavigationImportParam>> navGroups,
+                                      Map<Integer, CmsNavigation> tempIdMapping,
+                                      Integer originalParentId,
+                                      Integer defaultUserId,
+                                      Integer defaultTenantId) {
+    if (originalParentId == null || originalParentId == 0) {
+      return;
+    }
+    List<CmsNavigationImportParam> children = navGroups.get(originalParentId);
+    if (CollectionUtils.isEmpty(children)) {
+      return;
+    }
+    CmsNavigation parent = tempIdMapping.get(originalParentId);
+    if (parent == null || parent.getNavigationId() == null) {
+      return;
+    }
+    Integer newParentId = parent.getNavigationId();
+    for (CmsNavigationImportParam param : children) {
+      CmsNavigation nav = convertToNavigation(param, defaultUserId, defaultTenantId);
+      nav.setParentId(newParentId);
+      cmsNavigationService.save(nav);
+      cmsNavigationService.saveAsync(nav);
+      if (param.getNavigationId() != null) {
+        tempIdMapping.put(param.getNavigationId(), nav);
+      }
+      createChildNavigations(navGroups, tempIdMapping, param.getNavigationId(), defaultUserId, defaultTenantId);
+    }
+  }
+
+  private CmsNavigation convertToNavigation(CmsNavigationImportParam param, Integer defaultUserId, Integer defaultTenantId) {
+    CmsNavigation nav = new CmsNavigation();
+    nav.setType(param.getType());
+    nav.setTitle(StrUtil.trimStart(param.getTitle()));
+    nav.setParentId(param.getParentId() != null ? param.getParentId() : 0);
+    // saveAsync 依赖 model 生成路由/页面；缺省按 page 处理
+    nav.setModel(StrUtil.isBlank(param.getModel()) ? "page" : param.getModel());
+    nav.setCode(param.getCode());
+    nav.setPath(param.getPath());
+    nav.setComponent(param.getComponent());
+    nav.setTarget(param.getTarget());
+    nav.setIcon(param.getIcon());
+    nav.setColor(param.getColor());
+    nav.setHide(param.getHide());
+    nav.setPermission(param.getPermission());
+    nav.setPassword(param.getPassword());
+    nav.setPosition(param.getPosition());
+    nav.setTop(param.getTop());
+    nav.setBottom(param.getBottom());
+    nav.setActive(param.getActive());
+    nav.setMeta(param.getMeta());
+    nav.setStyle(param.getStyle());
+    nav.setModelName(param.getModelName());
+    nav.setPageId(param.getPageId());
+    nav.setItemId(param.getItemId());
+    nav.setIsMpWeixin(param.getIsMpWeixin());
+    nav.setGutter(param.getGutter());
+    nav.setSpan(param.getSpan());
+    nav.setReadNum(param.getReadNum());
+    nav.setMerchantId(param.getMerchantId());
+    nav.setLang(param.getLang());
+    nav.setHome(param.getHome());
+    nav.setRecommend(param.getRecommend());
+    nav.setSortNumber(param.getSortNumber() != null ? param.getSortNumber() : 0);
+    nav.setComments(param.getComments());
+    nav.setStatus(param.getStatus() != null ? param.getStatus() : 0);
+
+    // 导入时强制落到当前登录用户/租户，避免“导出其他租户 -> 导入”写回原租户导致当前租户数据不全。
+    nav.setUserId(defaultUserId);
+    nav.setTenantId(defaultTenantId);
+    nav.setDeleted(0);
+    return nav;
+  }
+
   @Operation(summary = "获取树形结构的网站导航数据")
   @GetMapping("/tree")
   public ApiResult<List<CmsNavigation>> tree(CmsNavigationParam param) {

src/main/java/com/gxwebsoft/cms/controller/CmsOrderController.java

@@ -0,0 +1,122 @@
+package com.gxwebsoft.cms.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.cms.service.CmsOrderService;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.BatchParam;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 网站订单控制器
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:25
+ */
+@Tag(name = "网站订单管理")
+@RestController
+@RequestMapping("/api/cms/cms-order")
+public class CmsOrderController extends BaseController {
+    @Resource
+    private CmsOrderService cmsOrderService;
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:list')")
+    @Operation(summary = "分页查询网站订单")
+    @GetMapping("/page")
+    public ApiResult<PageResult<CmsOrder>> page(CmsOrderParam param) {
+        // 使用关联查询
+        return success(cmsOrderService.pageRel(param));
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:list')")
+    @Operation(summary = "查询全部网站订单")
+    @GetMapping()
+    public ApiResult<List<CmsOrder>> list(CmsOrderParam param) {
+        // 使用关联查询
+        return success(cmsOrderService.listRel(param));
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:list')")
+    @Operation(summary = "根据id查询网站订单")
+    @GetMapping("/{id}")
+    public ApiResult<CmsOrder> get(@PathVariable("id") Integer id) {
+        // 使用关联查询
+        return success(cmsOrderService.getByIdRel(id));
+    }
+
+    @Operation(summary = "添加网站订单")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody CmsOrder cmsOrder) {
+
+        if (cmsOrderService.save(cmsOrder)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:update')")
+    @OperationLog
+    @Operation(summary = "修改网站订单")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody CmsOrder cmsOrder) {
+        if (cmsOrderService.updateById(cmsOrder)) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:remove')")
+    @OperationLog
+    @Operation(summary = "删除网站订单")
+    @DeleteMapping("/{id}")
+    public ApiResult<?> remove(@PathVariable("id") Integer id) {
+        if (cmsOrderService.removeById(id)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:save')")
+    @OperationLog
+    @Operation(summary = "批量添加网站订单")
+    @PostMapping("/batch")
+    public ApiResult<?> saveBatch(@RequestBody List<CmsOrder> list) {
+        if (cmsOrderService.saveBatch(list)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:update')")
+    @OperationLog
+    @Operation(summary = "批量修改网站订单")
+    @PutMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody BatchParam<CmsOrder> batchParam) {
+        if (batchParam.update(cmsOrderService, "id")) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:remove')")
+    @OperationLog
+    @Operation(summary = "批量删除网站订单")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
+        if (cmsOrderService.removeByIds(ids)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+}

src/main/java/com/gxwebsoft/cms/entity/CmsNavigation.java

@@ -43,6 +43,10 @@ public class CmsNavigation implements Serializable {
     @Schema(description = "模型")
     private String model;
 
+    @Schema(description = "模型名称")
+    @TableField(exist = false)
+    private String modelName;
+
     @Schema(description = "标识")
     private String code;
 
@@ -114,9 +118,6 @@ public class CmsNavigation implements Serializable {
     @TableField(exist = false)
     private Integer parentPosition;
 
-    @Schema(description = "模型名称")
-    private String modelName;
-
     @Schema(description = "绑定的页面（已废弃）")
     private Integer pageId;
 

src/main/java/com/gxwebsoft/cms/entity/CmsOrder.java

@@ -0,0 +1,266 @@
+package com.gxwebsoft.cms.entity;
+
+import java.math.BigDecimal;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import java.io.Serializable;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+/**
+ * 网站订单
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Schema(name = "CmsOrder对象", description = "网站订单")
+public class CmsOrder implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "id")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @Schema(description = "订单类型，0售前咨询 1售后服务 2意见反馈")
+    private Integer type;
+
+    @Schema(description = "订单标题")
+    private String title;
+
+    @Schema(description = "公司/团队名称")
+    private String company;
+
+    @Schema(description = "订单内容")
+    private String content;
+
+    @Schema(description = "订单编号")
+    private String orderNo;
+
+    @Schema(description = "快递/自提")
+    private Integer deliveryType;
+
+    @Schema(description = "下单渠道，0网站 1微信小程序 2其他")
+    private Integer channel;
+
+    @Schema(description = "微信支付交易号号")
+    private String transactionId;
+
+    @Schema(description = "微信退款订单号")
+    private String refundOrder;
+
+    @Schema(description = "商户ID")
+    private Integer merchantId;
+
+    @Schema(description = "商户名称")
+    private String merchantName;
+
+    @Schema(description = "商户编号")
+    private String merchantCode;
+
+    @Schema(description = "使用的优惠券id")
+    private Integer couponId;
+
+    @Schema(description = "使用的会员卡id")
+    private String cardId;
+
+    @Schema(description = "关联管理员id")
+    private Integer adminId;
+
+    @Schema(description = "核销管理员id")
+    private Integer confirmId;
+
+    @Schema(description = "IC卡号")
+    private String icCard;
+
+    @Schema(description = "真实姓名")
+    private String realName;
+
+    @Schema(description = "关联收货地址")
+    private Integer addressId;
+
+    @Schema(description = "收货地址")
+    private String address;
+
+    private String addressLat;
+
+    private String addressLng;
+
+    @Schema(description = "自提店铺id")
+    private Integer selfTakeMerchantId;
+
+    @Schema(description = "自提店铺")
+    private String selfTakeMerchantName;
+
+    @Schema(description = "配送开始时间")
+    private String sendStartTime;
+
+    @Schema(description = "配送结束时间")
+    private String sendEndTime;
+
+    @Schema(description = "发货店铺id")
+    private Integer expressMerchantId;
+
+    @Schema(description = "发货店铺")
+    private String expressMerchantName;
+
+    @Schema(description = "订单总额")
+    private BigDecimal totalPrice;
+
+    @Schema(description = "减少的金额，使用VIP会员折扣、优惠券抵扣、优惠券折扣后减去的价格")
+    private BigDecimal reducePrice;
+
+    @Schema(description = "实际付款")
+    private BigDecimal payPrice;
+
+    @Schema(description = "用于统计")
+    private BigDecimal price;
+
+    @Schema(description = "价钱，用于积分赠送")
+    private BigDecimal money;
+
+    @Schema(description = "取消时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime cancelTime;
+
+    @Schema(description = "取消原因")
+    private String cancelReason;
+
+    @Schema(description = "退款金额")
+    private BigDecimal refundMoney;
+
+    @Schema(description = "教练价格")
+    private BigDecimal coachPrice;
+
+    @Schema(description = "购买数量")
+    private Integer totalNum;
+
+    @Schema(description = "教练id")
+    private Integer coachId;
+
+    @Schema(description = "商品ID")
+    private Integer formId;
+
+    @Schema(description = "支付的用户id")
+    private Integer payUserId;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    private Integer payType;
+
+    @Schema(description = "微信支付子类型：JSAPI小程序支付，NATIVE扫码支付")
+    private String wechatPayType;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    private Integer friendPayType;
+
+    @Schema(description = "0未付款，1已付款")
+    private Integer payStatus;
+
+    @Schema(description = "0未使用，1已完成，2已取消，3取消中，4退款申请中，5退款被拒绝，6退款成功，7客户端申请退款")
+    private Integer orderStatus;
+
+    @Schema(description = "发货状态(10未发货 20已发货 30部分发货)")
+    private Integer deliveryStatus;
+
+    @Schema(description = "无需发货备注")
+    private String deliveryNote;
+
+    @Schema(description = "发货时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime deliveryTime;
+
+    @Schema(description = "评价状态(0未评价 1已评价)")
+    private Integer evaluateStatus;
+
+    @Schema(description = "评价时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime evaluateTime;
+
+    @Schema(description = "优惠类型：0无、1抵扣优惠券、2折扣优惠券、3、VIP月卡、4VIP年卡，5VIP次卡、6VIP会员卡、7IC月卡、8IC年卡、9IC次卡、10IC会员卡、11免费订单、12VIP充值卡、13IC充值卡、14VIP季卡、15IC季卡")
+    private Integer couponType;
+
+    @Schema(description = "优惠说明")
+    private String couponDesc;
+
+    @Schema(description = "二维码地址，保存订单号，支付成功后才生成")
+    private String qrcode;
+
+    @Schema(description = "vip月卡年卡、ic月卡年卡回退次数")
+    private Integer returnNum;
+
+    @Schema(description = "vip充值回退金额")
+    private BigDecimal returnMoney;
+
+    @Schema(description = "预约详情开始时间数组")
+    private String startTime;
+
+    @Schema(description = "是否已开具发票：0未开发票，1已开发票，2不能开具发票")
+    private Integer isInvoice;
+
+    @Schema(description = "发票流水号")
+    private String invoiceNo;
+
+    @Schema(description = "商家留言")
+    private String merchantRemarks;
+
+    @Schema(description = "支付时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime payTime;
+
+    @Schema(description = "退款时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime refundTime;
+
+    @Schema(description = "申请退款时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime refundApplyTime;
+
+    @Schema(description = "过期时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime expirationTime;
+
+    @Schema(description = "自提码")
+    private String selfTakeCode;
+
+    @Schema(description = "是否已收到赠品")
+    private Boolean hasTakeGift;
+
+    @Schema(description = "对账情况：0=未对账；1=已对账；3=已对账，金额对不上；4=未查询到该订单")
+    private Integer checkBill;
+
+    @Schema(description = "订单是否已结算(0未结算 1已结算)")
+    private Integer isSettled;
+
+    @Schema(description = "系统版本号 0当前版本 value=其他版本")
+    private Integer version;
+
+    @Schema(description = "用户id")
+    private Integer userId;
+
+    @Schema(description = "备注")
+    private String comments;
+
+    @Schema(description = "排序号")
+    private Integer sortNumber;
+
+    @Schema(description = "是否删除, 0否, 1是")
+    @TableLogic
+    private Integer deleted;
+
+    @Schema(description = "租户id")
+    private Integer tenantId;
+
+    @Schema(description = "修改时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+}

src/main/java/com/gxwebsoft/cms/mapper/CmsOrderMapper.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.cms.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 网站订单Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+public interface CmsOrderMapper extends BaseMapper<CmsOrder> {
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<CmsOrder>
+     */
+    List<CmsOrder> selectPageRel(@Param("page") IPage<CmsOrder> page,
+                             @Param("param") CmsOrderParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<User>
+     */
+    List<CmsOrder> selectListRel(@Param("param") CmsOrderParam param);
+
+}

src/main/java/com/gxwebsoft/cms/mapper/xml/CmsNavigationMapper.xml

@@ -4,9 +4,11 @@
 
     <!-- 关联查询sql -->
     <sql id="selectSql">
-        SELECT a.*, b.title as parentName, b.position as parentPosition
+        SELECT a.*, b.title as parentName, b.position as parentPosition, c.name as modelName
         FROM cms_navigation a
-        LEFT JOIN cms_navigation b ON a.parent_id = b.navigation_id
+        LEFT JOIN cms_navigation b ON a.parent_id = b.navigation_id AND b.deleted = 0 AND b.tenant_id = a.tenant_id
+        <!-- c.model = 0 会触发 MySQL 字符串转数字比较，导致几乎所有模型都匹配，从而把导航行成倍放大 -->
+        LEFT JOIN cms_model c ON a.model = c.model AND c.deleted = 0 AND c.tenant_id = a.tenant_id
         <where>
             <if test="param.navigationId != null">
                 AND a.navigation_id = #{param.navigationId}

src/main/java/com/gxwebsoft/cms/mapper/xml/CmsOrderMapper.xml

@@ -0,0 +1,258 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.gxwebsoft.cms.mapper.CmsOrderMapper">
+
+    <!-- 关联查询sql -->
+    <sql id="selectSql">
+        SELECT a.*
+        FROM cms_order a
+        <where>
+            <if test="param.id != null">
+                AND a.id = #{param.id}
+            </if>
+            <if test="param.type != null">
+                AND a.type = #{param.type}
+            </if>
+            <if test="param.title != null">
+                AND a.title LIKE CONCAT('%', #{param.title}, '%')
+            </if>
+            <if test="param.company != null">
+                AND a.company LIKE CONCAT('%', #{param.company}, '%')
+            </if>
+            <if test="param.content != null">
+                AND a.content LIKE CONCAT('%', #{param.content}, '%')
+            </if>
+            <if test="param.orderNo != null">
+                AND a.order_no LIKE CONCAT('%', #{param.orderNo}, '%')
+            </if>
+            <if test="param.deliveryType != null">
+                AND a.delivery_type = #{param.deliveryType}
+            </if>
+            <if test="param.channel != null">
+                AND a.channel = #{param.channel}
+            </if>
+            <if test="param.transactionId != null">
+                AND a.transaction_id LIKE CONCAT('%', #{param.transactionId}, '%')
+            </if>
+            <if test="param.refundOrder != null">
+                AND a.refund_order LIKE CONCAT('%', #{param.refundOrder}, '%')
+            </if>
+            <if test="param.merchantId != null">
+                AND a.merchant_id = #{param.merchantId}
+            </if>
+            <if test="param.merchantName != null">
+                AND a.merchant_name LIKE CONCAT('%', #{param.merchantName}, '%')
+            </if>
+            <if test="param.merchantCode != null">
+                AND a.merchant_code LIKE CONCAT('%', #{param.merchantCode}, '%')
+            </if>
+            <if test="param.couponId != null">
+                AND a.coupon_id = #{param.couponId}
+            </if>
+            <if test="param.cardId != null">
+                AND a.card_id LIKE CONCAT('%', #{param.cardId}, '%')
+            </if>
+            <if test="param.adminId != null">
+                AND a.admin_id = #{param.adminId}
+            </if>
+            <if test="param.confirmId != null">
+                AND a.confirm_id = #{param.confirmId}
+            </if>
+            <if test="param.icCard != null">
+                AND a.ic_card LIKE CONCAT('%', #{param.icCard}, '%')
+            </if>
+            <if test="param.realName != null">
+                AND a.real_name LIKE CONCAT('%', #{param.realName}, '%')
+            </if>
+            <if test="param.addressId != null">
+                AND a.address_id = #{param.addressId}
+            </if>
+            <if test="param.address != null">
+                AND a.address LIKE CONCAT('%', #{param.address}, '%')
+            </if>
+            <if test="param.addressLat != null">
+                AND a.address_lat LIKE CONCAT('%', #{param.addressLat}, '%')
+            </if>
+            <if test="param.addressLng != null">
+                AND a.address_lng LIKE CONCAT('%', #{param.addressLng}, '%')
+            </if>
+            <if test="param.selfTakeMerchantId != null">
+                AND a.self_take_merchant_id = #{param.selfTakeMerchantId}
+            </if>
+            <if test="param.selfTakeMerchantName != null">
+                AND a.self_take_merchant_name LIKE CONCAT('%', #{param.selfTakeMerchantName}, '%')
+            </if>
+            <if test="param.sendStartTime != null">
+                AND a.send_start_time LIKE CONCAT('%', #{param.sendStartTime}, '%')
+            </if>
+            <if test="param.sendEndTime != null">
+                AND a.send_end_time LIKE CONCAT('%', #{param.sendEndTime}, '%')
+            </if>
+            <if test="param.expressMerchantId != null">
+                AND a.express_merchant_id = #{param.expressMerchantId}
+            </if>
+            <if test="param.expressMerchantName != null">
+                AND a.express_merchant_name LIKE CONCAT('%', #{param.expressMerchantName}, '%')
+            </if>
+            <if test="param.totalPrice != null">
+                AND a.total_price = #{param.totalPrice}
+            </if>
+            <if test="param.reducePrice != null">
+                AND a.reduce_price = #{param.reducePrice}
+            </if>
+            <if test="param.payPrice != null">
+                AND a.pay_price = #{param.payPrice}
+            </if>
+            <if test="param.price != null">
+                AND a.price = #{param.price}
+            </if>
+            <if test="param.money != null">
+                AND a.money = #{param.money}
+            </if>
+            <if test="param.cancelTime != null">
+                AND a.cancel_time LIKE CONCAT('%', #{param.cancelTime}, '%')
+            </if>
+            <if test="param.cancelReason != null">
+                AND a.cancel_reason LIKE CONCAT('%', #{param.cancelReason}, '%')
+            </if>
+            <if test="param.refundMoney != null">
+                AND a.refund_money = #{param.refundMoney}
+            </if>
+            <if test="param.coachPrice != null">
+                AND a.coach_price = #{param.coachPrice}
+            </if>
+            <if test="param.totalNum != null">
+                AND a.total_num = #{param.totalNum}
+            </if>
+            <if test="param.coachId != null">
+                AND a.coach_id = #{param.coachId}
+            </if>
+            <if test="param.formId != null">
+                AND a.form_id = #{param.formId}
+            </if>
+            <if test="param.payUserId != null">
+                AND a.pay_user_id = #{param.payUserId}
+            </if>
+            <if test="param.payType != null">
+                AND a.pay_type = #{param.payType}
+            </if>
+            <if test="param.wechatPayType != null">
+                AND a.wechat_pay_type LIKE CONCAT('%', #{param.wechatPayType}, '%')
+            </if>
+            <if test="param.friendPayType != null">
+                AND a.friend_pay_type = #{param.friendPayType}
+            </if>
+            <if test="param.payStatus != null">
+                AND a.pay_status = #{param.payStatus}
+            </if>
+            <if test="param.orderStatus != null">
+                AND a.order_status = #{param.orderStatus}
+            </if>
+            <if test="param.deliveryStatus != null">
+                AND a.delivery_status = #{param.deliveryStatus}
+            </if>
+            <if test="param.deliveryNote != null">
+                AND a.delivery_note LIKE CONCAT('%', #{param.deliveryNote}, '%')
+            </if>
+            <if test="param.deliveryTime != null">
+                AND a.delivery_time LIKE CONCAT('%', #{param.deliveryTime}, '%')
+            </if>
+            <if test="param.evaluateStatus != null">
+                AND a.evaluate_status = #{param.evaluateStatus}
+            </if>
+            <if test="param.evaluateTime != null">
+                AND a.evaluate_time LIKE CONCAT('%', #{param.evaluateTime}, '%')
+            </if>
+            <if test="param.couponType != null">
+                AND a.coupon_type = #{param.couponType}
+            </if>
+            <if test="param.couponDesc != null">
+                AND a.coupon_desc LIKE CONCAT('%', #{param.couponDesc}, '%')
+            </if>
+            <if test="param.qrcode != null">
+                AND a.qrcode LIKE CONCAT('%', #{param.qrcode}, '%')
+            </if>
+            <if test="param.returnNum != null">
+                AND a.return_num = #{param.returnNum}
+            </if>
+            <if test="param.returnMoney != null">
+                AND a.return_money = #{param.returnMoney}
+            </if>
+            <if test="param.startTime != null">
+                AND a.start_time LIKE CONCAT('%', #{param.startTime}, '%')
+            </if>
+            <if test="param.isInvoice != null">
+                AND a.is_invoice = #{param.isInvoice}
+            </if>
+            <if test="param.invoiceNo != null">
+                AND a.invoice_no LIKE CONCAT('%', #{param.invoiceNo}, '%')
+            </if>
+            <if test="param.merchantRemarks != null">
+                AND a.merchant_remarks LIKE CONCAT('%', #{param.merchantRemarks}, '%')
+            </if>
+            <if test="param.payTime != null">
+                AND a.pay_time LIKE CONCAT('%', #{param.payTime}, '%')
+            </if>
+            <if test="param.refundTime != null">
+                AND a.refund_time LIKE CONCAT('%', #{param.refundTime}, '%')
+            </if>
+            <if test="param.refundApplyTime != null">
+                AND a.refund_apply_time LIKE CONCAT('%', #{param.refundApplyTime}, '%')
+            </if>
+            <if test="param.expirationTime != null">
+                AND a.expiration_time LIKE CONCAT('%', #{param.expirationTime}, '%')
+            </if>
+            <if test="param.selfTakeCode != null">
+                AND a.self_take_code LIKE CONCAT('%', #{param.selfTakeCode}, '%')
+            </if>
+            <if test="param.hasTakeGift != null">
+                AND a.has_take_gift = #{param.hasTakeGift}
+            </if>
+            <if test="param.checkBill != null">
+                AND a.check_bill = #{param.checkBill}
+            </if>
+            <if test="param.isSettled != null">
+                AND a.is_settled = #{param.isSettled}
+            </if>
+            <if test="param.version != null">
+                AND a.version = #{param.version}
+            </if>
+            <if test="param.userId != null">
+                AND a.user_id = #{param.userId}
+            </if>
+            <if test="param.comments != null">
+                AND a.comments LIKE CONCAT('%', #{param.comments}, '%')
+            </if>
+            <if test="param.sortNumber != null">
+                AND a.sort_number = #{param.sortNumber}
+            </if>
+            <if test="param.deleted != null">
+                AND a.deleted = #{param.deleted}
+            </if>
+            <if test="param.deleted == null">
+                AND a.deleted = 0
+            </if>
+            <if test="param.createTimeStart != null">
+                AND a.create_time &gt;= #{param.createTimeStart}
+            </if>
+            <if test="param.createTimeEnd != null">
+                AND a.create_time &lt;= #{param.createTimeEnd}
+            </if>
+            <if test="param.keywords != null">
+                AND (a.comments LIKE CONCAT('%', #{param.keywords}, '%')
+                )
+              </if>
+        </where>
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.cms.entity.CmsOrder">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.cms.entity.CmsOrder">
+        <include refid="selectSql"></include>
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/cms/param/CmsNavigationImportParam.java

@@ -0,0 +1,123 @@
+package com.gxwebsoft.cms.param;
+
+import cn.afterturn.easypoi.excel.annotation.Excel;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 网站导航导入参数（Excel 批量导入）
+ */
+@Data
+public class CmsNavigationImportParam implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Excel(name = "导航ID")
+    private Integer navigationId;
+
+    @Excel(name = "类型")
+    private Integer type;
+
+    @Excel(name = "菜单名称")
+    private String title;
+
+    @Excel(name = "上级id")
+    private Integer parentId;
+
+    @Excel(name = "模型")
+    private String model;
+
+    @Excel(name = "标识")
+    private String code;
+
+    @Excel(name = "菜单路由地址")
+    private String path;
+
+    @Excel(name = "菜单组件地址")
+    private String component;
+
+    @Excel(name = "打开位置")
+    private String target;
+
+    @Excel(name = "菜单图标")
+    private String icon;
+
+    @Excel(name = "图标颜色")
+    private String color;
+
+    @Excel(name = "是否隐藏")
+    private Integer hide;
+
+    @Excel(name = "可见类型")
+    private Integer permission;
+
+    @Excel(name = "访问密码")
+    private String password;
+
+    @Excel(name = "位置")
+    private Integer position;
+
+    @Excel(name = "仅在顶部显示")
+    private Integer top;
+
+    @Excel(name = "仅在底部显示")
+    private Integer bottom;
+
+    @Excel(name = "选中path")
+    private String active;
+
+    @Excel(name = "其它路由元信息")
+    private String meta;
+
+    @Excel(name = "css样式")
+    private String style;
+
+    @Excel(name = "模型名称")
+    private String modelName;
+
+    @Excel(name = "页面ID")
+    private Integer pageId;
+
+    @Excel(name = "详情页ID")
+    private Integer itemId;
+
+    @Excel(name = "是否微信小程序菜单")
+    private Boolean isMpWeixin;
+
+    @Excel(name = "菜单间距")
+    private Integer gutter;
+
+    @Excel(name = "菜单宽度")
+    private Integer span;
+
+    @Excel(name = "阅读量")
+    private Integer readNum;
+
+    @Excel(name = "商户ID")
+    private Long merchantId;
+
+    @Excel(name = "国际化语言")
+    private String lang;
+
+    @Excel(name = "设为首页")
+    private Integer home;
+
+    @Excel(name = "是否推荐")
+    private Boolean recommend;
+
+    @Excel(name = "排序")
+    private Integer sortNumber;
+
+    @Excel(name = "备注")
+    private String comments;
+
+    @Excel(name = "状态")
+    private Integer status;
+
+    @Excel(name = "用户ID")
+    private Integer userId;
+
+    @Excel(name = "租户ID")
+    private Integer tenantId;
+}
+

src/main/java/com/gxwebsoft/cms/param/CmsOrderParam.java

@@ -0,0 +1,284 @@
+package com.gxwebsoft.cms.param;
+
+import java.math.BigDecimal;
+import com.gxwebsoft.common.core.annotation.QueryField;
+import com.gxwebsoft.common.core.annotation.QueryType;
+import com.gxwebsoft.common.core.web.BaseParam;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 网站订单查询参数
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "CmsOrderParam对象", description = "网站订单查询参数")
+public class CmsOrderParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "id")
+    @QueryField(type = QueryType.EQ)
+    private Integer id;
+
+    @Schema(description = "订单类型，0售前咨询 1售后服务 2意见反馈")
+    @QueryField(type = QueryType.EQ)
+    private Integer type;
+
+    @Schema(description = "订单标题")
+    private String title;
+
+    @Schema(description = "公司/团队名称")
+    private String company;
+
+    @Schema(description = "订单内容")
+    private String content;
+
+    @Schema(description = "订单编号")
+    private String orderNo;
+
+    @Schema(description = "快递/自提")
+    @QueryField(type = QueryType.EQ)
+    private Integer deliveryType;
+
+    @Schema(description = "下单渠道，0网站 1微信小程序 2其他")
+    @QueryField(type = QueryType.EQ)
+    private Integer channel;
+
+    @Schema(description = "微信支付交易号号")
+    private String transactionId;
+
+    @Schema(description = "微信退款订单号")
+    private String refundOrder;
+
+    @Schema(description = "商户ID")
+    @QueryField(type = QueryType.EQ)
+    private Long merchantId;
+
+    @Schema(description = "商户名称")
+    private String merchantName;
+
+    @Schema(description = "商户编号")
+    private String merchantCode;
+
+    @Schema(description = "使用的优惠券id")
+    @QueryField(type = QueryType.EQ)
+    private Integer couponId;
+
+    @Schema(description = "使用的会员卡id")
+    private String cardId;
+
+    @Schema(description = "关联管理员id")
+    @QueryField(type = QueryType.EQ)
+    private Integer adminId;
+
+    @Schema(description = "核销管理员id")
+    @QueryField(type = QueryType.EQ)
+    private Integer confirmId;
+
+    @Schema(description = "IC卡号")
+    private String icCard;
+
+    @Schema(description = "真实姓名")
+    private String realName;
+
+    @Schema(description = "关联收货地址")
+    @QueryField(type = QueryType.EQ)
+    private Integer addressId;
+
+    @Schema(description = "收货地址")
+    private String address;
+
+    private String addressLat;
+
+    private String addressLng;
+
+    @Schema(description = "自提店铺id")
+    @QueryField(type = QueryType.EQ)
+    private Integer selfTakeMerchantId;
+
+    @Schema(description = "自提店铺")
+    private String selfTakeMerchantName;
+
+    @Schema(description = "配送开始时间")
+    private String sendStartTime;
+
+    @Schema(description = "配送结束时间")
+    private String sendEndTime;
+
+    @Schema(description = "发货店铺id")
+    @QueryField(type = QueryType.EQ)
+    private Integer expressMerchantId;
+
+    @Schema(description = "发货店铺")
+    private String expressMerchantName;
+
+    @Schema(description = "订单总额")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal totalPrice;
+
+    @Schema(description = "减少的金额，使用VIP会员折扣、优惠券抵扣、优惠券折扣后减去的价格")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal reducePrice;
+
+    @Schema(description = "实际付款")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal payPrice;
+
+    @Schema(description = "用于统计")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal price;
+
+    @Schema(description = "价钱，用于积分赠送")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal money;
+
+    @Schema(description = "取消时间")
+    private String cancelTime;
+
+    @Schema(description = "取消原因")
+    private String cancelReason;
+
+    @Schema(description = "退款金额")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal refundMoney;
+
+    @Schema(description = "教练价格")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal coachPrice;
+
+    @Schema(description = "购买数量")
+    @QueryField(type = QueryType.EQ)
+    private Integer totalNum;
+
+    @Schema(description = "教练id")
+    @QueryField(type = QueryType.EQ)
+    private Integer coachId;
+
+    @Schema(description = "商品ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer formId;
+
+    @Schema(description = "支付的用户id")
+    @QueryField(type = QueryType.EQ)
+    private Integer payUserId;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    @QueryField(type = QueryType.EQ)
+    private Integer payType;
+
+    @Schema(description = "微信支付子类型：JSAPI小程序支付，NATIVE扫码支付")
+    private String wechatPayType;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    @QueryField(type = QueryType.EQ)
+    private Integer friendPayType;
+
+    @Schema(description = "0未付款，1已付款")
+    @QueryField(type = QueryType.EQ)
+    private Integer payStatus;
+
+    @Schema(description = "0未使用，1已完成，2已取消，3取消中，4退款申请中，5退款被拒绝，6退款成功，7客户端申请退款")
+    @QueryField(type = QueryType.EQ)
+    private Integer orderStatus;
+
+    @Schema(description = "发货状态(10未发货 20已发货 30部分发货)")
+    @QueryField(type = QueryType.EQ)
+    private Integer deliveryStatus;
+
+    @Schema(description = "无需发货备注")
+    private String deliveryNote;
+
+    @Schema(description = "发货时间")
+    private String deliveryTime;
+
+    @Schema(description = "评价状态(0未评价 1已评价)")
+    @QueryField(type = QueryType.EQ)
+    private Integer evaluateStatus;
+
+    @Schema(description = "评价时间")
+    private String evaluateTime;
+
+    @Schema(description = "优惠类型：0无、1抵扣优惠券、2折扣优惠券、3、VIP月卡、4VIP年卡，5VIP次卡、6VIP会员卡、7IC月卡、8IC年卡、9IC次卡、10IC会员卡、11免费订单、12VIP充值卡、13IC充值卡、14VIP季卡、15IC季卡")
+    @QueryField(type = QueryType.EQ)
+    private Integer couponType;
+
+    @Schema(description = "优惠说明")
+    private String couponDesc;
+
+    @Schema(description = "二维码地址，保存订单号，支付成功后才生成")
+    private String qrcode;
+
+    @Schema(description = "vip月卡年卡、ic月卡年卡回退次数")
+    @QueryField(type = QueryType.EQ)
+    private Integer returnNum;
+
+    @Schema(description = "vip充值回退金额")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal returnMoney;
+
+    @Schema(description = "预约详情开始时间数组")
+    private String startTime;
+
+    @Schema(description = "是否已开具发票：0未开发票，1已开发票，2不能开具发票")
+    @QueryField(type = QueryType.EQ)
+    private Integer isInvoice;
+
+    @Schema(description = "发票流水号")
+    private String invoiceNo;
+
+    @Schema(description = "商家留言")
+    private String merchantRemarks;
+
+    @Schema(description = "支付时间")
+    private String payTime;
+
+    @Schema(description = "退款时间")
+    private String refundTime;
+
+    @Schema(description = "申请退款时间")
+    private String refundApplyTime;
+
+    @Schema(description = "过期时间")
+    private String expirationTime;
+
+    @Schema(description = "自提码")
+    private String selfTakeCode;
+
+    @Schema(description = "是否已收到赠品")
+    @QueryField(type = QueryType.EQ)
+    private Boolean hasTakeGift;
+
+    @Schema(description = "对账情况：0=未对账；1=已对账；3=已对账，金额对不上；4=未查询到该订单")
+    @QueryField(type = QueryType.EQ)
+    private Integer checkBill;
+
+    @Schema(description = "订单是否已结算(0未结算 1已结算)")
+    @QueryField(type = QueryType.EQ)
+    private Integer isSettled;
+
+    @Schema(description = "系统版本号 0当前版本 value=其他版本")
+    @QueryField(type = QueryType.EQ)
+    private Integer version;
+
+    @Schema(description = "用户id")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "备注")
+    private String comments;
+
+    @Schema(description = "排序号")
+    @QueryField(type = QueryType.EQ)
+    private Integer sortNumber;
+
+    @Schema(description = "是否删除, 0否, 1是")
+    @QueryField(type = QueryType.EQ)
+    private Integer deleted;
+
+}

src/main/java/com/gxwebsoft/cms/service/CmsOrderService.java

@@ -0,0 +1,42 @@
+package com.gxwebsoft.cms.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+
+import java.util.List;
+
+/**
+ * 网站订单Service
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+public interface CmsOrderService extends IService<CmsOrder> {
+
+    /**
+     * 分页关联查询
+     *
+     * @param param 查询参数
+     * @return PageResult<CmsOrder>
+     */
+    PageResult<CmsOrder> pageRel(CmsOrderParam param);
+
+    /**
+     * 关联查询全部
+     *
+     * @param param 查询参数
+     * @return List<CmsOrder>
+     */
+    List<CmsOrder> listRel(CmsOrderParam param);
+
+    /**
+     * 根据id查询
+     *
+     * @param id id
+     * @return CmsOrder
+     */
+    CmsOrder getByIdRel(Integer id);
+
+}

src/main/java/com/gxwebsoft/cms/service/impl/CmsOrderServiceImpl.java

@@ -0,0 +1,47 @@
+package com.gxwebsoft.cms.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.cms.mapper.CmsOrderMapper;
+import com.gxwebsoft.cms.service.CmsOrderService;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 网站订单Service实现
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+@Service
+public class CmsOrderServiceImpl extends ServiceImpl<CmsOrderMapper, CmsOrder> implements CmsOrderService {
+
+    @Override
+    public PageResult<CmsOrder> pageRel(CmsOrderParam param) {
+        PageParam<CmsOrder, CmsOrderParam> page = new PageParam<>(param);
+        page.setDefaultOrder("sort_number asc, create_time desc");
+        List<CmsOrder> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<CmsOrder> listRel(CmsOrderParam param) {
+        List<CmsOrder> list = baseMapper.selectListRel(param);
+        // 排序
+        PageParam<CmsOrder, CmsOrderParam> page = new PageParam<>();
+        page.setDefaultOrder("sort_number asc, create_time desc");
+        return page.sortRecords(list);
+    }
+
+    @Override
+    public CmsOrder getByIdRel(Integer id) {
+        CmsOrderParam param = new CmsOrderParam();
+        param.setId(id);
+        return param.getOne(baseMapper.selectListRel(param));
+    }
+
+}

src/main/java/com/gxwebsoft/cms/service/impl/CmsWebsiteServiceImpl.java

@@ -337,9 +337,16 @@ public class CmsWebsiteServiceImpl extends ServiceImpl<CmsWebsiteMapper, CmsWebs
     if (StrUtil.isNotBlank(siteInfo)) {
       log.info("从缓存获取网站信息，租户ID: {}", tenantId);
       try {
-        return JSONUtil.parseObject(siteInfo, ShopVo.class);
+        // 兼容历史缓存：JSON "null" 会被解析为 null；此时应视为未命中并回源数据库。
+        ShopVo cacheVo = JSONUtil.parseObject(siteInfo, ShopVo.class);
+        if (cacheVo != null) {
+          return cacheVo;
+        }
+        log.warn("网站信息缓存命中但内容为空(null)，清理缓存后回源数据库，租户ID: {}", tenantId);
+        redisUtil.delete(cacheKey);
       } catch (Exception e) {
-        log.warn("缓存解析失败，从数据库重新获取: {}", e.getMessage());
+        log.warn("缓存解析失败，清理缓存后从数据库重新获取: {}", e.getMessage());
+        redisUtil.delete(cacheKey);
       }
     }
 

src/main/java/com/gxwebsoft/common/core/Constants.java

@@ -65,16 +65,6 @@ public class Constants {
      */
     public static final String BAD_CREDENTIALS_MSG = "请退出重新登录";
 
-    /**
-     * 服务暂不可用错误码（Redis 连接被重置、核心实例不可达等基础设施故障，不是用户凭据问题）
-     */
-    public static final int SERVICE_UNAVAILABLE_CODE = 503;
-
-    /**
-     * 服务暂不可用提示信息
-     */
-    public static final String SERVICE_UNAVAILABLE_MSG = "服务暂不可用，请稍后重试";
-
     /**
      * 表示升序的值
      */

src/main/java/com/gxwebsoft/common/core/config/JacksonConfig.java

@@ -4,7 +4,6 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;

src/main/java/com/gxwebsoft/common/core/config/LocalDateTimeDeserializer.java

@@ -1,11 +1,14 @@
 package com.gxwebsoft.common.core.config;
 
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.JsonDeserializer;
 
 import java.io.IOException;
+import java.time.Instant;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 
 /**
@@ -16,14 +19,43 @@ import java.time.format.DateTimeFormatter;
  */
 public class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
 
-    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+    private final DateTimeFormatter formatter;
+
+    public LocalDateTimeDeserializer() {
+        this(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+    }
+
+    public LocalDateTimeDeserializer(DateTimeFormatter formatter) {
+        this.formatter = formatter;
+    }
 
     @Override
     public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
-        String value = p.getValueAsString();
-        if (value != null && !value.isEmpty()) {
-            return LocalDateTime.parse(value, FORMATTER);
+        JsonToken t = p.currentToken();
+        ZoneId zoneId = ctxt.getTimeZone() != null ? ctxt.getTimeZone().toZoneId() : ZoneId.systemDefault();
+
+        // Accept epoch timestamps (seconds or millis) for compatibility with frontends that send numbers.
+        if (t == JsonToken.VALUE_NUMBER_INT) {
+            long ts = p.getLongValue();
+            // Heuristic: 10+ digits is seconds; 13+ digits is millis (most common in JS).
+            Instant instant = (String.valueOf(Math.abs(ts)).length() >= 13)
+                    ? Instant.ofEpochMilli(ts)
+                    : Instant.ofEpochSecond(ts);
+            return LocalDateTime.ofInstant(instant, zoneId);
         }
-        return null;
+
+        String value = p.getValueAsString();
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+
+        // Handle numeric timestamps passed as strings, e.g. "1769618486000"
+        if (value.chars().allMatch(Character::isDigit)) {
+            long ts = Long.parseLong(value);
+            Instant instant = (value.length() >= 13) ? Instant.ofEpochMilli(ts) : Instant.ofEpochSecond(ts);
+            return LocalDateTime.ofInstant(instant, zoneId);
+        }
+
+        return LocalDateTime.parse(value, formatter);
     }
 }

src/main/java/com/gxwebsoft/common/core/config/SwaggerConfig.java

@@ -80,7 +80,8 @@ public class SwaggerConfig {
     public GroupedOpenApi shopApi() {
         return GroupedOpenApi.builder()
                 .group("shop")
-                .pathsToMatch("/api/shop/**")
+                // 订单等用户侧接口在 shop 包内，但路径使用 /api/user/**（前端统一 user 侧 API 前缀）
+                .pathsToMatch("/api/shop/**", "/api/user/**")
                 .packagesToScan("com.gxwebsoft.shop")
                 .build();
     }

src/main/java/com/gxwebsoft/common/core/controller/TestController.java

@@ -5,7 +5,6 @@ import com.gxwebsoft.common.system.entity.Payment;
 import com.gxwebsoft.common.system.service.PaymentService;
 import com.gxwebsoft.common.system.param.PaymentParam;
 import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.payment.service.WxPayConfigService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -40,9 +39,6 @@ public class TestController extends BaseController {
     @Autowired
     private PaymentService paymentService;
 
-    @Autowired
-    private WxPayConfigService wxPayConfigService;
-
     @Operation(summary = "测试LocalDateTime序列化")
     @GetMapping("/datetime")
     public ApiResult<Map<String, Object>> testDateTime() {
@@ -237,8 +233,6 @@ public class TestController extends BaseController {
             // 清理可能的缓存键
             paymentCacheService.removePaymentConfig("0", tenantId);  // 微信支付
             paymentCacheService.removePaymentConfig("wechat", tenantId);  // 可能的其他格式
-            // 清理实际生效的缓存键：Payment:1:{tenantId} 与内存中的微信支付配置
-            wxPayConfigService.clearConfigCache(tenantId);
 
             String result = "✅ 缓存已清理，租户ID: " + tenantId;
             System.out.println(result);

src/main/java/com/gxwebsoft/common/core/security/AuthFailureUtil.java

@@ -1,64 +0,0 @@
-package com.gxwebsoft.common.core.security;
-
-import io.lettuce.core.RedisException;
-import org.springframework.data.redis.RedisConnectionFailureException;
-import org.springframework.data.redis.RedisSystemException;
-
-import java.io.IOException;
-
-/**
- * 鉴权链路上的失败分类：这次失败是<b>用户凭据问题</b>，还是<b>基础设施抖了一下</b>？
- *
- * <p><b>为什么必须分开</b>：鉴权过滤器里除了「token 无效」，还有两次外部依赖调用——
- * 核心实例的 {@code /auth/user} 与 Redis 的域名白名单读。此前它们抛出的异常与「token 无效」
- * 一起被兜底成 {@code 401 请退出重新登录}，于是线上出现这样一条报文：</p>
- *
- * <pre>
- * {"code":401,"message":"请退出重新登录",
- *  "error":"org.springframework.data.redis.RedisSystemException: Redis exception;
- *           nested exception is io.lettuce.core.RedisException:
- *           java.net.SocketException: Connection reset"}
- * </pre>
- *
- * <p>用户照着这句话去重新登录，什么也解决不了——Redis 连接被重置跟他手里的 token 毫无关系；
- * 而真正的故障（Redis / 核心实例）被「登录态异常」这层皮盖住了，排查方向从一开始就被带偏。
- * 重新登录还会把一份<b>完全有效</b>的凭据丢掉，把一次秒级抖动放大成用户的重复劳动。</p>
- *
- * <p><b>判定方式</b>：沿 cause 链找基础设施异常。之所以要沿链找，是因为真实抛出的异常是套娃的——
- * {@code RedisSystemException → io.lettuce.core.RedisException → java.net.SocketException}、
- * {@code cn.hutool.core.io.IORuntimeException → java.net.ConnectException}，
- * 只看最外层的类型会漏判。凭据类异常（{@code MalformedJwtException} / {@code SignatureException} /
- * {@code UsernameNotFoundException}）的 cause 链里不会出现这些类型。</p>
- */
-public final class AuthFailureUtil {
-
-    /** cause 链的遍历深度上限，防御自引用或异常实现里的环 */
-    private static final int MAX_CAUSE_DEPTH = 16;
-
-    private AuthFailureUtil() {
-    }
-
-    /**
-     * 是否为基础设施故障（Redis 连接被重置/超时、核心实例不可达等）。
-     *
-     * <p>这类失败<b>不该</b>报「请退出重新登录」，应报
-     * {@link com.gxwebsoft.common.core.Constants#SERVICE_UNAVAILABLE_MSG}，让用户稍后重试即可。</p>
-     *
-     * @param e 鉴权过程中抛出的异常
-     * @return true 表示与用户凭据无关，是基础设施的问题
-     */
-    public static boolean isInfrastructureFailure(Throwable e) {
-        Throwable t = e;
-        for (int depth = 0; t != null && depth < MAX_CAUSE_DEPTH; depth++) {
-            if (t instanceof RedisConnectionFailureException
-                    || t instanceof RedisSystemException
-                    || t instanceof RedisException
-                    || t instanceof IOException) {
-                return true;
-            }
-            Throwable cause = t.getCause();
-            t = (cause == t) ? null : cause;
-        }
-        return false;
-    }
-}

src/main/java/com/gxwebsoft/common/core/security/JwtAuthenticationFilter.java

@@ -107,13 +107,6 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
           e.getMessage());
         return;
       } catch (Exception e) {
-        // Redis 连接被重置、核心实例不可达属于基础设施抖动，与用户凭据无关：
-        // 报「请退出重新登录」既解决不了问题，又把真正的故障掩盖成一次登录态异常。
-        if (AuthFailureUtil.isInfrastructureFailure(e)) {
-          CommonUtil.responseError(response, Constants.SERVICE_UNAVAILABLE_CODE,
-            Constants.SERVICE_UNAVAILABLE_MSG, e.toString());
-          return;
-        }
         CommonUtil.responseError(response, Constants.BAD_CREDENTIALS_CODE, Constants.BAD_CREDENTIALS_MSG,
           e.toString());
         return;

src/main/java/com/gxwebsoft/common/core/security/SecurityConfig.java

@@ -67,6 +67,7 @@ public class SecurityConfig {
                         "/api/shop/wx-login/**",
                         "/api/shop/wx-native-pay/**",
                         "/api/shop/wx-pay/**",
+                        "/api/system/wx-pay/**",
                         "/api/bszx/bszx-pay/notify/**",
                         "/api/wxWorkQrConnect",
                         "/WW_verify_QMv7HoblYU6z63bb.txt",
@@ -79,25 +80,7 @@ public class SecurityConfig {
                         "/api/shop/getShopInfo",
                         "/api/shop/shop-order/test",
                         "/api/qr-code/**",
-                        "/api/shop/order-delivery/notify",
-                        "/api/hjc/push/project",
-                        // 汇吉采买家端：注册/登录/验证码/退出都由 mp-java 代理核心实例，
-                        // 必须在登录前可访问；未登录的客户端本来也没有平台 token。
-                        "/api/hjc/auth/register",
-                        "/api/hjc/auth/login",
-                        "/api/hjc/auth/logout",
-                        "/api/hjc/auth/captcha",
-                        "/api/hjc/auth/sms",
-                        // 注册页专用：证件上传与 OCR 识别在登录前发生
-                        "/api/hjc/auth/upload",
-                        "/api/hjc/ocr/recognize",
-                        // 小程序端登录：用 uni.login 的 code 换 openid，发生在业务请求之前，
-                        // 小程序侧此时还没有平台 token
-                        "/api/hjc/wechat/mp-login",
-                        // 密码找回：企业未登录时提交材料申请（进度查询走
-                        // GET /api/hjc/auth/password/apply/status，已被上面的 GET /** 放行）。
-                        // 「修改密码」的两个端点必须保持需要登录态，故刻意不在此列。
-                        "/api/hjc/auth/password/apply"
+                        "/api/shop/order-delivery/notify"
                 )
                 .permitAll()
                 .anyRequest()

src/main/java/com/gxwebsoft/common/core/utils/JSONUtil.java

@@ -1,8 +1,13 @@
 package com.gxwebsoft.common.core.utils;
 
 import cn.hutool.core.util.StrUtil;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectWriter;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+
+import java.util.TimeZone;
 
 /**
  * JSON解析工具类
@@ -11,8 +16,21 @@ import com.fasterxml.jackson.databind.ObjectWriter;
  * @since 2017-06-10 10:10:39
  */
 public class JSONUtil {
-    private static final ObjectMapper objectMapper = new ObjectMapper();
-    private static final ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
+    /**
+     * 注意：不要直接 new ObjectMapper() 否则不支持 Java8 时间类型（LocalDateTime 等）。
+     * 这里做最小可用配置，避免在 Redis/日志/签名等场景序列化失败。
+     */
+    private static final ObjectMapper objectMapper;
+    private static final ObjectWriter objectWriter;
+
+    static {
+        objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
+        objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
+    }
 
     /**
      * 对象转json字符串

src/main/java/com/gxwebsoft/common/core/web/ImportParams.java

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2013-2015 JueYue (qrb.jueyue@gmail.com)
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.gxwebsoft.common.core.web;
+
+import cn.afterturn.easypoi.excel.entity.ExcelBaseParams;
+import cn.afterturn.easypoi.handler.inter.IExcelVerifyHandler;
+import lombok.Data;
+
+/**
+ * 导入参数设置
+ *
+ * @author JueYue
+ *  2013-9-24
+ * @version 1.0
+ */
+@Data
+public class ImportParams extends ExcelBaseParams {
+
+    public static final String SAVE_URL = "/excel/upload/excelUpload";
+
+    /**
+     * 表格标题行数,默认0
+     */
+    private int                 titleRows        = 0;
+    /**
+     * 表头行数,默认1
+     */
+    private int                 headRows         = 1;
+    /**
+     * 字段真正值和列标题之间的距离 默认0
+     */
+    private int                 startRows        = 0;
+
+    /**
+     * 主键设置,如何这个cell没有值,就跳过 或者认为这个是list的下面的值
+     * 大家不理解，去掉这个
+     */
+
+    private Integer             keyIndex         = null;
+    /**
+     * 开始读取的sheet位置,默认为0
+     */
+    private int                 startSheetIndex  = 0;
+    /**
+     * 上传表格需要读取的sheet 数量,默认为1
+     */
+    private int                 sheetNum         = 1;
+    /**
+     * 是否需要保存上传的Excel,默认为false
+     */
+    private boolean             needSave         = false;
+    /**
+     * 校验组
+     */
+    private Class[]             verifyGroup = null;
+    /**
+     * 是否需要校验上传的Excel,默认为false
+     */
+    private boolean             needVerify = false;
+    /**
+     * 返回文件是否分割,默认是分割
+     */
+    private boolean             verifyFileSplit = true;
+    /**
+     * 校验处理接口
+     */
+    private IExcelVerifyHandler verifyHandler;
+    /**
+     * 保存上传的Excel目录,默认是 如 TestEntity这个类保存路径就是
+     * upload/excelUpload/Test/yyyyMMddHHmss_***** 保存名称上传时间_五位随机数
+     */
+    private String              saveUrl          = SAVE_URL;
+    /**
+     * 最后的无效行数
+     */
+    private int                 lastOfInvalidRow = 0;
+    /**
+     * 手动控制读取的行数
+     */
+    private int                 readRows = 0;
+    /**
+     * 导入时校验数据模板,是不是正确的Excel
+     */
+    private String[]            importFields;
+    /**
+     * 导入时校验excel的标题列顺序。依赖于importFields的配置顺序
+    */
+    private boolean             needCheckOrder = false;
+    /**
+     * Key-Value 读取标记,以这个为Key,后面一个Cell 为Value,多个改为ArrayList
+     */
+    private String              keyMark = ":";
+    /**
+     * 按照Key-Value 规则读取全局扫描Excel,但是跳过List读取范围提升性能
+     * 仅仅支持titleRows + headRows + startRows 以及 lastOfInvalidRow
+     */
+    private boolean             readSingleCell = false;
+    /**
+     * 是否并行计算
+     */
+    private boolean             concurrentTask = false;
+    /**
+     * 最小截取大小
+     */
+    private Integer             critical = 1000;
+}

src/main/java/com/gxwebsoft/common/core/websocket/WebSocketConfig.java

@@ -16,4 +16,4 @@ public class WebSocketConfig {
 
         return exporter;
     }
-}
+}

src/main/java/com/gxwebsoft/common/core/websocket/WebSocketServer.java

@@ -35,7 +35,13 @@ public class WebSocketServer {
     public void onOpen(Session session, @PathParam("userId") String userId) {
         this.session = session;
         this.userId = userId;
-        webSocketMap.put(userId, this);
+        if (webSocketMap.containsKey(userId)) {
+            webSocketMap.remove(userId);
+            webSocketMap.put(userId, this);
+            //加入set中
+        } else {
+            webSocketMap.put(userId, this);
+        }
 
         try {
             sendMessage(userId, "连接成功");
@@ -49,24 +55,20 @@ public class WebSocketServer {
      */
     @OnClose
     public void onClose() {
-        webSocketMap.remove(userId, this);
+        if (webSocketMap.containsKey(userId)) {
+            webSocketMap.remove(userId);
+        }
     }
 
 
     /**
      * 实现服务器主动推送
      */
-    public boolean sendMessage(String userId, String message) throws IOException {
-        WebSocketServer webSocketServer = webSocketMap.get(userId);
-        if (webSocketServer == null || webSocketServer.session == null
-            || !webSocketServer.session.isOpen()) {
-            if (webSocketServer != null) {
-                webSocketMap.remove(userId, webSocketServer);
-            }
-            return false;
+    public void sendMessage(String userId, String message) throws IOException {
+        if (webSocketMap.containsKey(userId)) {
+            Session session1 = webSocketMap.get(userId).session;
+            if (session1 != null) session1.getBasicRemote().sendText(message);
         }
-        webSocketServer.session.getBasicRemote().sendText(message);
-        return true;
     }
 
 

src/main/java/com/gxwebsoft/common/system/controller/MenuController.java

@@ -1,20 +1,29 @@
 package com.gxwebsoft.common.system.controller;
 
+import cn.afterturn.easypoi.excel.ExcelImportUtil;
+import cn.afterturn.easypoi.excel.entity.ImportParams;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.gxwebsoft.common.core.annotation.OperationLog;
 import com.gxwebsoft.common.core.web.*;
-import com.gxwebsoft.common.system.entity.Menu;
-import com.gxwebsoft.common.system.entity.Plug;
+import com.gxwebsoft.common.system.entity.*;
+import com.gxwebsoft.common.system.param.MenuImportParam;
 import com.gxwebsoft.common.system.param.MenuParam;
-import com.gxwebsoft.common.system.service.MenuService;
-import com.gxwebsoft.common.system.service.PlugService;
-import io.swagger.v3.oas.annotations.tags.Tag;
+import com.gxwebsoft.common.system.param.VersionParam;
+import com.gxwebsoft.common.system.service.*;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 import javax.annotation.Resource;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * 菜单控制器
@@ -22,21 +31,27 @@ import java.util.List;
  * @author WebSoft
  * @since 2018-12-24 16:10:23
  */
-@Tag(name = "菜单管理")
+@Tag(name = "菜单")
 @RestController
 @RequestMapping("/api/system/menu")
 public class MenuController extends BaseController {
     @Resource
     private MenuService menuService;
     @Resource
-    private PlugService plugService;
+    private CompanyService companyService;
+    @Resource
+    private UserService userService;
+    @Resource
+    private RoleService roleService;
+    @Resource
+    private RoleMenuService roleMenuService;
 
     @PreAuthorize("hasAuthority('sys:menu:list')")
     @Operation(summary = "分页查询菜单")
     @GetMapping("/page")
     public ApiResult<PageResult<Menu>> page(MenuParam param) {
         PageParam<Menu, MenuParam> page = new PageParam<>(param);
-        page.setDefaultOrder("sort_number");
+        page.setDefaultOrder("sort_number asc, create_time desc");
         return success(menuService.page(page, page.getWrapper()));
     }
 
@@ -45,7 +60,7 @@ public class MenuController extends BaseController {
     @GetMapping()
     public ApiResult<List<Menu>> list(MenuParam param) {
         PageParam<Menu, MenuParam> page = new PageParam<>(param);
-        page.setDefaultOrder("sort_number");
+        page.setDefaultOrder("sort_number asc, create_time desc");
         return success(menuService.list(page.getOrderWrapper()));
     }
 
@@ -57,12 +72,18 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:save')")
+    @OperationLog
     @Operation(summary = "添加菜单")
     @PostMapping()
     public ApiResult<?> add(@RequestBody Menu menu) {
         if (menu.getParentId() == null) {
             menu.setParentId(0);
         }
+        // 去除字符串前面的空格
+        menu.setTitle(StrUtil.trimStart(menu.getTitle()));
+        menu.setPath(StrUtil.trimStart(menu.getPath()));
+        menu.setComponent(StrUtil.trimStart(menu.getComponent()));
+        menu.setAuthority(StrUtil.trimStart(menu.getAuthority()));
         if (menuService.save(menu)) {
             return success("添加成功");
         }
@@ -70,9 +91,15 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:update')")
+    @OperationLog
     @Operation(summary = "修改菜单")
     @PutMapping()
     public ApiResult<?> update(@RequestBody Menu menu) {
+        // 去除字符串前面的空格
+        menu.setTitle(StrUtil.trimStart(menu.getTitle()));
+        menu.setPath(StrUtil.trimStart(menu.getPath()));
+        menu.setComponent(StrUtil.trimStart(menu.getComponent()));
+        menu.setAuthority(StrUtil.trimStart(menu.getAuthority()));
         if (menuService.updateById(menu)) {
             return success("修改成功");
         }
@@ -80,6 +107,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:remove')")
+    @OperationLog
     @Operation(summary = "删除菜单")
     @DeleteMapping("/{id}")
     public ApiResult<?> remove(@PathVariable("id") Integer id) {
@@ -90,6 +118,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:save')")
+    @OperationLog
     @Operation(summary = "批量添加菜单")
     @PostMapping("/batch")
     public ApiResult<?> saveBatch(@RequestBody List<Menu> menus) {
@@ -100,6 +129,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:update')")
+    @OperationLog
     @Operation(summary = "批量修改菜单")
     @PutMapping("/batch")
     public ApiResult<?> updateBatch(@RequestBody BatchParam<Menu> batchParam) {
@@ -110,6 +140,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:remove')")
+    @OperationLog
     @Operation(summary = "批量删除菜单")
     @DeleteMapping("/batch")
     public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
@@ -119,14 +150,35 @@ public class MenuController extends BaseController {
         return fail("删除失败");
     }
 
-    @PreAuthorize("hasAuthority('sys:menu:update')")
-    @Operation(summary = "菜单克隆")
-    @PostMapping("/clone")
-    public ApiResult<?> onClone(@RequestBody MenuParam param){
-      if(menuService.cloneMenu(param)){
-        return success("克隆成功,请刷新");
+    @PreAuthorize("hasAuthority('sys:menu:remove')")
+    @Operation(summary = "删除父级以下菜单")
+    @DeleteMapping("/deleteParentMenu/{id}")
+    public ApiResult<?> deleteParentMenu(@PathVariable("id") Integer id) {
+      final List<Menu> list = menuService.list(new LambdaQueryWrapper<Menu>().eq(Menu::getParentId, id));
+      if (CollectionUtils.isEmpty(list)) {
+        menuService.removeById(id);
+        return success("删除成功");
       }
-      return fail("克隆失败");
+      final Set<Integer> ids = list.stream().map(Menu::getMenuId).collect(Collectors.toSet());
+      final List<Menu> list2 = menuService.list(new LambdaUpdateWrapper<Menu>().in(Menu::getParentId, ids));
+      final Set<Integer> collect = list2.stream().map(Menu::getMenuId).collect(Collectors.toSet());
+      if (!CollectionUtils.isEmpty(list2)) {
+        ids.addAll(collect);
+        final List<Menu> list3 = menuService.list(new LambdaUpdateWrapper<Menu>().in(Menu::getParentId, ids));
+        final Set<Integer> collect1 = list3.stream().map(Menu::getMenuId).collect(Collectors.toSet());
+        if (!CollectionUtils.isEmpty(collect1)) {
+          ids.addAll(collect1);
+        }
+        ids.add(id);
+        if (menuService.removeByIds(ids)) {
+          return success("删除成功");
+        }
+      }
+      ids.add(id);
+      if (menuService.removeByIds(ids)) {
+        return success("删除成功");
+      }
+      return fail("删除失败");
     }
 
     @PreAuthorize("hasAuthority('sys:menu:update')")
@@ -135,11 +187,271 @@ public class MenuController extends BaseController {
     public ApiResult<?> install(@PathVariable("id") Integer id){
       if(menuService.install(id)){
         // 更新安装次数
-        final Plug plug = plugService.getOne(new LambdaQueryWrapper<Plug>().eq(Plug::getMenuId, id));
-        plug.setInstalls(plug.getInstalls() + 1);
-        plugService.updateById(plug);
+//        final Plug plug = plugService.getOne(new LambdaQueryWrapper<Plug>().eq(Plug::getMenuId, id));
+//        plug.setInstalls(plug.getInstalls() + 1);
+//        plugService.updateById(plug);
         return success("安装成功");
       }
       return fail("安装失败",id);
     }
+
+    /**
+     * excel批量导入菜单
+     */
+    @PreAuthorize("hasAuthority('sys:menu:save')")
+    @Operation(summary = "批量导入菜单")
+    @Transactional(rollbackFor = {Exception.class})
+    @PostMapping("/import")
+    public ApiResult<?> importBatch(MultipartFile file) {
+        ImportParams importParams = new ImportParams();
+        try {
+            System.out.println("=== 开始菜单导入流程 ===");
+
+            // 检查导入前的菜单数据
+            long beforeCount = menuService.count();
+            System.out.println("导入前菜单总数: " + beforeCount);
+
+            // 检查当前未删除的菜单
+            List<Menu> undeletedMenus = menuService.list(new LambdaQueryWrapper<Menu>().eq(Menu::getDeleted, 0));
+            System.out.println("当前未删除的菜单数: " + undeletedMenus.size());
+            if (!undeletedMenus.isEmpty()) {
+                System.out.println("未删除菜单列表:");
+                for (Menu menu : undeletedMenus) {
+                    System.out.println("  ID: " + menu.getMenuId() + ", 名称: " + menu.getTitle() +
+                        ", 父级ID: " + menu.getParentId() + ", deleted: " + menu.getDeleted());
+                }
+            }
+
+            // 第一步：永久删除已标记为 deleted=1 的记录
+            boolean deleteResult = menuService.remove(new LambdaQueryWrapper<Menu>().eq(Menu::getDeleted, 1));
+            System.out.println("已永久删除标记为deleted=1的菜单记录，结果: " + deleteResult);
+
+            // 第二步：将现有未删除的记录（deleted=0）标记为 deleted=1
+            if (!undeletedMenus.isEmpty()) {
+                LambdaUpdateWrapper<Menu> updateWrapper = new LambdaUpdateWrapper<>();
+                updateWrapper.eq(Menu::getDeleted, 0);
+                updateWrapper.set(Menu::getDeleted, 1);
+                boolean updateResult = menuService.update(updateWrapper);
+                System.out.println("更新未删除菜单记录的结果: " + updateResult);
+            }
+
+            // 检查更新后的菜单数据
+            long afterCleanupCount = menuService.count(new LambdaQueryWrapper<Menu>().eq(Menu::getDeleted, 0));
+            System.out.println("清理后未标记删除的菜单数: " + afterCleanupCount);
+
+            // 第三步：导入XLS文件的内容
+            List<MenuImportParam> list = ExcelImportUtil.importExcel(file.getInputStream(), MenuImportParam.class, importParams);
+            System.out.println("从Excel文件中读取到" + list.size() + "条菜单记录");
+
+            // 存储原始parentId到菜单列表的映射关系
+            Map<Integer, List<MenuImportParam>> menuGroups = new HashMap<>();
+            // 存储原始ID到新菜单对象的映射关系（用于后续设置正确的parentId）
+            Map<Integer, Menu> tempIdMapping = new HashMap<>();
+
+            // 按parentId分组（处理null值）
+            for (MenuImportParam param : list) {
+                Integer parentId = param.getParentId() != null ? param.getParentId() : 0;
+                menuGroups.computeIfAbsent(parentId, k -> new ArrayList<>()).add(param);
+            }
+
+            System.out.println("菜单分组情况:");
+            for (Map.Entry<Integer, List<MenuImportParam>> entry : menuGroups.entrySet()) {
+                System.out.println("  parentId=" + entry.getKey() + " 的菜单数: " + entry.getValue().size());
+            }
+
+            // 先创建所有父级菜单（parentId为0的菜单）
+            List<MenuImportParam> rootMenus = menuGroups.getOrDefault(0, new ArrayList<>());
+            List<Menu> createdRootMenus = new ArrayList<>();
+
+            System.out.println("开始创建" + rootMenus.size() + "个根菜单");
+            for (MenuImportParam param : rootMenus) {
+                Menu menu = convertToMenu(param);
+                menu.setParentId(0); // 根菜单的parentId为0
+                menuService.save(menu);
+                createdRootMenus.add(menu);
+                System.out.println("创建根菜单: " + menu.getTitle() + ", ID: " + menu.getMenuId() + ", 原始ID: " + param.getMenuId());
+
+                // 记录原始ID到新菜单的映射关系
+                if (param.getMenuId() != null) {
+                    tempIdMapping.put(param.getMenuId(), menu);
+                }
+            }
+
+            // 递归创建子级菜单（注意：这里不再处理parentId=0的菜单，因为已经在上面处理过了）
+            System.out.println("开始创建子级菜单（跳过根菜单）");
+            // 只处理非根菜单的子级菜单
+            for (Map.Entry<Integer, List<MenuImportParam>> entry : menuGroups.entrySet()) {
+                Integer parentId = entry.getKey();
+                if (parentId != 0) {  // 跳过根菜单（parentId=0）
+                    System.out.println("处理parentId=" + parentId + "的子菜单");
+                    createChildMenus(menuGroups, tempIdMapping, parentId);
+                }
+            }
+
+            // 获取所有导入的菜单ID
+            List<Integer> allImportedMenuIds = new ArrayList<>();
+            for (Menu menu : tempIdMapping.values()) {
+                allImportedMenuIds.add(menu.getMenuId());
+            }
+
+            System.out.println("总共导入了" + allImportedMenuIds.size() + "个菜单");
+
+            // 显示导入的菜单详情
+            if (!allImportedMenuIds.isEmpty()) {
+                List<Menu> allImportedMenus = menuService.list(new LambdaQueryWrapper<Menu>()
+                    .in(Menu::getMenuId, allImportedMenuIds)
+                    .orderByAsc(Menu::getParentId, Menu::getSortNumber));
+                System.out.println("导入的菜单详情:");
+                for (Menu menu : allImportedMenus) {
+                    System.out.println("  ID: " + menu.getMenuId() + ", 名称: " + menu.getTitle() +
+                        ", 父级ID: " + menu.getParentId() + ", 类型: " + menu.getMenuType());
+                }
+            }
+
+            // 为超级管理员配置菜单权限
+            if (!allImportedMenuIds.isEmpty()) {
+                List<Menu> allImportedMenus = menuService.list(new LambdaQueryWrapper<Menu>()
+                    .in(Menu::getMenuId, allImportedMenuIds));
+                System.out.println("为" + allImportedMenus.size() + "个菜单配置超级管理员权限");
+                configureSuperAdminPermissionsForImportedMenus(allImportedMenus);
+            }
+
+            // 最终检查
+            long finalCount = menuService.count();
+            System.out.println("导入后菜单总数: " + finalCount);
+            System.out.println("=== 菜单导入流程结束 ===");
+
+            return success("成功导入" + list.size() + "条");
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 递归创建子级菜单
+     * @param menuGroups 菜单分组
+     * @param tempIdMapping 临时ID映射关系
+     * @param originalParentId 原始父级ID
+     */
+    private void createChildMenus(Map<Integer, List<MenuImportParam>> menuGroups,
+                                  Map<Integer, Menu> tempIdMapping,
+                                  Integer originalParentId) {
+        System.out.println(">>> 进入createChildMenus方法，处理originalParentId=" + originalParentId);
+
+        // 特殊处理：originalParentId=0的情况已经在主方法中处理过了，这里不应该再处理
+        if (originalParentId == 0) {
+            System.out.println("  跳过originalParentId=0的处理（已在主方法中处理）");
+            System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+            return;
+        }
+
+        List<MenuImportParam> childMenus = menuGroups.get(originalParentId);
+        if (childMenus == null || childMenus.isEmpty()) {
+            System.out.println("  没有找到originalParentId=" + originalParentId + "的子菜单");
+            System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+            return;
+        }
+
+        // 获取新的父级菜单对象
+        Menu parentMenu = tempIdMapping.get(originalParentId);
+        if (parentMenu == null) {
+            System.out.println("  未找到原始ID为" + originalParentId + "的父级菜单，跳过处理");
+            System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+            return;
+        }
+
+        Integer newParentId = parentMenu.getMenuId();
+
+        System.out.println("  创建父级ID为" + originalParentId + "(新ID:" + newParentId + ")的子菜单，共" + childMenus.size() + "个");
+
+        // 创建所有子菜单
+        for (int i = 0; i < childMenus.size(); i++) {
+            MenuImportParam param = childMenus.get(i);
+            System.out.println("    处理第" + (i+1) + "个子菜单，原始ID: " + param.getMenuId() + ", 原始ParentId: " + param.getParentId());
+
+            Menu menu = convertToMenu(param);
+            menu.setParentId(newParentId);
+            menuService.save(menu);
+
+            System.out.println("    创建子菜单: " + menu.getTitle() + ", ID: " + menu.getMenuId() +
+                ", 父级ID: " + menu.getParentId() + ", 原始ID: " + param.getMenuId());
+
+            // 记录原始ID到新菜单的映射关系
+            if (param.getMenuId() != null) {
+                tempIdMapping.put(param.getMenuId(), menu);
+            }
+
+            // 递归创建当前菜单的子级菜单（使用原始ID作为下一个递归的父级ID）
+            System.out.println("    递归调用createChildMenus，处理原始ID=" + param.getMenuId() + "的子菜单");
+            createChildMenus(menuGroups, tempIdMapping, param.getMenuId());
+        }
+
+        System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+    }
+
+    /**
+     * 将MenuImportParam转换为Menu实体
+     * @param param MenuImportParam对象
+     * @return Menu实体
+     */
+    private Menu convertToMenu(MenuImportParam param) {
+        Menu menu = new Menu();
+        menu.setParentId(param.getParentId());
+        menu.setTitle(param.getTitle());
+        menu.setPath(param.getPath());
+        menu.setComponent(param.getComponent());
+        menu.setModules(param.getModules());
+        menu.setModulesUrl(param.getModulesUrl());
+        menu.setMenuType(param.getMenuType());
+        menu.setSortNumber(param.getSortNumber() != null ? param.getSortNumber() : 0);
+        menu.setAuthority(param.getAuthority());
+        menu.setIcon(param.getIcon());
+        menu.setHide(param.getHide());
+        menu.setAppId(param.getAppId());
+        menu.setTenantId(param.getTenantId());
+        menu.setDeleted(0); // 新导入的数据deleted设为0
+        return menu;
+    }
+
+    /**
+     * 为超级管理员配置导入菜单的权限
+     * @param importedMenus 导入的菜单列表
+     */
+    private void configureSuperAdminPermissionsForImportedMenus(List<Menu> importedMenus) {
+        try {
+            // 1.查找当前租户的超管权限的roleId
+            final Role superAdmin = roleService.getOne(new LambdaQueryWrapper<Role>().eq(Role::getRoleCode, "superAdmin"));
+            if (superAdmin == null) {
+                System.out.println("未找到superAdmin角色");
+                return;
+            }
+
+            final Integer roleId = superAdmin.getRoleId();
+            final Integer tenantId = superAdmin.getTenantId();
+
+            // 为所有导入的菜单配置权限
+            for (Menu menu : importedMenus) {
+                RoleMenu roleMenu = new RoleMenu();
+                roleMenu.setRoleId(roleId);
+                roleMenu.setMenuId(menu.getMenuId());
+                roleMenu.setTenantId(tenantId);
+                roleMenuService.save(roleMenu);
+            }
+
+            // 调整根菜单的排序（如果有根菜单的话）
+            for (Menu menu : importedMenus) {
+                if (menu.getParentId() == 0) {
+                    menu.setSortNumber(0);
+                    menuService.updateById(menu);
+                    break;
+                }
+            }
+
+            System.out.println("为超级管理员配置菜单权限成功，共配置了" + importedMenus.size() + "个菜单");
+        } catch (Exception e) {
+            System.err.println("为超级管理员配置菜单权限失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
 }

src/main/java/com/gxwebsoft/common/system/controller/WxLoginController.java

@@ -10,6 +10,8 @@ import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.gxwebsoft.cms.entity.CmsWebsite;
+import com.gxwebsoft.cms.service.CmsWebsiteService;
 import com.gxwebsoft.common.core.config.ConfigProperties;
 import com.gxwebsoft.common.core.exception.BusinessException;
 import com.gxwebsoft.common.core.security.JwtSubject;
@@ -52,7 +54,7 @@ import static com.gxwebsoft.common.core.constants.RedisConstants.MP_WX_KEY;
 public class WxLoginController extends BaseController {
   private final StringRedisTemplate redisTemplate;
   private final OkHttpClient http = new OkHttpClient();
-  private final ObjectMapper om = new ObjectMapper();
+  private final ObjectMapper om;
   private volatile long tokenExpireEpoch = 0L; // 过期的 epoch 秒
   @Resource
   private SettingService settingService;
@@ -74,10 +76,13 @@ public class WxLoginController extends BaseController {
   private ConfigProperties config;
   @Resource
   private UserRefereeService userRefereeService;
+  @Resource
+  private CmsWebsiteService cmsWebsiteService;
 
 
-  public WxLoginController(StringRedisTemplate redisTemplate) {
+  public WxLoginController(StringRedisTemplate redisTemplate, ObjectMapper objectMapper) {
     this.redisTemplate = redisTemplate;
+    this.om = objectMapper;
   }
 
   @Operation(summary = "获取微信AccessToken")
@@ -442,6 +447,13 @@ public class WxLoginController extends BaseController {
       map.put("page", "pages/index/index");
       map.put("env_version", "release");
 
+      // 判断应用运行状态
+      final CmsWebsite website = cmsWebsiteService.getByTenantId(tenantId);
+      if(website.getRunning().equals(2)){
+        map.put("check_path",false);
+        map.put("env_version","trial");
+      }
+
       String jsonBody = JSON.toJSONString(map);
       System.out.println("请求的 JSON body = " + jsonBody);
 

src/main/java/com/gxwebsoft/common/system/entity/Menu.java

@@ -1,13 +1,12 @@
 package com.gxwebsoft.common.system.entity;
 
 import com.baomidou.mybatisplus.annotation.*;
-import io.swagger.v3.oas.annotations.media.Schema;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import org.springframework.security.core.GrantedAuthority;
 
-import java.time.LocalDateTime;
-import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -19,6 +18,7 @@ import java.util.List;
 @Data
 @Schema(description = "菜单")
 @TableName("sys_menu")
+@JsonIgnoreProperties(ignoreUnknown = true)
 public class Menu implements GrantedAuthority {
     private static final long serialVersionUID = 1L;
     public static final int TYPE_MENU = 0;  // 菜单类型
@@ -40,9 +40,19 @@ public class Menu implements GrantedAuthority {
     @Schema(description = "菜单组件地址")
     private String component;
 
+    @Schema(description = "模块ID")
+    private String modules;
+
+    @Schema(description = "模块API")
+    private String modulesUrl;
+
     @Schema(description = "菜单类型, 0菜单, 1按钮")
     private Integer menuType;
 
+    @Schema(description = "打开方式, 0当前页, 1新窗口")
+    @TableField(exist = false)
+    private Integer openType;
+
     @Schema(description = "排序号")
     private Integer sortNumber;
 
@@ -69,12 +79,10 @@ public class Menu implements GrantedAuthority {
     private Integer tenantId;
 
     @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
+    private Date createTime;
 
     @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
+    private Date updateTime;
 
     @Schema(description = "子菜单")
     @TableField(exist = false)

src/main/java/com/gxwebsoft/common/system/mapper/xml/UserRoleMapper.xml

@@ -3,7 +3,7 @@
 <mapper namespace="com.gxwebsoft.common.system.mapper.UserRoleMapper">
 
     <insert id="insertBatch">
-        INSERT INTO sys_user_role(user_id, role_id) VALUES
+        INSERT INTO gxwebsoft_core.sys_user_role(user_id, role_id) VALUES
         <foreach collection="roleIds" item="roleId" separator=",">
             (#{userId}, #{roleId})
         </foreach>
@@ -11,10 +11,10 @@
 
     <select id="selectByUserId" resultType="com.gxwebsoft.common.system.entity.Role">
         SELECT *
-        FROM sys_role
+        FROM gxwebsoft_core.sys_role
         WHERE role_id IN (
             SELECT role_id
-            FROM sys_user_role
+            FROM gxwebsoft_core.sys_user_role
             WHERE user_id = #{userId}
         )
           AND deleted = 0
@@ -23,7 +23,7 @@
 
     <select id="selectByUserIds" resultType="com.gxwebsoft.common.system.entity.Role">
         SELECT a.user_id, b.*
-        FROM sys_user_role a
+        FROM gxwebsoft_core.sys_user_role a
         LEFT JOIN gxwebsoft_core.sys_role b ON a.role_id = b.role_id
         WHERE a.user_id IN
         <foreach collection="userIds" open="(" close=")" separator="," item="userId">

src/main/java/com/gxwebsoft/common/system/param/MenuImportParam.java

@@ -0,0 +1,60 @@
+package com.gxwebsoft.common.system.param;
+
+import cn.afterturn.easypoi.excel.annotation.Excel;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 菜单导入参数
+ *
+ * @author WebSoft
+ * @since 2025-09-30
+ */
+@Data
+public class MenuImportParam implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Excel(name = "菜单ID")
+    private Integer menuId;
+
+    @Excel(name = "父级ID")
+    private Integer parentId;
+
+    @Excel(name = "菜单名称")
+    private String title;
+
+    @Excel(name = "路由地址")
+    private String path;
+
+    @Excel(name = "组件路径")
+    private String component;
+
+    @Excel(name = "模块ID")
+    private String modules;
+
+    @Excel(name = "模块API")
+    private String modulesUrl;
+
+    @Excel(name = "菜单类型")
+    private Integer menuType;
+
+    @Excel(name = "排序号")
+    private Integer sortNumber;
+
+    @Excel(name = "权限标识")
+    private String authority;
+
+    @Excel(name = "图标")
+    private String icon;
+
+    @Excel(name = "是否隐藏")
+    private Integer hide;
+
+    @Excel(name = "关联应用")
+    private Integer appId;
+
+    @Excel(name = "租户id")
+    private Integer tenantId;
+
+}

src/main/java/com/gxwebsoft/common/system/param/MenuParam.java

@@ -1,11 +1,11 @@
 package com.gxwebsoft.common.system.param;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.gxwebsoft.common.core.annotation.QueryField;
 import com.gxwebsoft.common.core.annotation.QueryType;
 import com.gxwebsoft.common.core.web.BaseParam;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -40,10 +40,17 @@ public class MenuParam extends BaseParam {
     @Schema(description = "菜单组件地址")
     private String component;
 
+    @Schema(description = "模块ID")
+    private String modules;
+
     @Schema(description = "菜单类型, 0菜单, 1按钮")
     @QueryField(type = QueryType.EQ)
     private Integer menuType;
 
+    @Schema(description = "打开方式, 0当前页, 1新窗口")
+    @TableField(exist = false)
+    private Integer openType;
+
     @Schema(description = "权限标识")
     private String authority;
 
@@ -65,4 +72,12 @@ public class MenuParam extends BaseParam {
     @QueryField(type = QueryType.EQ)
     private Integer tenantId;
 
+    @Schema(description = "企业ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer companyId;
+
+    @Schema(description = "租户名称")
+    @TableField(exist = false)
+    private String tenantName;
+
 }

src/main/java/com/gxwebsoft/common/system/param/VersionParam.java

@@ -0,0 +1,70 @@
+package com.gxwebsoft.common.system.param;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.gxwebsoft.common.core.annotation.QueryField;
+import com.gxwebsoft.common.core.annotation.QueryType;
+import com.gxwebsoft.common.core.web.BaseParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 版本更新查询参数
+ *
+ * @author 科技小王子
+ * @since 2024-01-15 18:52:24
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "VersionParam对象", description = "版本更新查询参数")
+public class VersionParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer id;
+
+    @Schema(description = "版本名")
+    private String versionName;
+
+    @Schema(description = "版本号")
+    @QueryField(type = QueryType.EQ)
+    private Integer versionCode;
+
+    @Schema(description = "下载链接")
+    private String androidDownloadUrl;
+
+    @Schema(description = "下载链接")
+    private String iosDownloadUrl;
+
+    @Schema(description = "更新日志")
+    private String updateInfo;
+
+    @Schema(description = "强制更新")
+    @QueryField(type = QueryType.EQ)
+    private Integer isHard;
+
+    @Schema(description = "热更")
+    @QueryField(type = QueryType.EQ)
+    private Integer isHot;
+
+    @Schema(description = "备注")
+    private String comments;
+
+    @Schema(description = "文章排序(数字越小越靠前)")
+    @QueryField(type = QueryType.EQ)
+    private Integer sortNumber;
+
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "状态, 0正常, 1冻结")
+    @QueryField(type = QueryType.EQ)
+    private Integer status;
+
+    @Schema(description = "是否删除, 0否, 1是")
+    @QueryField(type = QueryType.EQ)
+    private Integer deleted;
+
+}

src/main/java/com/gxwebsoft/common/system/service/WxMiniappAccessTokenService.java

@@ -0,0 +1,18 @@
+package com.gxwebsoft.common.system.service;
+
+/**
+ * 微信小程序 access_token 获取服务（按租户）。
+ *
+ * <p>用于调用微信小程序开放接口（例如：上传发货信息）。</p>
+ */
+public interface WxMiniappAccessTokenService {
+
+    /**
+     * 获取指定租户的小程序 access_token（内部带缓存）。
+     *
+     * @param tenantId 租户ID
+     * @return access_token
+     */
+    String getAccessToken(Integer tenantId);
+}
+

src/main/java/com/gxwebsoft/common/system/service/impl/WxMiniappAccessTokenServiceImpl.java

@@ -0,0 +1,108 @@
+package com.gxwebsoft.common.system.service.impl;
+
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.gxwebsoft.common.core.exception.BusinessException;
+import com.gxwebsoft.common.core.utils.RedisUtil;
+import com.gxwebsoft.common.system.service.WxMiniappAccessTokenService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.concurrent.TimeUnit;
+
+import static com.gxwebsoft.common.core.constants.RedisConstants.ACCESS_TOKEN_KEY;
+import static com.gxwebsoft.common.core.constants.RedisConstants.MP_WX_KEY;
+
+/**
+ * 微信小程序 access_token 获取实现（按租户）。
+ *
+ * <p>复用现有缓存结构：
+ * <ul>
+ *   <li>小程序配置：Redis key = {@code mp-weixin:{tenantId}}，value 为 JSON，包含 appId/appSecret</li>
+ *   <li>access_token：Redis key = {@code access-token:{tenantId}}，value 为微信返回的 JSON 字符串</li>
+ * </ul>
+ * </p>
+ */
+@Slf4j
+@Service
+public class WxMiniappAccessTokenServiceImpl implements WxMiniappAccessTokenService {
+
+    @Resource
+    private RedisUtil redisUtil;
+
+    @Override
+    public String getAccessToken(Integer tenantId) {
+        if (tenantId == null) {
+            throw new BusinessException("tenantId 不能为空");
+        }
+
+        final String tokenCacheKey = ACCESS_TOKEN_KEY + ":" + tenantId;
+
+        // 1) 优先从缓存取（兼容 JSON 或纯字符串 token 的历史格式）
+        String cachedValue = redisUtil.get(tokenCacheKey);
+        if (StrUtil.isNotBlank(cachedValue)) {
+            try {
+                JSONObject cachedJson = JSON.parseObject(cachedValue);
+                String accessToken = cachedJson.getString("access_token");
+                if (StrUtil.isNotBlank(accessToken)) {
+                    return accessToken;
+                }
+            } catch (Exception ignore) {
+                // 旧格式：直接存 token
+                return cachedValue;
+            }
+        }
+
+        // 2) 缓存没有则从租户配置获取 appId/appSecret
+        final String wxConfigKey = MP_WX_KEY + tenantId;
+        final String wxConfigValue = redisUtil.get(wxConfigKey);
+        if (StrUtil.isBlank(wxConfigValue)) {
+            throw new BusinessException("未找到微信小程序配置，请检查缓存key: " + wxConfigKey);
+        }
+
+        JSONObject wxConfig;
+        try {
+            wxConfig = JSON.parseObject(wxConfigValue);
+        } catch (Exception e) {
+            throw new BusinessException("微信小程序配置格式错误: " + e.getMessage());
+        }
+
+        final String appId = wxConfig.getString("appId");
+        final String appSecret = wxConfig.getString("appSecret");
+        if (StrUtil.isBlank(appId) || StrUtil.isBlank(appSecret)) {
+            throw new BusinessException("微信小程序配置不完整(appId/appSecret)");
+        }
+
+        // 3) 调用微信接口获取 token
+        final String apiUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential"
+                + "&appid=" + appId + "&secret=" + appSecret;
+        String result = HttpUtil.get(apiUrl);
+
+        JSONObject json = JSON.parseObject(result);
+        if (json.containsKey("errcode") && json.getIntValue("errcode") != 0) {
+            Integer errcode = json.getInteger("errcode");
+            String errmsg = json.getString("errmsg");
+            throw new BusinessException("获取小程序access_token失败: " + errmsg + " (errcode: " + errcode + ")");
+        }
+
+        String accessToken = json.getString("access_token");
+        Integer expiresIn = json.getInteger("expires_in");
+        if (StrUtil.isBlank(accessToken)) {
+            throw new BusinessException("获取小程序access_token失败: access_token为空");
+        }
+
+        // 4) 缓存微信原始 JSON（与现有实现保持一致），提前5分钟过期
+        long ttlSeconds = 7000L;
+        if (expiresIn != null && expiresIn > 300) {
+            ttlSeconds = expiresIn - 300L;
+        }
+        redisUtil.set(tokenCacheKey, result, ttlSeconds, TimeUnit.SECONDS);
+
+        log.info("获取小程序access_token成功 - tenantId={}, ttlSeconds={}", tenantId, ttlSeconds);
+        return accessToken;
+    }
+}
+

src/main/java/com/gxwebsoft/credit/controller/CreditAdministrativeLicenseController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditAdministrativeLicense;
 import com.gxwebsoft.credit.param.CreditAdministrativeLicenseImportParam;
 import com.gxwebsoft.credit.param.CreditAdministrativeLicenseParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditAdministrativeLicenseService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 行政许可控制器
@@ -41,6 +46,12 @@ public class CreditAdministrativeLicenseController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询行政许可")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditAdministrativeLicense>> page(CreditAdministrativeLicenseParam param) {
@@ -133,6 +144,45 @@ public class CreditAdministrativeLicenseController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditAdministrativeLicense:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditAdministrativeLicenseService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditAdministrativeLicense::getId,
+            CreditAdministrativeLicense::setId,
+            CreditAdministrativeLicense::getName,
+            CreditAdministrativeLicense::getCompanyId,
+            CreditAdministrativeLicense::setCompanyId,
+            CreditAdministrativeLicense::getHasData,
+            CreditAdministrativeLicense::setHasData,
+            CreditAdministrativeLicense::getTenantId,
+            CreditAdministrativeLicense::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入行政许可
      */
@@ -143,6 +193,7 @@ public class CreditAdministrativeLicenseController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditAdministrativeLicenseImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -185,6 +236,9 @@ public class CreditAdministrativeLicenseController extends BaseController {
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -207,6 +261,10 @@ public class CreditAdministrativeLicenseController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -311,6 +369,8 @@ public class CreditAdministrativeLicenseController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.ADMINISTRATIVE_LICENSE, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -322,6 +382,245 @@ public class CreditAdministrativeLicenseController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史行政许可（仅解析“历史行政许可”选项卡）
+     * 规则：优先按编号(code)匹配；code 为空时按名称(name)匹配；匹配到则覆盖更新（recommend++ 记录更新次数）。
+     */
+    @PreAuthorize("hasAuthority('credit:creditAdministrativeLicense:save')")
+    @Operation(summary = "批量导入历史行政许可")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史行政许可");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史行政许可”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditAdministrativeLicenseImportParam> importResult = ExcelImportSupport.read(
+                file, CreditAdministrativeLicenseImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditAdministrativeLicenseImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCode = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "决定文书/许可编号");
+            Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "决定文书/许可证名称");
+
+            LinkedHashMap<String, CreditAdministrativeLicense> latestByKey = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByKey = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditAdministrativeLicenseImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditAdministrativeLicense item = convertImportParamToEntity(param);
+                    if (item.getCode() != null) {
+                        item.setCode(item.getCode().trim());
+                    }
+                    if (item.getName() != null) {
+                        item.setName(item.getName().trim());
+                    }
+
+                    if (ImportHelper.isBlank(item.getName())) {
+                        errorMessages.add("第" + excelRowNumber + "行：决定文书/许可证名称不能为空");
+                        continue;
+                    }
+
+                    String link = null;
+                    if (!ImportHelper.isBlank(item.getCode())) {
+                        link = urlByCode.get(item.getCode());
+                    }
+                    if ((link == null || link.isEmpty()) && !ImportHelper.isBlank(item.getName())) {
+                        link = urlByName.get(item.getName());
+                    }
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    String dedupKey = !ImportHelper.isBlank(item.getCode()) ? ("CODE:" + item.getCode()) : ("NAME:" + item.getName());
+                    latestByKey.put(dedupKey, item);
+                    latestRowByKey.put(dedupKey, excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByKey.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditAdministrativeLicense> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditAdministrativeLicense> entry : latestByKey.entrySet()) {
+                String dedupKey = entry.getKey();
+                CreditAdministrativeLicense item = entry.getValue();
+                Integer rowNo = latestRowByKey.get(dedupKey);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertByCodeOrNameAndIncrementCounterOnUpdate(
+                            creditAdministrativeLicenseService,
+                            chunkItems,
+                            CreditAdministrativeLicense::getId,
+                            CreditAdministrativeLicense::setId,
+                            CreditAdministrativeLicense::getCode,
+                            CreditAdministrativeLicense::getCode,
+                            CreditAdministrativeLicense::getName,
+                            CreditAdministrativeLicense::getName,
+                            CreditAdministrativeLicense::getRecommend,
+                            CreditAdministrativeLicense::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditAdministrativeLicenseService.save(rowItem);
+                            if (!saved) {
+                                CreditAdministrativeLicense existing = null;
+                                if (!ImportHelper.isBlank(rowItem.getCode())) {
+                                    existing = creditAdministrativeLicenseService.lambdaQuery()
+                                        .eq(CreditAdministrativeLicense::getCode, rowItem.getCode())
+                                        .select(CreditAdministrativeLicense::getId, CreditAdministrativeLicense::getRecommend)
+                                        .one();
+                                }
+                                if (existing == null && !ImportHelper.isBlank(rowItem.getName())) {
+                                    existing = creditAdministrativeLicenseService.lambdaQuery()
+                                        .eq(CreditAdministrativeLicense::getName, rowItem.getName())
+                                        .select(CreditAdministrativeLicense::getId, CreditAdministrativeLicense::getRecommend)
+                                        .one();
+                                }
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditAdministrativeLicenseService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertByCodeOrNameAndIncrementCounterOnUpdate(
+                        creditAdministrativeLicenseService,
+                        chunkItems,
+                        CreditAdministrativeLicense::getId,
+                        CreditAdministrativeLicense::setId,
+                        CreditAdministrativeLicense::getCode,
+                        CreditAdministrativeLicense::getCode,
+                        CreditAdministrativeLicense::getName,
+                        CreditAdministrativeLicense::getName,
+                        CreditAdministrativeLicense::getRecommend,
+                        CreditAdministrativeLicense::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditAdministrativeLicenseService.save(rowItem);
+                        if (!saved) {
+                            CreditAdministrativeLicense existing = null;
+                            if (!ImportHelper.isBlank(rowItem.getCode())) {
+                                existing = creditAdministrativeLicenseService.lambdaQuery()
+                                    .eq(CreditAdministrativeLicense::getCode, rowItem.getCode())
+                                    .select(CreditAdministrativeLicense::getId, CreditAdministrativeLicense::getRecommend)
+                                    .one();
+                            }
+                            if (existing == null && !ImportHelper.isBlank(rowItem.getName())) {
+                                existing = creditAdministrativeLicenseService.lambdaQuery()
+                                    .eq(CreditAdministrativeLicense::getName, rowItem.getName())
+                                    .select(CreditAdministrativeLicense::getId, CreditAdministrativeLicense::getRecommend)
+                                    .one();
+                            }
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditAdministrativeLicenseService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.ADMINISTRATIVE_LICENSE, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载行政许可导入模板
      */

src/main/java/com/gxwebsoft/credit/controller/CreditBankruptcyController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditBankruptcy;
 import com.gxwebsoft.credit.param.CreditBankruptcyImportParam;
 import com.gxwebsoft.credit.param.CreditBankruptcyParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditBankruptcyService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 破产重整控制器
@@ -41,6 +46,12 @@ public class CreditBankruptcyController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询破产重整")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditBankruptcy>> page(CreditBankruptcyParam param) {
@@ -133,6 +144,45 @@ public class CreditBankruptcyController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditBankruptcy:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditBankruptcyService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditBankruptcy::getId,
+            CreditBankruptcy::setId,
+            CreditBankruptcy::getParty,
+            CreditBankruptcy::getCompanyId,
+            CreditBankruptcy::setCompanyId,
+            CreditBankruptcy::getHasData,
+            CreditBankruptcy::setHasData,
+            CreditBankruptcy::getTenantId,
+            CreditBankruptcy::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入破产重整
      */
@@ -143,6 +193,7 @@ public class CreditBankruptcyController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditBankruptcyImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -180,6 +231,9 @@ public class CreditBankruptcyController extends BaseController {
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -202,6 +256,10 @@ public class CreditBankruptcyController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -286,6 +344,8 @@ public class CreditBankruptcyController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BANKRUPTCY, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -297,6 +357,209 @@ public class CreditBankruptcyController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史破产重整（仅解析“历史破产重整”选项卡）
+     * 规则：案号/唯一标识相同则覆盖更新（recommend++ 记录更新次数）；不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditBankruptcy:save')")
+    @Operation(summary = "批量导入历史破产重整")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史破产重整");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史破产重整”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditBankruptcyImportParam> importResult = ExcelImportSupport.read(
+                file, CreditBankruptcyImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditBankruptcyImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCode = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+
+            LinkedHashMap<String, CreditBankruptcy> latestByCode = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCode = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditBankruptcyImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditBankruptcy item = convertImportParamToEntity(param);
+                    if (item.getCode() != null) {
+                        item.setCode(item.getCode().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCode())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = urlByCode.get(item.getCode());
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+
+                    latestByCode.put(item.getCode(), item);
+                    latestRowByCode.put(item.getCode(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCode.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditBankruptcy> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditBankruptcy> entry : latestByCode.entrySet()) {
+                String code = entry.getKey();
+                CreditBankruptcy item = entry.getValue();
+                Integer rowNo = latestRowByCode.get(code);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditBankruptcyService,
+                            chunkItems,
+                            CreditBankruptcy::getId,
+                            CreditBankruptcy::setId,
+                            CreditBankruptcy::getCode,
+                            CreditBankruptcy::getCode,
+                            CreditBankruptcy::getRecommend,
+                            CreditBankruptcy::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditBankruptcyService.save(rowItem);
+                            if (!saved) {
+                                CreditBankruptcy existing = creditBankruptcyService.lambdaQuery()
+                                    .eq(CreditBankruptcy::getCode, rowItem.getCode())
+                                    .select(CreditBankruptcy::getId, CreditBankruptcy::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditBankruptcyService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditBankruptcyService,
+                        chunkItems,
+                        CreditBankruptcy::getId,
+                        CreditBankruptcy::setId,
+                        CreditBankruptcy::getCode,
+                        CreditBankruptcy::getCode,
+                        CreditBankruptcy::getRecommend,
+                        CreditBankruptcy::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditBankruptcyService.save(rowItem);
+                        if (!saved) {
+                            CreditBankruptcy existing = creditBankruptcyService.lambdaQuery()
+                                .eq(CreditBankruptcy::getCode, rowItem.getCode())
+                                .select(CreditBankruptcy::getId, CreditBankruptcy::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditBankruptcyService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BANKRUPTCY, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载破产重整导入模板
      */

src/main/java/com/gxwebsoft/credit/controller/CreditBranchController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditBranch;
 import com.gxwebsoft.credit.param.CreditBranchImportParam;
 import com.gxwebsoft.credit.param.CreditBranchParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditBranchService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 分支机构控制器
@@ -41,6 +45,12 @@ public class CreditBranchController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询分支机构")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditBranch>> page(CreditBranchParam param) {
@@ -133,6 +143,45 @@ public class CreditBranchController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditBranch:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditBranchService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditBranch::getId,
+            CreditBranch::setId,
+            CreditBranch::getName,
+            CreditBranch::getCompanyId,
+            CreditBranch::setCompanyId,
+            CreditBranch::getHasData,
+            CreditBranch::setHasData,
+            CreditBranch::getTenantId,
+            CreditBranch::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入分支机构
      */
@@ -143,6 +192,7 @@ public class CreditBranchController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditBranchImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -202,6 +252,10 @@ public class CreditBranchController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -286,6 +340,8 @@ public class CreditBranchController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BRANCH, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditBreachOfTrustController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditBreachOfTrust;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.param.CreditBreachOfTrustImportParam;
 import com.gxwebsoft.credit.param.CreditBreachOfTrustParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditBreachOfTrustService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -23,7 +25,11 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.time.LocalDate;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 失信被执行人控制器
@@ -41,6 +47,12 @@ public class CreditBreachOfTrustController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询失信被执行人")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditBreachOfTrust>> page(CreditBreachOfTrustParam param) {
@@ -128,6 +140,49 @@ public class CreditBreachOfTrustController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditBreachOfTrust:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditBreachOfTrustService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditBreachOfTrust::getId,
+            CreditBreachOfTrust::setId,
+            CreditBreachOfTrust::getCompanyId,
+            CreditBreachOfTrust::setCompanyId,
+            CreditBreachOfTrust::getHasData,
+            CreditBreachOfTrust::setHasData,
+            CreditBreachOfTrust::getTenantId,
+            CreditBreachOfTrust::new,
+            CreditBreachOfTrust::getPlaintiffAppellant,
+            CreditBreachOfTrust::getAppellee,
+            CreditBreachOfTrust::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入失信被执行人
      */
@@ -138,13 +193,16 @@ public class CreditBreachOfTrustController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "失信被执行人", 0);
+            ExcelImportSupport.ImportResult<CreditBreachOfTrustImportParam> importResult = ExcelImportSupport.read(
+                file, CreditBreachOfTrustImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditBreachOfTrustImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -153,6 +211,7 @@ public class CreditBreachOfTrustController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -160,13 +219,22 @@ public class CreditBreachOfTrustController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditBreachOfTrustImportParam param = list.get(i);
                 try {
                     CreditBreachOfTrust item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -189,6 +257,10 @@ public class CreditBreachOfTrustController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -273,6 +345,8 @@ public class CreditBreachOfTrustController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BREACH_OF_TRUST, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -284,29 +358,234 @@ public class CreditBreachOfTrustController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史失信被执行人（仅解析“历史失信被执行人”选项卡）
+     * 规则：案号相同则覆盖更新（recommend++ 记录更新次数）；案号不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditBreachOfTrust:save')")
+    @Operation(summary = "批量导入历史失信被执行人")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史失信被执行人");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史失信被执行人”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditBreachOfTrustImportParam> importResult = ExcelImportSupport.read(
+                file, CreditBreachOfTrustImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditBreachOfTrustImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+
+            // 同案号多条：以导入文件中“最后一条”为准（视为最新）
+            LinkedHashMap<String, CreditBreachOfTrust> latestByCaseNumber = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditBreachOfTrustImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditBreachOfTrust item = convertImportParamToEntity(param);
+                    if (item.getCaseNumber() != null) {
+                        item.setCaseNumber(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCaseNumber())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = urlByCaseNumber.get(item.getCaseNumber());
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    latestByCaseNumber.put(item.getCaseNumber(), item);
+                    latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCaseNumber.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditBreachOfTrust> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditBreachOfTrust> entry : latestByCaseNumber.entrySet()) {
+                String caseNumber = entry.getKey();
+                CreditBreachOfTrust item = entry.getValue();
+                Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditBreachOfTrustService,
+                            chunkItems,
+                            CreditBreachOfTrust::getId,
+                            CreditBreachOfTrust::setId,
+                            CreditBreachOfTrust::getCaseNumber,
+                            CreditBreachOfTrust::getCaseNumber,
+                            CreditBreachOfTrust::getRecommend,
+                            CreditBreachOfTrust::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditBreachOfTrustService.save(rowItem);
+                            if (!saved) {
+                                CreditBreachOfTrust existing = creditBreachOfTrustService.lambdaQuery()
+                                    .eq(CreditBreachOfTrust::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditBreachOfTrust::getId, CreditBreachOfTrust::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditBreachOfTrustService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditBreachOfTrustService,
+                        chunkItems,
+                        CreditBreachOfTrust::getId,
+                        CreditBreachOfTrust::setId,
+                        CreditBreachOfTrust::getCaseNumber,
+                        CreditBreachOfTrust::getCaseNumber,
+                        CreditBreachOfTrust::getRecommend,
+                        CreditBreachOfTrust::setRecommend,
+                        null,
+                        mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditBreachOfTrustService.save(rowItem);
+                            if (!saved) {
+                                CreditBreachOfTrust existing = creditBreachOfTrustService.lambdaQuery()
+                                    .eq(CreditBreachOfTrust::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditBreachOfTrust::getId, CreditBreachOfTrust::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditBreachOfTrustService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BREACH_OF_TRUST, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载失信被执行人导入模板
      */
     @Operation(summary = "下载失信被执行人导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditBreachOfTrustImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
+        CreditBreachOfTrustImportParam example = new CreditBreachOfTrustImportParam();
         example.setDataType("失信被执行人");
+        example.setCaseNumber("（2024）示例案号");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
         example.setOtherPartiesThirdParty("第三人示例");
+        example.setInvolvedAmount("20,293.91");
+        example.setDataStatus("正常");
         example.setOccurrenceTime("2024-01-01");
-        example.setCaseNumber("（2024）示例案号");
-        example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
-        example.setComments("备注信息");
+        example.setReleaseDate("2024-01-01");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("失信被执行人导入模板", "失信被执行人", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("失信被执行人导入模板", "失信被执行人", CreditBreachOfTrustImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_breach_of_trust_import_template.xlsx");
@@ -315,29 +594,46 @@ public class CreditBreachOfTrustController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditBreachOfTrustImportParam param) {
         if (param == null) {
             return true;
         }
         return ImportHelper.isBlank(param.getCaseNumber())
             && ImportHelper.isBlank(param.getPlaintiffAppellant())
+            && ImportHelper.isBlank(param.getPlaintiffAppellant2())
             && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+            && ImportHelper.isBlank(param.getAppellee2());
     }
 
-    private CreditBreachOfTrust convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditBreachOfTrust convertImportParamToEntity(CreditBreachOfTrustImportParam param) {
         CreditBreachOfTrust entity = new CreditBreachOfTrust();
 
         entity.setDataType(param.getDataType());
-        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
-        entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
         entity.setCaseNumber(param.getCaseNumber());
-        entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
-        entity.setCourtName(param.getCourtName());
+
+        String plaintiffAppellant = !ImportHelper.isBlank(param.getPlaintiffAppellant2())
+            ? param.getPlaintiffAppellant2()
+            : param.getPlaintiffAppellant();
+        entity.setPlaintiffAppellant(plaintiffAppellant);
+
+        String appellee = !ImportHelper.isBlank(param.getAppellee2())
+            ? param.getAppellee2()
+            : param.getAppellee();
+        entity.setAppellee(appellee);
+
+        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
         entity.setDataStatus(param.getDataStatus());
+
+        entity.setInvolvedAmount(!ImportHelper.isBlank(param.getInvolvedAmount2())
+            ? param.getInvolvedAmount2()
+            : param.getInvolvedAmount());
+        entity.setOccurrenceTime(!ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime());
+        entity.setCourtName(!ImportHelper.isBlank(param.getCourtName2())
+            ? param.getCourtName2()
+            : param.getCourtName());
+        entity.setReleaseDate(param.getReleaseDate());
         entity.setComments(param.getComments());
 
         return entity;

src/main/java/com/gxwebsoft/credit/controller/CreditCaseFilingController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditCaseFiling;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.param.CreditCaseFilingImportParam;
 import com.gxwebsoft.credit.param.CreditCaseFilingParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditCaseFilingService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 司法大数据控制器
@@ -40,6 +45,12 @@ public class CreditCaseFilingController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询司法大数据")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditCaseFiling>> page(CreditCaseFilingParam param) {
@@ -133,22 +144,68 @@ public class CreditCaseFilingController extends BaseController {
     }
 
     /**
-     * 批量导入司法大数据
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditCaseFiling:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Special: party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditCaseFilingService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditCaseFiling::getId,
+            CreditCaseFiling::setId,
+            CreditCaseFiling::getCompanyId,
+            CreditCaseFiling::setCompanyId,
+            CreditCaseFiling::getHasData,
+            CreditCaseFiling::setHasData,
+            CreditCaseFiling::getTenantId,
+            CreditCaseFiling::new,
+            CreditCaseFiling::getPlaintiffAppellant,
+            CreditCaseFiling::getAppellee,
+            CreditCaseFiling::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
+    /**
+     * 批量导入立案信息
      */
     @PreAuthorize("hasAuthority('credit:creditCaseFiling:save')")
-    @Operation(summary = "批量导入司法大数据")
+    @Operation(summary = "批量导入立案信息")
     @PostMapping("/import")
     public ApiResult<List<String>> importBatch(@RequestParam("file") MultipartFile file,
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "立案信息", 0);
+            ExcelImportSupport.ImportResult<CreditCaseFilingImportParam> importResult = ExcelImportSupport.read(
+                file, CreditCaseFilingImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditCaseFilingImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +214,8 @@ public class CreditCaseFilingController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            // easypoi 默认不会读取单元格超链接地址；url 通常挂在“案号”列的超链接中，需要额外读取回填。
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,9 +223,15 @@ public class CreditCaseFilingController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditCaseFilingImportParam param = list.get(i);
                 try {
                     CreditCaseFiling item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (link != null && !link.isEmpty()) {
+                            item.setUrl(link);
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -193,6 +258,10 @@ public class CreditCaseFilingController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +346,8 @@ public class CreditCaseFilingController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.CASE_FILING, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -289,28 +360,28 @@ public class CreditCaseFilingController extends BaseController {
     }
 
     /**
-     * 下载司法大数据导入模板
+     * 下载立案信息导入模板
      */
-    @Operation(summary = "下载司法大数据导入模板")
+    @Operation(summary = "下载立案信息导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditCaseFilingImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
-        example.setDataType("司法大数据");
+        CreditCaseFilingImportParam example = new CreditCaseFilingImportParam();
+        example.setDataType("立案信息");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
-        example.setOtherPartiesThirdParty("第三人示例");
-        example.setOccurrenceTime("2024-01-01");
+        example.setOtherPartiesThirdParty2("第三人示例");
+        example.setInvolvedAmount("100000");
+        example.setDataStatus("正常");
         example.setCaseNumber("（2024）示例案号");
         example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
+        example.setOccurrenceTime("2024-01-01");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("司法大数据导入模板", "司法大数据", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("立案信息导入模板", "立案信息", CreditCaseFilingImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_case_filing_import_template.xlsx");
@@ -319,29 +390,55 @@ public class CreditCaseFilingController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditCaseFilingImportParam param) {
         if (param == null) {
             return true;
         }
         return ImportHelper.isBlank(param.getCaseNumber())
             && ImportHelper.isBlank(param.getPlaintiffAppellant())
             && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+            && ImportHelper.isBlank(param.getCauseOfAction())
+            && ImportHelper.isBlank(param.getOtherPartiesThirdParty())
+            && ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
+            && ImportHelper.isBlank(param.getCourtName())
+            && ImportHelper.isBlank(param.getCourtName2())
+            && ImportHelper.isBlank(param.getOccurrenceTime())
+            && ImportHelper.isBlank(param.getOccurrenceTime2())
+            && ImportHelper.isBlank(param.getInvolvedAmount())
+            && ImportHelper.isBlank(param.getInvolvedAmount2())
+            && ImportHelper.isBlank(param.getDataStatus())
+            && ImportHelper.isBlank(param.getDataType())
+            && ImportHelper.isBlank(param.getComments());
     }
 
-    private CreditCaseFiling convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditCaseFiling convertImportParamToEntity(CreditCaseFilingImportParam param) {
         CreditCaseFiling entity = new CreditCaseFiling();
 
+        // Template compatibility: prefer new columns when present.
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime();
+        String otherPartiesThirdParty = !ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
+            ? param.getOtherPartiesThirdParty2()
+            : param.getOtherPartiesThirdParty();
+        String courtName = !ImportHelper.isBlank(param.getCourtName2())
+            ? param.getCourtName2()
+            : param.getCourtName();
+        String involvedAmount = !ImportHelper.isBlank(param.getInvolvedAmount2())
+            ? param.getInvolvedAmount2()
+            : param.getInvolvedAmount();
+
         entity.setDataType(param.getDataType());
         entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
         entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
+        entity.setDataStatus(param.getDataStatus());
+
         entity.setCaseNumber(param.getCaseNumber());
         entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
-        entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
+        entity.setOtherPartiesThirdParty(otherPartiesThirdParty);
+        entity.setCourtName(courtName);
+        entity.setOccurrenceTime(occurrenceTime);
+        entity.setInvolvedAmount(involvedAmount);
         entity.setComments(param.getComments());
 
         return entity;

src/main/java/com/gxwebsoft/credit/controller/CreditCompanyController.java

@@ -14,6 +14,7 @@ import com.gxwebsoft.credit.entity.CreditCompany;
 import com.gxwebsoft.credit.param.CreditCompanyImportParam;
 import com.gxwebsoft.credit.param.CreditCompanyParam;
 import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.apache.poi.ss.usermodel.Workbook;
@@ -26,8 +27,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 企业控制器
@@ -45,6 +48,9 @@ public class CreditCompanyController extends BaseController {
   @Resource
   private BatchImportSupport batchImportSupport;
 
+  @Resource
+  private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询企业")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditCompany>> page(CreditCompanyParam param) {
@@ -141,7 +147,9 @@ public class CreditCompanyController extends BaseController {
   public ApiResult<List<String>> importBatch(@RequestParam("file") MultipartFile file,
                                              @RequestParam(value = "companyId", required = false) Integer companyId) {
     List<String> errorMessages = new ArrayList<>();
-    int successCount = 0;
+    int insertedCount = 0;
+    Set<String> touchedMatchNames = new HashSet<>();
+    String refreshWarning = null;
 
     try {
       List<CreditCompanyImportParam> list = null;
@@ -214,37 +222,41 @@ public class CreditCompanyController extends BaseController {
 //            continue;
 //          }
 
+          touchedMatchNames.add(item.getMatchName().trim());
+
           chunkItems.add(item);
           chunkRowNumbers.add(excelRowNumber);
           if (chunkItems.size() >= chunkSize) {
-            successCount += batchImportSupport.persistChunkWithFallback(
+            insertedCount += batchImportSupport.persistChunkWithFallbackCount(
               chunkItems,
               chunkRowNumbers,
-              () -> batchImportSupport.upsertBySingleKey(
-                creditCompanyService,
-                chunkItems,
-                CreditCompany::getId,
-                CreditCompany::setId,
-                CreditCompany::getMatchName,
-                CreditCompany::getMatchName,
-                null,
-                mpBatchSize
-              ),
+              () -> {
+                int delta = countInsertedByMatchName(chunkItems);
+                batchImportSupport.upsertBySingleKey(
+                  creditCompanyService,
+                  chunkItems,
+                  CreditCompany::getId,
+                  CreditCompany::setId,
+                  CreditCompany::getMatchName,
+                  CreditCompany::getMatchName,
+                  null,
+                  mpBatchSize
+                );
+                return delta;
+              },
               (rowItem, rowNumber) -> {
                 boolean saved = creditCompanyService.save(rowItem);
-                if (!saved) {
-                  CreditCompany existing = creditCompanyService.getByMatchName(rowItem.getMatchName());
-                  if (existing != null) {
-                    rowItem.setId(existing.getId());
-                    if (creditCompanyService.updateById(rowItem)) {
-                      return true;
-                    }
-                  }
-                } else {
-                  return true;
+                if (saved) {
+                  return 1; // insert 入库
                 }
-                errorMessages.add("第" + rowNumber + "行：保存失败");
-                return false;
+                CreditCompany existing = creditCompanyService.getByMatchName(rowItem.getMatchName());
+                if (existing != null) {
+                  rowItem.setId(existing.getId());
+                  if (creditCompanyService.updateById(rowItem)) {
+                    return 0; // update 不计入“入库”条数
+                  }
+                }
+                throw new RuntimeException("保存失败");
               },
               errorMessages
             );
@@ -259,43 +271,85 @@ public class CreditCompanyController extends BaseController {
       }
 
       if (!chunkItems.isEmpty()) {
-        successCount += batchImportSupport.persistChunkWithFallback(
+        insertedCount += batchImportSupport.persistChunkWithFallbackCount(
           chunkItems,
           chunkRowNumbers,
-          () -> batchImportSupport.upsertBySingleKey(
-            creditCompanyService,
-            chunkItems,
-            CreditCompany::getId,
-            CreditCompany::setId,
-            CreditCompany::getMatchName,
-            CreditCompany::getMatchName,
-            null,
-            mpBatchSize
-          ),
+          () -> {
+            int delta = countInsertedByMatchName(chunkItems);
+            batchImportSupport.upsertBySingleKey(
+              creditCompanyService,
+              chunkItems,
+              CreditCompany::getId,
+              CreditCompany::setId,
+              CreditCompany::getMatchName,
+              CreditCompany::getMatchName,
+              null,
+              mpBatchSize
+            );
+            return delta;
+          },
           (rowItem, rowNumber) -> {
             boolean saved = creditCompanyService.save(rowItem);
-            if (!saved) {
-              CreditCompany existing = creditCompanyService.getByMatchName(rowItem.getMatchName());
-              if (existing != null) {
-                rowItem.setId(existing.getId());
-                if (creditCompanyService.updateById(rowItem)) {
-                  return true;
-                }
-              }
-            } else {
-              return true;
+            if (saved) {
+              return 1; // insert 入库
             }
-            errorMessages.add("第" + rowNumber + "行：保存失败");
-            return false;
+            CreditCompany existing = creditCompanyService.getByMatchName(rowItem.getMatchName());
+            if (existing != null) {
+              rowItem.setId(existing.getId());
+              if (creditCompanyService.updateById(rowItem)) {
+                return 0; // update 不计入“入库”条数
+              }
+            }
+            throw new RuntimeException("保存失败");
           },
           errorMessages
         );
       }
 
+      // 导入完成后，按 matchName 定位本次涉及的企业并回填“关联记录数”字段（避免 companyId/自增 id 在导入对象里拿不到）。
+      if (!touchedMatchNames.isEmpty()) {
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+        List<String> allMatchNames = new ArrayList<>(touchedMatchNames);
+        final int inChunkSize = 800;
+        for (int i = 0; i < allMatchNames.size(); i += inChunkSize) {
+          List<String> chunk = allMatchNames.subList(i, Math.min(allMatchNames.size(), i + inChunkSize));
+          List<CreditCompany> dbRows = creditCompanyService.lambdaQuery()
+            .select(CreditCompany::getId)
+            .in(CreditCompany::getMatchName, chunk)
+            .list();
+          if (!CollectionUtils.isEmpty(dbRows)) {
+            for (CreditCompany row : dbRows) {
+              if (row != null && row.getId() != null) {
+                touchedCompanyIds.add(row.getId());
+              }
+            }
+          }
+        }
+        try {
+          creditCompanyRecordCountService.refreshAll(touchedCompanyIds);
+        } catch (Exception ex) {
+          // 导入本身已经成功写入，回填计数字段失败不应导致整个导入失败（可后续单独重试刷新）。
+          String msg = ex.getMessage();
+          if (msg != null && msg.length() > 300) {
+            msg = msg.substring(0, 300) + "...";
+          }
+          refreshWarning = "关联记录数回填失败：" + (msg != null ? msg : ex.getClass().getSimpleName());
+          ex.printStackTrace();
+        }
+      }
+
       if (errorMessages.isEmpty()) {
-        return success("成功导入" + successCount + "条数据", null);
+        String msg = "成功入库" + insertedCount + "条数据";
+        if (refreshWarning != null) {
+          msg = msg + "；" + refreshWarning;
+        }
+        return success(msg, null);
       } else {
-        return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        String msg = "导入完成，入库" + insertedCount + "条，失败" + errorMessages.size() + "条";
+        if (refreshWarning != null) {
+          msg = msg + "；" + refreshWarning;
+        }
+        return success(msg, errorMessages);
       }
 
     } catch (Exception e) {
@@ -405,6 +459,53 @@ public class CreditCompanyController extends BaseController {
     return value == null || value.trim().isEmpty();
   }
 
+  /**
+   * 入库条数以 insert 为准：matchName 在数据库中不存在时计 1，否则计 0。
+   *
+   * <p>统计口径需与批量 upsert 的匹配字段保持一致（matchName）。</p>
+   */
+  private int countInsertedByMatchName(List<CreditCompany> items) {
+    if (CollectionUtils.isEmpty(items)) {
+      return 0;
+    }
+    List<String> matchNames = new ArrayList<>(items.size());
+    for (CreditCompany item : items) {
+      if (item == null) {
+        continue;
+      }
+      String key = item.getMatchName();
+      if (!isBlank(key)) {
+        matchNames.add(key.trim());
+      }
+    }
+    if (matchNames.isEmpty()) {
+      return 0;
+    }
+
+    Set<String> existing = new HashSet<>();
+    List<CreditCompany> dbRows = creditCompanyService.lambdaQuery()
+      .select(CreditCompany::getMatchName)
+      .in(CreditCompany::getMatchName, matchNames)
+      .list();
+    if (!CollectionUtils.isEmpty(dbRows)) {
+      for (CreditCompany row : dbRows) {
+        String v = row != null ? row.getMatchName() : null;
+        if (!isBlank(v)) {
+          existing.add(v.trim());
+        }
+      }
+    }
+
+    int count = 0;
+    for (CreditCompany item : items) {
+      String key = item != null ? item.getMatchName() : null;
+      if (!isBlank(key) && !existing.contains(key.trim())) {
+        count++;
+      }
+    }
+    return count;
+  }
+
   /**
    * 将CreditCompanyImportParam转换为CreditCompany实体
    */

src/main/java/com/gxwebsoft/credit/controller/CreditCompetitorController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditCompetitor;
 import com.gxwebsoft.credit.param.CreditCompetitorImportParam;
 import com.gxwebsoft.credit.param.CreditCompetitorParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditCompetitorService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 竞争对手控制器
@@ -40,6 +45,12 @@ public class CreditCompetitorController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询竞争对手")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditCompetitor>> page(CreditCompetitorParam param) {
@@ -132,6 +143,45 @@ public class CreditCompetitorController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditCompetitor:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditCompetitorService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditCompetitor::getId,
+            CreditCompetitor::setId,
+            CreditCompetitor::getName,
+            CreditCompetitor::getCompanyId,
+            CreditCompetitor::setCompanyId,
+            CreditCompetitor::getHasData,
+            CreditCompetitor::setHasData,
+            CreditCompetitor::getTenantId,
+            CreditCompetitor::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入竞争对手
      */
@@ -142,6 +192,7 @@ public class CreditCompetitorController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             int sheetIndex = ExcelImportSupport.findSheetIndex(file, "竞争对手", 2);
@@ -150,6 +201,7 @@ public class CreditCompetitorController extends BaseController {
             List<CreditCompetitorImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -158,6 +210,8 @@ public class CreditCompetitorController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByName = ExcelImportSupport.readUrlByKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, "企业名称");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -168,6 +222,13 @@ public class CreditCompetitorController extends BaseController {
                 CreditCompetitorImportParam param = list.get(i);
                 try {
                     CreditCompetitor item = convertImportParamToEntity(param);
+                    // name 才是持久化字段；companyName 为关联查询的临时字段（exist=false），导入时不应使用。
+                    if (!ImportHelper.isBlank(item.getName())) {
+                        String link = urlByName.get(item.getName().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -189,11 +250,15 @@ public class CreditCompetitorController extends BaseController {
                     }
 
                     int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
-                    if (ImportHelper.isBlank(item.getCompanyName())) {
+                    if (ImportHelper.isBlank(item.getName())) {
                         errorMessages.add("第" + excelRowNumber + "行：企业名称不能为空");
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -205,8 +270,8 @@ public class CreditCompetitorController extends BaseController {
                                 chunkItems,
                                 CreditCompetitor::getId,
                                 CreditCompetitor::setId,
-                                CreditCompetitor::getCompanyName,
-                                CreditCompetitor::getCompanyName,
+                                CreditCompetitor::getName,
+                                CreditCompetitor::getName,
                                 null,
                                 mpBatchSize
                             ),
@@ -214,7 +279,7 @@ public class CreditCompetitorController extends BaseController {
                                 boolean saved = creditCompetitorService.save(rowItem);
                                 if (!saved) {
                                     CreditCompetitor existing = creditCompetitorService.lambdaQuery()
-                                        .eq(CreditCompetitor::getCompanyName, rowItem.getCompanyName())
+                                        .eq(CreditCompetitor::getName, rowItem.getName())
                                         .one();
                                     if (existing != null) {
                                         rowItem.setId(existing.getId());
@@ -250,8 +315,8 @@ public class CreditCompetitorController extends BaseController {
                         chunkItems,
                         CreditCompetitor::getId,
                         CreditCompetitor::setId,
-                        CreditCompetitor::getCompanyName,
-                        CreditCompetitor::getCompanyName,
+                        CreditCompetitor::getName,
+                        CreditCompetitor::getName,
                         null,
                         mpBatchSize
                     ),
@@ -259,7 +324,7 @@ public class CreditCompetitorController extends BaseController {
                         boolean saved = creditCompetitorService.save(rowItem);
                         if (!saved) {
                             CreditCompetitor existing = creditCompetitorService.lambdaQuery()
-                                .eq(CreditCompetitor::getCompanyName, rowItem.getCompanyName())
+                                .eq(CreditCompetitor::getName, rowItem.getName())
                                 .one();
                             if (existing != null) {
                                 rowItem.setId(existing.getId());
@@ -278,6 +343,8 @@ public class CreditCompetitorController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.COMPETITOR, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -298,7 +365,7 @@ public class CreditCompetitorController extends BaseController {
         List<CreditCompetitorImportParam> templateList = new ArrayList<>();
 
         CreditCompetitorImportParam example = new CreditCompetitorImportParam();
-        example.setCompanyName("示例科技有限公司");
+        example.setName("示例科技有限公司");
         example.setLegalRepresentative("张三");
         example.setRegisteredCapital("5000");
         example.setEstablishmentDate("2015-01-01");
@@ -321,7 +388,7 @@ public class CreditCompetitorController extends BaseController {
         if (param == null) {
             return true;
         }
-        return ImportHelper.isBlank(param.getCompanyName())
+        return ImportHelper.isBlank(param.getName())
             && ImportHelper.isBlank(param.getLegalRepresentative())
             && ImportHelper.isBlank(param.getRegisteredCapital())
             && ImportHelper.isBlank(param.getEstablishmentDate());
@@ -330,7 +397,7 @@ public class CreditCompetitorController extends BaseController {
     private CreditCompetitor convertImportParamToEntity(CreditCompetitorImportParam param) {
         CreditCompetitor entity = new CreditCompetitor();
 
-        entity.setCompanyName(param.getCompanyName());
+        entity.setName(param.getName());
         entity.setLegalRepresentative(param.getLegalRepresentative());
         entity.setRegisteredCapital(param.getRegisteredCapital());
         entity.setEstablishmentDate(param.getEstablishmentDate());

src/main/java/com/gxwebsoft/credit/controller/CreditCourtAnnouncementController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditCourtAnnouncement;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.param.CreditCourtAnnouncementImportParam;
 import com.gxwebsoft.credit.param.CreditCourtAnnouncementParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditCourtAnnouncementService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 法院公告司法大数据控制器
@@ -40,6 +45,12 @@ public class CreditCourtAnnouncementController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询法院公告司法大数据")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditCourtAnnouncement>> page(CreditCourtAnnouncementParam param) {
@@ -132,6 +143,49 @@ public class CreditCourtAnnouncementController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditCourtAnnouncement:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditCourtAnnouncementService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditCourtAnnouncement::getId,
+            CreditCourtAnnouncement::setId,
+            CreditCourtAnnouncement::getCompanyId,
+            CreditCourtAnnouncement::setCompanyId,
+            CreditCourtAnnouncement::getHasData,
+            CreditCourtAnnouncement::setHasData,
+            CreditCourtAnnouncement::getTenantId,
+            CreditCourtAnnouncement::new,
+            CreditCourtAnnouncement::getPlaintiffAppellant,
+            CreditCourtAnnouncement::getAppellee,
+            CreditCourtAnnouncement::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入法院公告司法大数据
      */
@@ -142,13 +196,17 @@ public class CreditCourtAnnouncementController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            // 兼容多 sheet 文件：优先定位“法院公告”sheet，否则默认第 0 个。
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "法院公告", 0);
+            ExcelImportSupport.ImportResult<CreditCourtAnnouncementImportParam> importResult = ExcelImportSupport.read(
+                file, CreditCourtAnnouncementImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditCourtAnnouncementImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +215,7 @@ public class CreditCourtAnnouncementController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,9 +223,15 @@ public class CreditCourtAnnouncementController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditCourtAnnouncementImportParam param = list.get(i);
                 try {
                     CreditCourtAnnouncement item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -193,6 +258,10 @@ public class CreditCourtAnnouncementController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +346,8 @@ public class CreditCourtAnnouncementController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.COURT_ANNOUNCEMENT, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -294,9 +365,9 @@ public class CreditCourtAnnouncementController extends BaseController {
     @Operation(summary = "下载法院公告司法大数据导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditCourtAnnouncementImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
+        CreditCourtAnnouncementImportParam example = new CreditCourtAnnouncementImportParam();
         example.setDataType("法院公告");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
@@ -304,13 +375,13 @@ public class CreditCourtAnnouncementController extends BaseController {
         example.setOccurrenceTime("2024-01-01");
         example.setCaseNumber("（2024）示例案号");
         example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
+        example.setInvolvedAmount("100000");
+        example.setDataStatus("正常");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("法院公告导入模板", "法院公告", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("法院公告导入模板", "法院公告", CreditCourtAnnouncementImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_court_announcement_import_template.xlsx");
@@ -319,28 +390,43 @@ public class CreditCourtAnnouncementController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditCourtAnnouncementImportParam param) {
         if (param == null) {
             return true;
         }
         return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
             && ImportHelper.isBlank(param.getCauseOfAction());
     }
 
-    private CreditCourtAnnouncement convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditCourtAnnouncement convertImportParamToEntity(CreditCourtAnnouncementImportParam param) {
         CreditCourtAnnouncement entity = new CreditCourtAnnouncement();
 
-        entity.setDataType(param.getDataType());
-        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
+        String dataType = !ImportHelper.isBlank(param.getDataType2())
+            ? param.getDataType2()
+            : param.getDataType();
+        String plaintiffAppellant = !ImportHelper.isBlank(param.getPlaintiffAppellant2())
+            ? param.getPlaintiffAppellant2()
+            : param.getPlaintiffAppellant();
+        String otherPartiesThirdParty = !ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
+            ? param.getOtherPartiesThirdParty2()
+            : param.getOtherPartiesThirdParty();
+        String involvedAmount = !ImportHelper.isBlank(param.getInvolvedAmount2())
+            ? param.getInvolvedAmount2()
+            : param.getInvolvedAmount();
+
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime();
+
+        entity.setDataType(dataType);
+        entity.setPlaintiffAppellant(plaintiffAppellant);
         entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
+        entity.setOtherPartiesThirdParty(otherPartiesThirdParty);
+        entity.setOccurrenceTime(occurrenceTime);
         entity.setCaseNumber(param.getCaseNumber());
         entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
         entity.setCourtName(param.getCourtName());
+        entity.setInvolvedAmount(involvedAmount);
         entity.setDataStatus(param.getDataStatus());
         entity.setComments(param.getComments());
 

src/main/java/com/gxwebsoft/credit/controller/CreditCourtSessionController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditCourtSession;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.param.CreditCourtSessionImportParam;
 import com.gxwebsoft.credit.param.CreditCourtSessionParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditCourtSessionService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 开庭公告司法大数据控制器
@@ -40,6 +46,12 @@ public class CreditCourtSessionController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询开庭公告司法大数据")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditCourtSession>> page(CreditCourtSessionParam param) {
@@ -132,6 +144,49 @@ public class CreditCourtSessionController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditCourtSession:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditCourtSessionService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditCourtSession::getId,
+            CreditCourtSession::setId,
+            CreditCourtSession::getCompanyId,
+            CreditCourtSession::setCompanyId,
+            CreditCourtSession::getHasData,
+            CreditCourtSession::setHasData,
+            CreditCourtSession::getTenantId,
+            CreditCourtSession::new,
+            CreditCourtSession::getPlaintiffAppellant,
+            CreditCourtSession::getAppellee,
+            CreditCourtSession::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入开庭公告司法大数据
      */
@@ -142,13 +197,17 @@ public class CreditCourtSessionController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            // 兼容多 sheet 文件：优先定位“开庭公告”sheet，否则默认第 0 个。
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "开庭公告", 0);
+            ExcelImportSupport.ImportResult<CreditCourtSessionImportParam> importResult = ExcelImportSupport.read(
+                file, CreditCourtSessionImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditCourtSessionImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +216,7 @@ public class CreditCourtSessionController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,13 +224,22 @@ public class CreditCourtSessionController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditCourtSessionImportParam param = list.get(i);
                 try {
                     CreditCourtSession item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -193,6 +262,10 @@ public class CreditCourtSessionController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +350,8 @@ public class CreditCourtSessionController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.COURT_SESSION, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -288,29 +363,234 @@ public class CreditCourtSessionController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史开庭公告（仅解析“历史开庭公告”选项卡）
+     * 规则：案号相同则覆盖更新（recommend++ 记录更新次数）；案号不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditCourtSession:save')")
+    @Operation(summary = "批量导入历史开庭公告司法大数据")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史开庭公告");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史开庭公告”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditCourtSessionImportParam> importResult = ExcelImportSupport.read(
+                file, CreditCourtSessionImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditCourtSessionImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+
+            LinkedHashMap<String, CreditCourtSession> latestByCaseNumber = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditCourtSessionImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditCourtSession item = convertImportParamToEntity(param);
+                    if (item.getCaseNumber() != null) {
+                        item.setCaseNumber(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCaseNumber())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = urlByCaseNumber.get(item.getCaseNumber());
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    latestByCaseNumber.put(item.getCaseNumber(), item);
+                    latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCaseNumber.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditCourtSession> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditCourtSession> entry : latestByCaseNumber.entrySet()) {
+                String caseNumber = entry.getKey();
+                CreditCourtSession item = entry.getValue();
+                Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditCourtSessionService,
+                            chunkItems,
+                            CreditCourtSession::getId,
+                            CreditCourtSession::setId,
+                            CreditCourtSession::getCaseNumber,
+                            CreditCourtSession::getCaseNumber,
+                            CreditCourtSession::getRecommend,
+                            CreditCourtSession::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditCourtSessionService.save(rowItem);
+                            if (!saved) {
+                                CreditCourtSession existing = creditCourtSessionService.lambdaQuery()
+                                    .eq(CreditCourtSession::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditCourtSession::getId, CreditCourtSession::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditCourtSessionService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditCourtSessionService,
+                        chunkItems,
+                        CreditCourtSession::getId,
+                        CreditCourtSession::setId,
+                        CreditCourtSession::getCaseNumber,
+                        CreditCourtSession::getCaseNumber,
+                        CreditCourtSession::getRecommend,
+                        CreditCourtSession::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditCourtSessionService.save(rowItem);
+                        if (!saved) {
+                            CreditCourtSession existing = creditCourtSessionService.lambdaQuery()
+                                .eq(CreditCourtSession::getCaseNumber, rowItem.getCaseNumber())
+                                .select(CreditCourtSession::getId, CreditCourtSession::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditCourtSessionService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.COURT_SESSION, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载开庭公告司法大数据导入模板
      */
     @Operation(summary = "下载开庭公告司法大数据导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditCourtSessionImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
+        CreditCourtSessionImportParam example = new CreditCourtSessionImportParam();
         example.setDataType("开庭公告");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
-        example.setOtherPartiesThirdParty("第三人示例");
-        example.setOccurrenceTime("2024-01-01");
+        example.setOtherPartiesThirdParty2("第三人示例");
         example.setCaseNumber("（2024）示例案号");
         example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
+        example.setOccurrenceTime("2024-01-01");
+        example.setInvolvedAmount("100000");
+        example.setDataStatus("正常");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("开庭公告导入模板", "开庭公告", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("开庭公告导入模板", "开庭公告", CreditCourtSessionImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_court_session_import_template.xlsx");
@@ -319,29 +599,39 @@ public class CreditCourtSessionController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditCourtSessionImportParam param) {
         if (param == null) {
             return true;
         }
         return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
             && ImportHelper.isBlank(param.getCauseOfAction());
     }
 
-    private CreditCourtSession convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditCourtSession convertImportParamToEntity(CreditCourtSessionImportParam param) {
         CreditCourtSession entity = new CreditCourtSession();
 
+        // Template compatibility: prefer new columns ("发生时间"/"其他当事人/第三人") when present.
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime();
+        String otherPartiesThirdParty = !ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
+            ? param.getOtherPartiesThirdParty2()
+            : param.getOtherPartiesThirdParty();
+        String involvedAmount = !ImportHelper.isBlank(param.getInvolvedAmount2())
+            ? param.getInvolvedAmount2()
+            : param.getInvolvedAmount();
+
         entity.setDataType(param.getDataType());
         entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
         entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
+        entity.setDataStatus(param.getDataStatus());
+        entity.setInvolvedAmount(involvedAmount);
+
+        entity.setOtherPartiesThirdParty(otherPartiesThirdParty);
+        entity.setOccurrenceTime(occurrenceTime);
         entity.setCaseNumber(param.getCaseNumber());
         entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
         entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
         entity.setComments(param.getComments());
 
         return entity;

src/main/java/com/gxwebsoft/credit/controller/CreditCustomerController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditCustomer;
 import com.gxwebsoft.credit.param.CreditCustomerImportParam;
 import com.gxwebsoft.credit.param.CreditCustomerParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditCustomerService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,12 @@ import org.springframework.web.multipart.MultipartFile;
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 客户控制器
@@ -41,6 +47,12 @@ public class CreditCustomerController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询客户")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditCustomer>> page(CreditCustomerParam param) {
@@ -128,6 +140,45 @@ public class CreditCustomerController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditCustomer:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditCustomerService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditCustomer::getId,
+            CreditCustomer::setId,
+            CreditCustomer::getName,
+            CreditCustomer::getCompanyId,
+            CreditCustomer::setCompanyId,
+            CreditCustomer::getHasData,
+            CreditCustomer::setHasData,
+            CreditCustomer::getTenantId,
+            CreditCustomer::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入客户
      */
@@ -138,6 +189,7 @@ public class CreditCustomerController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             int sheetIndex = ExcelImportSupport.findSheetIndex(file, "客户", 4);
@@ -146,6 +198,7 @@ public class CreditCustomerController extends BaseController {
             List<CreditCustomerImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -154,6 +207,7 @@ public class CreditCustomerController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByName = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "客户");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -165,6 +219,13 @@ public class CreditCustomerController extends BaseController {
                 int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
                 try {
                     CreditCustomer item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getName())) {
+                        item.setName(item.getName().trim());
+                        String link = urlByName.get(item.getName());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -190,119 +251,14 @@ public class CreditCustomerController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
-                        successCount += batchImportSupport.persistChunkWithFallback(
-                            chunkItems,
-                            chunkRowNumbers,
-                            () -> {
-                                // 批内一次查库，避免逐行查/写导致数据库压力过大
-                                List<String> names = new ArrayList<>(chunkItems.size());
-                                for (CreditCustomer it : chunkItems) {
-                                    if (it != null && !ImportHelper.isBlank(it.getName())) {
-                                        names.add(it.getName().trim());
-                                    }
-                                }
-                                List<CreditCustomer> existingList = names.isEmpty()
-                                    ? new ArrayList<>()
-                                    : creditCustomerService.lambdaQuery()
-                                    .in(CreditCustomer::getName, names)
-                                    .list();
-                                java.util.Map<String, CreditCustomer> existingByName = new java.util.HashMap<>();
-                                for (CreditCustomer existing : existingList) {
-                                    if (existing != null && !ImportHelper.isBlank(existing.getName())) {
-                                        existingByName.putIfAbsent(existing.getName().trim(), existing);
-                                    }
-                                }
-
-                                java.util.Map<String, CreditCustomer> latestByName = new java.util.HashMap<>();
-                                int acceptedRows = 0;
-                                for (int idx = 0; idx < chunkItems.size(); idx++) {
-                                    CreditCustomer it = chunkItems.get(idx);
-                                    int rowNo = (idx < chunkRowNumbers.size()) ? chunkRowNumbers.get(idx) : -1;
-                                    if (it == null || ImportHelper.isBlank(it.getName())) {
-                                        continue;
-                                    }
-                                    String name = it.getName().trim();
-                                    CreditCustomer existing = existingByName.get(name);
-                                    if (existing != null) {
-                                        Integer existingTenantId = existing.getTenantId();
-                                        if (it.getTenantId() != null
-                                            && existingTenantId != null
-                                            && !it.getTenantId().equals(existingTenantId)) {
-                                            errorMessages.add("第" + rowNo + "行：客户名称已存在且归属其他租户，无法导入");
-                                            continue;
-                                        }
-                                        it.setId(existing.getId());
-                                        if (existingTenantId != null) {
-                                            it.setTenantId(existingTenantId);
-                                        }
-                                    }
-                                    // 同名多行：保留最后一行的值（等价于“先插入/更新，再被后续行更新”）
-                                    latestByName.put(name, it);
-                                    acceptedRows++;
-                                }
-
-                                List<CreditCustomer> updates = new ArrayList<>();
-                                List<CreditCustomer> inserts = new ArrayList<>();
-                                for (CreditCustomer it : latestByName.values()) {
-                                    if (it.getId() != null) {
-                                        updates.add(it);
-                                    } else {
-                                        inserts.add(it);
-                                    }
-                                }
-                                if (!updates.isEmpty()) {
-                                    creditCustomerService.updateBatchById(updates, mpBatchSize);
-                                }
-                                if (!inserts.isEmpty()) {
-                                    creditCustomerService.saveBatch(inserts, mpBatchSize);
-                                }
-                                return acceptedRows;
-                            },
-                            (rowItem, rowNumber) -> {
-                                CreditCustomer existing = creditCustomerService.lambdaQuery()
-                                    .eq(CreditCustomer::getName, rowItem.getName())
-                                    .one();
-                                if (existing != null) {
-                                    Integer existingTenantId = existing.getTenantId();
-                                    if (rowItem.getTenantId() != null
-                                        && existingTenantId != null
-                                        && !rowItem.getTenantId().equals(existingTenantId)) {
-                                        errorMessages.add("第" + rowNumber + "行：客户名称已存在且归属其他租户，无法导入");
-                                        return false;
-                                    }
-                                    rowItem.setId(existing.getId());
-                                    if (existingTenantId != null) {
-                                        rowItem.setTenantId(existingTenantId);
-                                    }
-                                    return creditCustomerService.updateById(rowItem);
-                                }
-
-                                try {
-                                    return creditCustomerService.save(rowItem);
-                                } catch (DataIntegrityViolationException e) {
-                                    if (!isDuplicateCustomerName(e)) {
-                                        throw e;
-                                    }
-                                    CreditCustomer dbExisting = creditCustomerService.lambdaQuery()
-                                        .eq(CreditCustomer::getName, rowItem.getName())
-                                        .one();
-                                    if (dbExisting != null) {
-                                        Integer existingTenantId = dbExisting.getTenantId();
-                                        rowItem.setId(dbExisting.getId());
-                                        if (existingTenantId != null) {
-                                            rowItem.setTenantId(existingTenantId);
-                                        }
-                                        return creditCustomerService.updateById(rowItem);
-                                    }
-                                }
-                                errorMessages.add("第" + rowNumber + "行：保存失败");
-                                return false;
-                            },
-                            errorMessages
-                        );
+                        successCount += persistImportChunk(chunkItems, chunkRowNumbers, mpBatchSize, errorMessages);
                         chunkItems.clear();
                         chunkRowNumbers.clear();
                     }
@@ -313,116 +269,11 @@ public class CreditCustomerController extends BaseController {
             }
 
             if (!chunkItems.isEmpty()) {
-                successCount += batchImportSupport.persistChunkWithFallback(
-                    chunkItems,
-                    chunkRowNumbers,
-                    () -> {
-                        List<String> names = new ArrayList<>(chunkItems.size());
-                        for (CreditCustomer it : chunkItems) {
-                            if (it != null && !ImportHelper.isBlank(it.getName())) {
-                                names.add(it.getName().trim());
-                            }
-                        }
-                        List<CreditCustomer> existingList = names.isEmpty()
-                            ? new ArrayList<>()
-                            : creditCustomerService.lambdaQuery()
-                            .in(CreditCustomer::getName, names)
-                            .list();
-                        java.util.Map<String, CreditCustomer> existingByName = new java.util.HashMap<>();
-                        for (CreditCustomer existing : existingList) {
-                            if (existing != null && !ImportHelper.isBlank(existing.getName())) {
-                                existingByName.putIfAbsent(existing.getName().trim(), existing);
-                            }
-                        }
-
-                        java.util.Map<String, CreditCustomer> latestByName = new java.util.HashMap<>();
-                        int acceptedRows = 0;
-                        for (int idx = 0; idx < chunkItems.size(); idx++) {
-                            CreditCustomer it = chunkItems.get(idx);
-                            int rowNo = (idx < chunkRowNumbers.size()) ? chunkRowNumbers.get(idx) : -1;
-                            if (it == null || ImportHelper.isBlank(it.getName())) {
-                                continue;
-                            }
-                            String name = it.getName().trim();
-                            CreditCustomer existing = existingByName.get(name);
-                            if (existing != null) {
-                                Integer existingTenantId = existing.getTenantId();
-                                if (it.getTenantId() != null
-                                    && existingTenantId != null
-                                    && !it.getTenantId().equals(existingTenantId)) {
-                                    errorMessages.add("第" + rowNo + "行：客户名称已存在且归属其他租户，无法导入");
-                                    continue;
-                                }
-                                it.setId(existing.getId());
-                                if (existingTenantId != null) {
-                                    it.setTenantId(existingTenantId);
-                                }
-                            }
-                            latestByName.put(name, it);
-                            acceptedRows++;
-                        }
-
-                        List<CreditCustomer> updates = new ArrayList<>();
-                        List<CreditCustomer> inserts = new ArrayList<>();
-                        for (CreditCustomer it : latestByName.values()) {
-                            if (it.getId() != null) {
-                                updates.add(it);
-                            } else {
-                                inserts.add(it);
-                            }
-                        }
-                        if (!updates.isEmpty()) {
-                            creditCustomerService.updateBatchById(updates, mpBatchSize);
-                        }
-                        if (!inserts.isEmpty()) {
-                            creditCustomerService.saveBatch(inserts, mpBatchSize);
-                        }
-                        return acceptedRows;
-                    },
-                    (rowItem, rowNumber) -> {
-                        CreditCustomer existing = creditCustomerService.lambdaQuery()
-                            .eq(CreditCustomer::getName, rowItem.getName())
-                            .one();
-                        if (existing != null) {
-                            Integer existingTenantId = existing.getTenantId();
-                            if (rowItem.getTenantId() != null
-                                && existingTenantId != null
-                                && !rowItem.getTenantId().equals(existingTenantId)) {
-                                errorMessages.add("第" + rowNumber + "行：客户名称已存在且归属其他租户，无法导入");
-                                return false;
-                            }
-                            rowItem.setId(existing.getId());
-                            if (existingTenantId != null) {
-                                rowItem.setTenantId(existingTenantId);
-                            }
-                            return creditCustomerService.updateById(rowItem);
-                        }
-
-                        try {
-                            return creditCustomerService.save(rowItem);
-                        } catch (DataIntegrityViolationException e) {
-                            if (!isDuplicateCustomerName(e)) {
-                                throw e;
-                            }
-                            CreditCustomer dbExisting = creditCustomerService.lambdaQuery()
-                                .eq(CreditCustomer::getName, rowItem.getName())
-                                .one();
-                            if (dbExisting != null) {
-                                Integer existingTenantId = dbExisting.getTenantId();
-                                rowItem.setId(dbExisting.getId());
-                                if (existingTenantId != null) {
-                                    rowItem.setTenantId(existingTenantId);
-                                }
-                                return creditCustomerService.updateById(rowItem);
-                            }
-                        }
-                        errorMessages.add("第" + rowNumber + "行：保存失败");
-                        return false;
-                    },
-                    errorMessages
-                );
+                successCount += persistImportChunk(chunkItems, chunkRowNumbers, mpBatchSize, errorMessages);
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.CUSTOMER, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -489,19 +340,71 @@ public class CreditCustomerController extends BaseController {
         return value.trim();
     }
 
-    private boolean isDuplicateCustomerName(DataIntegrityViolationException e) {
+    private int persistImportChunk(List<CreditCustomer> items,
+                                   List<Integer> excelRowNumbers,
+                                   int mpBatchSize,
+                                   List<String> errorMessages) {
+        return batchImportSupport.persistChunkWithFallback(
+            items,
+            excelRowNumbers,
+            () -> {
+                boolean ok = creditCustomerService.saveBatch(items, mpBatchSize);
+                if (!ok) {
+                    throw new RuntimeException("批量保存失败");
+                }
+                return items.size();
+            },
+            (rowItem, rowNumber) -> {
+                try {
+                    boolean saved = creditCustomerService.save(rowItem);
+                    if (saved) {
+                        return true;
+                    }
+                    if (rowNumber != null && rowNumber > 0) {
+                        errorMessages.add("第" + rowNumber + "行：保存失败");
+                    } else {
+                        errorMessages.add("保存失败");
+                    }
+                    return false;
+                } catch (DataIntegrityViolationException e) {
+                    if (isDuplicateKey(e)) {
+                        String name = rowItem != null ? rowItem.getName() : null;
+                        String label = ImportHelper.isBlank(name) ? "数据" : ("客户【" + name.trim() + "】");
+                        if (rowNumber != null && rowNumber > 0) {
+                            errorMessages.add("第" + rowNumber + "行：" + label + "重复（唯一索引冲突）");
+                        } else {
+                            errorMessages.add(label + "重复（唯一索引冲突）");
+                        }
+                        return false;
+                    }
+                    throw e;
+                }
+            },
+            errorMessages
+        );
+    }
+
+    private static boolean isDuplicateKey(DataIntegrityViolationException e) {
+        // Prefer structured detection (SQLState / vendor error code), fall back to message contains.
+        for (Throwable t = e; t != null; t = t.getCause()) {
+            if (t instanceof SQLException) {
+                SQLException se = (SQLException) t;
+                // MySQL: 1062 Duplicate entry; PostgreSQL/H2: SQLState 23505 unique_violation
+                if (se.getErrorCode() == 1062) {
+                    return true;
+                }
+                if ("23505".equals(se.getSQLState())) {
+                    return true;
+                }
+            }
+        }
         Throwable mostSpecificCause = e.getMostSpecificCause();
         String message = mostSpecificCause != null ? mostSpecificCause.getMessage() : e.getMessage();
         if (message == null) {
             return false;
         }
         String lower = message.toLowerCase();
-        if (!lower.contains("duplicate")) {
-            return false;
-        }
-        return lower.contains("credit_customer.name")
-            || lower.contains("for key 'name'")
-            || lower.contains("for key `name`");
+        return lower.contains("duplicate") && lower.contains("key");
     }
 
 }

src/main/java/com/gxwebsoft/credit/controller/CreditDeliveryNoticeController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditDeliveryNotice;
+import com.gxwebsoft.credit.param.CreditDeliveryNoticeImportParam;
 import com.gxwebsoft.credit.param.CreditDeliveryNoticeParam;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditDeliveryNoticeService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 送达公告司法大数据控制器
@@ -40,6 +45,12 @@ public class CreditDeliveryNoticeController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询送达公告司法大数据")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditDeliveryNotice>> page(CreditDeliveryNoticeParam param) {
@@ -132,6 +143,49 @@ public class CreditDeliveryNoticeController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditDeliveryNotice:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditDeliveryNoticeService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditDeliveryNotice::getId,
+            CreditDeliveryNotice::setId,
+            CreditDeliveryNotice::getCompanyId,
+            CreditDeliveryNotice::setCompanyId,
+            CreditDeliveryNotice::getHasData,
+            CreditDeliveryNotice::setHasData,
+            CreditDeliveryNotice::getTenantId,
+            CreditDeliveryNotice::new,
+            CreditDeliveryNotice::getPlaintiffAppellant,
+            CreditDeliveryNotice::getAppellee,
+            CreditDeliveryNotice::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入送达公告司法大数据
      */
@@ -142,13 +196,16 @@ public class CreditDeliveryNoticeController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "送达公告", 0);
+            ExcelImportSupport.ImportResult<CreditDeliveryNoticeImportParam> importResult = ExcelImportSupport.read(
+                file, CreditDeliveryNoticeImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditDeliveryNoticeImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +214,9 @@ public class CreditDeliveryNoticeController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            // URL 通常以超链接形式存在于“案号”列里
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,9 +224,15 @@ public class CreditDeliveryNoticeController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditDeliveryNoticeImportParam param = list.get(i);
                 try {
                     CreditDeliveryNotice item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (link != null && !link.isEmpty()) {
+                            item.setUrl(link);
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -193,6 +259,10 @@ public class CreditDeliveryNoticeController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +347,8 @@ public class CreditDeliveryNoticeController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.DELIVERY_NOTICE, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -294,23 +366,23 @@ public class CreditDeliveryNoticeController extends BaseController {
     @Operation(summary = "下载送达公告导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditDeliveryNoticeImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
+        CreditDeliveryNoticeImportParam example = new CreditDeliveryNoticeImportParam();
         example.setDataType("送达公告");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
-        example.setOtherPartiesThirdParty("第三人示例");
+        example.setOtherPartiesThirdParty2("第三人示例");
+        example.setInvolvedAmount("100000");
+        example.setDataStatus("正常");
         example.setOccurrenceTime("2024-01-01");
         example.setCaseNumber("（2024）示例案号");
         example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("送达公告导入模板", "送达公告", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("送达公告导入模板", "送达公告", CreditDeliveryNoticeImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_delivery_notice_import_template.xlsx");
@@ -319,29 +391,45 @@ public class CreditDeliveryNoticeController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditDeliveryNoticeImportParam param) {
         if (param == null) {
             return true;
         }
         return ImportHelper.isBlank(param.getCaseNumber())
+            && ImportHelper.isBlank(param.getCauseOfAction())
+            && ImportHelper.isBlank(param.getOtherPartiesThirdParty())
+            && ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
             && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+            && ImportHelper.isBlank(param.getAppellee());
     }
 
-    private CreditDeliveryNotice convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditDeliveryNotice convertImportParamToEntity(CreditDeliveryNoticeImportParam param) {
         CreditDeliveryNotice entity = new CreditDeliveryNotice();
 
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime();
+        String otherPartiesThirdParty = !ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
+            ? param.getOtherPartiesThirdParty2()
+            : param.getOtherPartiesThirdParty();
+        String courtName = !ImportHelper.isBlank(param.getCourtName2())
+            ? param.getCourtName2()
+            : param.getCourtName();
+        String involvedAmount = !ImportHelper.isBlank(param.getInvolvedAmount2())
+            ? param.getInvolvedAmount2()
+            : param.getInvolvedAmount();
+
         entity.setDataType(param.getDataType());
         entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
         entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
+        entity.setInvolvedAmount(involvedAmount);
+        entity.setDataStatus(param.getDataStatus());
+
+        entity.setOtherPartiesThirdParty(otherPartiesThirdParty);
+        entity.setOccurrenceTime(occurrenceTime);
         entity.setCaseNumber(param.getCaseNumber());
         entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
-        entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
+        entity.setCourtName(courtName);
         entity.setComments(param.getComments());
 
         return entity;

src/main/java/com/gxwebsoft/credit/controller/CreditExternalController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditExternal;
 import com.gxwebsoft.credit.param.CreditExternalImportParam;
 import com.gxwebsoft.credit.param.CreditExternalParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditExternalService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 对外投资控制器
@@ -40,6 +45,12 @@ public class CreditExternalController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询对外投资")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditExternal>> page(CreditExternalParam param) {
@@ -132,6 +143,45 @@ public class CreditExternalController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditExternal:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditExternalService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditExternal::getId,
+            CreditExternal::setId,
+            CreditExternal::getName,
+            CreditExternal::getCompanyId,
+            CreditExternal::setCompanyId,
+            CreditExternal::getHasData,
+            CreditExternal::setHasData,
+            CreditExternal::getTenantId,
+            CreditExternal::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入对外投资
      */
@@ -142,6 +192,7 @@ public class CreditExternalController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             int sheetIndex = ExcelImportSupport.findSheetIndex(file, "对外投资", 0);
@@ -150,6 +201,7 @@ public class CreditExternalController extends BaseController {
             List<CreditExternalImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -158,6 +210,7 @@ public class CreditExternalController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByName = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "被投资企业名称");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -168,6 +221,12 @@ public class CreditExternalController extends BaseController {
                 CreditExternalImportParam param = list.get(i);
                 try {
                     CreditExternal item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getName())) {
+                        String link = urlByName.get(item.getName().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -194,6 +253,10 @@ public class CreditExternalController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -278,6 +341,8 @@ public class CreditExternalController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.EXTERNAL, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditFinalVersionController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditFinalVersion;
+import com.gxwebsoft.credit.param.CreditFinalVersionImportParam;
 import com.gxwebsoft.credit.param.CreditFinalVersionParam;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditFinalVersionService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 终本案件控制器
@@ -40,6 +46,12 @@ public class CreditFinalVersionController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询终本案件")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditFinalVersion>> page(CreditFinalVersionParam param) {
@@ -132,6 +144,49 @@ public class CreditFinalVersionController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditFinalVersion:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditFinalVersionService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditFinalVersion::getId,
+            CreditFinalVersion::setId,
+            CreditFinalVersion::getCompanyId,
+            CreditFinalVersion::setCompanyId,
+            CreditFinalVersion::getHasData,
+            CreditFinalVersion::setHasData,
+            CreditFinalVersion::getTenantId,
+            CreditFinalVersion::new,
+            CreditFinalVersion::getPlaintiffAppellant,
+            CreditFinalVersion::getAppellee,
+            CreditFinalVersion::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入终本案件
      */
@@ -142,13 +197,17 @@ public class CreditFinalVersionController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            // 按选项卡名称读取（客户提供的文件可能不是把目标 sheet 放在第一个）
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "终本案件", 0);
+            ExcelImportSupport.ImportResult<CreditFinalVersionImportParam> importResult = ExcelImportSupport.read(
+                file, CreditFinalVersionImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditFinalVersionImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +216,7 @@ public class CreditFinalVersionController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,13 +224,22 @@ public class CreditFinalVersionController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditFinalVersionImportParam param = list.get(i);
                 try {
                     CreditFinalVersion item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -193,6 +262,10 @@ public class CreditFinalVersionController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +350,8 @@ public class CreditFinalVersionController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.FINAL_VERSION, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -288,29 +363,233 @@ public class CreditFinalVersionController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史终本案件（仅解析“历史终本案件”选项卡）
+     * 规则：案号相同则覆盖更新（recommend++ 记录更新次数）；案号不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditFinalVersion:save')")
+    @Operation(summary = "批量导入历史终本案件")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史终本案件");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史终本案件”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditFinalVersionImportParam> importResult = ExcelImportSupport.read(
+                file, CreditFinalVersionImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditFinalVersionImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+
+            LinkedHashMap<String, CreditFinalVersion> latestByCaseNumber = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditFinalVersionImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditFinalVersion item = convertImportParamToEntity(param);
+                    if (item.getCaseNumber() != null) {
+                        item.setCaseNumber(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCaseNumber())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = urlByCaseNumber.get(item.getCaseNumber());
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    latestByCaseNumber.put(item.getCaseNumber(), item);
+                    latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCaseNumber.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditFinalVersion> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditFinalVersion> entry : latestByCaseNumber.entrySet()) {
+                String caseNumber = entry.getKey();
+                CreditFinalVersion item = entry.getValue();
+                Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditFinalVersionService,
+                            chunkItems,
+                            CreditFinalVersion::getId,
+                            CreditFinalVersion::setId,
+                            CreditFinalVersion::getCaseNumber,
+                            CreditFinalVersion::getCaseNumber,
+                            CreditFinalVersion::getRecommend,
+                            CreditFinalVersion::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditFinalVersionService.save(rowItem);
+                            if (!saved) {
+                                CreditFinalVersion existing = creditFinalVersionService.lambdaQuery()
+                                    .eq(CreditFinalVersion::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditFinalVersion::getId, CreditFinalVersion::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditFinalVersionService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditFinalVersionService,
+                        chunkItems,
+                        CreditFinalVersion::getId,
+                        CreditFinalVersion::setId,
+                        CreditFinalVersion::getCaseNumber,
+                        CreditFinalVersion::getCaseNumber,
+                        CreditFinalVersion::getRecommend,
+                        CreditFinalVersion::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditFinalVersionService.save(rowItem);
+                        if (!saved) {
+                            CreditFinalVersion existing = creditFinalVersionService.lambdaQuery()
+                                .eq(CreditFinalVersion::getCaseNumber, rowItem.getCaseNumber())
+                                .select(CreditFinalVersion::getId, CreditFinalVersion::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditFinalVersionService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.FINAL_VERSION, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载终本案件导入模板
      */
     @Operation(summary = "下载终本案件导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditFinalVersionImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
-        example.setDataType("终本案件");
+        CreditFinalVersionImportParam example = new CreditFinalVersionImportParam();
+        example.setCaseNumber("（2024）示例案号");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
         example.setOtherPartiesThirdParty("第三人示例");
-        example.setOccurrenceTime("2024-01-01");
-        example.setCaseNumber("（2024）示例案号");
-        example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
+        example.setInvolvedAmount("20,293.91");
+        example.setDataStatus("正常");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
+        example.setOccurrenceTime("2024-01-01");
+        example.setFinalDate("2024-01-01");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("终本案件导入模板", "终本案件", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("终本案件导入模板", "终本案件", CreditFinalVersionImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_final_version_import_template.xlsx");
@@ -319,29 +598,45 @@ public class CreditFinalVersionController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditFinalVersionImportParam param) {
         if (param == null) {
             return true;
         }
-        return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+        return ImportHelper.isBlank(param.getCaseNumber());
     }
 
-    private CreditFinalVersion convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditFinalVersion convertImportParamToEntity(CreditFinalVersionImportParam param) {
         CreditFinalVersion entity = new CreditFinalVersion();
 
-        entity.setDataType(param.getDataType());
-        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
-        entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
+        String plaintiffAppellant = !ImportHelper.isBlank(param.getPlaintiffAppellant2())
+            ? param.getPlaintiffAppellant2()
+            : param.getPlaintiffAppellant();
+        String appellee = !ImportHelper.isBlank(param.getAppellee2())
+            ? param.getAppellee2()
+            : param.getAppellee();
+        String otherPartiesThirdParty = !ImportHelper.isBlank(param.getOtherPartiesThirdParty())
+            ? param.getOtherPartiesThirdParty()
+            : param.getOtherPartiesThirdParty2();
+        String involvedAmount = !ImportHelper.isBlank(param.getInvolvedAmount2())
+            ? param.getInvolvedAmount2()
+            : param.getInvolvedAmount();
+        String courtName = !ImportHelper.isBlank(param.getCourtName2())
+            ? param.getCourtName2()
+            : param.getCourtName();
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime();
+
         entity.setCaseNumber(param.getCaseNumber());
-        entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
-        entity.setCourtName(param.getCourtName());
+        entity.setPlaintiffAppellant(plaintiffAppellant);
+        entity.setAppellee(appellee);
+        entity.setUnfulfilledAmount(param.getUnfulfilledAmount());
+        entity.setInvolvedAmount(involvedAmount);
+        entity.setOtherPartiesThirdParty(otherPartiesThirdParty);
         entity.setDataStatus(param.getDataStatus());
+        entity.setCourtName(courtName);
+        entity.setOccurrenceTime(occurrenceTime);
+        entity.setFinalDate(param.getFinalDate());
         entity.setComments(param.getComments());
 
         return entity;

src/main/java/com/gxwebsoft/credit/controller/CreditGqdjController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditGqdj;
+import com.gxwebsoft.credit.param.CreditGqdjImportParam;
 import com.gxwebsoft.credit.param.CreditGqdjParam;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditGqdjService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 股权冻结控制器
@@ -40,6 +46,12 @@ public class CreditGqdjController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询股权冻结")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditGqdj>> page(CreditGqdjParam param) {
@@ -132,6 +144,47 @@ public class CreditGqdjController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据当事人/企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId 为空/0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditGqdj:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Match companyId by any party/company-name column (e.g. plaintiff/appellant, defendant/appellee).
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNames(
+            creditGqdjService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditGqdj::getId,
+            CreditGqdj::setId,
+            CreditGqdj::getCompanyId,
+            CreditGqdj::setCompanyId,
+            CreditGqdj::getHasData,
+            CreditGqdj::setHasData,
+            CreditGqdj::getTenantId,
+            CreditGqdj::new,
+            CreditGqdj::getPlaintiffAppellant,
+            CreditGqdj::getAppellee
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入股权冻结司法大数据
      */
@@ -142,13 +195,42 @@ public class CreditGqdjController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "股权冻结", 0);
+            // Prefer the "best" header configuration; many upstream files have extra title rows or multi-row headers.
+            ExcelImportSupport.ImportResult<CreditGqdjImportParam> importResult = ExcelImportSupport.readBest(
+                file,
+                CreditGqdjImportParam.class,
+                this::isEmptyImportRow,
+                // Score rows that look like real data (at least has a case number in either column).
+                p -> p != null
+                    && (!ImportHelper.isBlank(p.getCaseNumber())
+                    || !ImportHelper.isBlank(p.getCaseNumber2())
+                ),
+                sheetIndex
+            );
+            List<CreditGqdjImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                // Fallback: try other sheets if the named/default sheet doesn't match.
+                importResult = ExcelImportSupport.readAnySheetBest(
+                    file,
+                    CreditGqdjImportParam.class,
+                    this::isEmptyImportRow,
+                    p -> p != null
+                        && (!ImportHelper.isBlank(p.getCaseNumber())
+                        || !ImportHelper.isBlank(p.getCaseNumber2()))
+                );
+                list = importResult.getData();
+                usedTitleRows = importResult.getTitleRows();
+                usedHeadRows = importResult.getHeadRows();
+                usedSheetIndex = importResult.getSheetIndex();
+            }
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +239,67 @@ public class CreditGqdjController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            // easypoi 默认不会读取单元格超链接地址；url 通常挂在“案号/执行通知文书号”列的超链接中，需要额外读取回填。
+            String caseNumberHeader = "执行通知文书号";
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader);
+            // Some upstream sources use "案号" as the case number header.
+            Map<String, String> urlByCaseNumberFromAh = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+            urlByCaseNumberFromAh.forEach(urlByCaseNumber::putIfAbsent);
+            // Some upstream sources use "暗号" as the case number header.
+            Map<String, String> urlByCaseNumberFromAh2 = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号");
+            urlByCaseNumberFromAh2.forEach(urlByCaseNumber::putIfAbsent);
+            // 有些源文件会单独提供“url/网址/链接”等列（可能是纯文本也可能是超链接）
+            Map<String, String> urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "url");
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "URL");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "网址");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "链接");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                // Try again with "案号" as the key column name.
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "url");
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "URL");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "网址");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "链接");
+                }
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                // Try again with "暗号" as the key column name.
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "url");
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "URL");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "网址");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "链接");
+                }
+            }
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,13 +307,26 @@ public class CreditGqdjController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditGqdjImportParam param = list.get(i);
                 try {
                     CreditGqdj item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String key = item.getCaseNumber().trim();
+                        String link = urlByCaseNumber.get(key);
+                        if (ImportHelper.isBlank(link)) {
+                            link = urlByCaseNumberFromUrlCol.get(key);
+                        }
+                        if (link != null && !link.isEmpty()) {
+                            item.setUrl(link);
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -193,6 +349,10 @@ public class CreditGqdjController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +437,8 @@ public class CreditGqdjController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.GQDJ, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -288,29 +450,296 @@ public class CreditGqdjController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史股权冻结（仅解析“历史股权冻结”选项卡）
+     * 规则：执行通知文书号/案号相同则覆盖更新（recommend++ 记录更新次数）；不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditGqdj:save')")
+    @Operation(summary = "批量导入历史股权冻结司法大数据")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史股权冻结");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史股权冻结”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditGqdjImportParam> importResult = ExcelImportSupport.readBest(
+                file,
+                CreditGqdjImportParam.class,
+                this::isEmptyImportRow,
+                p -> p != null
+                    && (!ImportHelper.isBlank(p.getCaseNumber())
+                    || !ImportHelper.isBlank(p.getCaseNumber2())),
+                sheetIndex
+            );
+            List<CreditGqdjImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+            String caseNumberHeader = "执行通知文书号";
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader);
+            Map<String, String> urlByCaseNumberFromAh = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+            urlByCaseNumberFromAh.forEach(urlByCaseNumber::putIfAbsent);
+            Map<String, String> urlByCaseNumberFromAh2 = ExcelImportSupport.readHyperlinksByHeaderKey(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号");
+            urlByCaseNumberFromAh2.forEach(urlByCaseNumber::putIfAbsent);
+            Map<String, String> urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "url");
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "URL");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "网址");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, caseNumberHeader, "链接");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "url");
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "URL");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "网址");
+                }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号", "链接");
+            }
+            if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                    file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "url");
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "URL");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "网址");
+                }
+                if (urlByCaseNumberFromUrlCol.isEmpty()) {
+                    urlByCaseNumberFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(
+                        file, usedSheetIndex, usedTitleRows, usedHeadRows, "暗号", "链接");
+                }
+            }
+            }
+
+            LinkedHashMap<String, CreditGqdj> latestByCaseNumber = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditGqdjImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditGqdj item = convertImportParamToEntity(param);
+                    if (item.getCaseNumber() != null) {
+                        item.setCaseNumber(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCaseNumber())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String key = item.getCaseNumber();
+                    String link = urlByCaseNumber.get(key);
+                    if (ImportHelper.isBlank(link)) {
+                        link = urlByCaseNumberFromUrlCol.get(key);
+                    }
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    latestByCaseNumber.put(item.getCaseNumber(), item);
+                    latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCaseNumber.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditGqdj> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditGqdj> entry : latestByCaseNumber.entrySet()) {
+                String caseNumber = entry.getKey();
+                CreditGqdj item = entry.getValue();
+                Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditGqdjService,
+                            chunkItems,
+                            CreditGqdj::getId,
+                            CreditGqdj::setId,
+                            CreditGqdj::getCaseNumber,
+                            CreditGqdj::getCaseNumber,
+                            CreditGqdj::getRecommend,
+                            CreditGqdj::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditGqdjService.save(rowItem);
+                            if (!saved) {
+                                CreditGqdj existing = creditGqdjService.lambdaQuery()
+                                    .eq(CreditGqdj::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditGqdj::getId, CreditGqdj::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditGqdjService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditGqdjService,
+                        chunkItems,
+                        CreditGqdj::getId,
+                        CreditGqdj::setId,
+                        CreditGqdj::getCaseNumber,
+                        CreditGqdj::getCaseNumber,
+                        CreditGqdj::getRecommend,
+                        CreditGqdj::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditGqdjService.save(rowItem);
+                        if (!saved) {
+                            CreditGqdj existing = creditGqdjService.lambdaQuery()
+                                .eq(CreditGqdj::getCaseNumber, rowItem.getCaseNumber())
+                                .select(CreditGqdj::getId, CreditGqdj::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditGqdjService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.GQDJ, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载股权冻结导入模板
      */
     @Operation(summary = "下载股权冻结导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditGqdjImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
+        CreditGqdjImportParam example = new CreditGqdjImportParam();
         example.setDataType("股权冻结");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
-        example.setOtherPartiesThirdParty("第三人示例");
-        example.setOccurrenceTime("2024-01-01");
         example.setCaseNumber("（2024）示例案号");
-        example.setCauseOfAction("案由示例");
         example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
         example.setDataStatus("已公开");
-        example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("股权冻结导入模板", "股权冻结", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("股权冻结导入模板", "股权冻结", CreditGqdjImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_gqdj_import_template.xlsx");
@@ -319,30 +748,65 @@ public class CreditGqdjController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditGqdjImportParam param) {
         if (param == null) {
             return true;
         }
+        // Don't over-filter here: if some columns are mapped but case number header differs,
+        // we still want to read the row and report "案号不能为空" instead of "未读取到数据".
         return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
+            && ImportHelper.isBlank(param.getCaseNumber2())
             && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+            && ImportHelper.isBlank(param.getAppellee2())
+            && ImportHelper.isBlank(param.getPlaintiffAppellant())
+            && ImportHelper.isBlank(param.getPlaintiffAppellant2())
+            && ImportHelper.isBlank(param.getInvolvedAmount())
+            && ImportHelper.isBlank(param.getCourtName())
+            && ImportHelper.isBlank(param.getDataType())
+            && ImportHelper.isBlank(param.getDataStatus())
+            && ImportHelper.isBlank(param.getDataStatus2())
+            && ImportHelper.isBlank(param.getFreezeDateStart())
+            && ImportHelper.isBlank(param.getFreezeDateEnd())
+            && ImportHelper.isBlank(param.getFreezeDateStart2())
+            && ImportHelper.isBlank(param.getFreezeDateEnd2())
+            && ImportHelper.isBlank(param.getPublicDate());
     }
 
-    private CreditGqdj convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditGqdj convertImportParamToEntity(CreditGqdjImportParam param) {
         CreditGqdj entity = new CreditGqdj();
 
-        entity.setDataType(param.getDataType());
-        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
-        entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
-        entity.setCaseNumber(param.getCaseNumber());
-        entity.setCauseOfAction(param.getCauseOfAction());
+        // Template compatibility: some sources use alternate headers for the same columns.
+        String appellee = !ImportHelper.isBlank(param.getAppellee()) ? param.getAppellee() : param.getAppellee2();
+        String plaintiffAppellant = !ImportHelper.isBlank(param.getPlaintiffAppellant())
+            ? param.getPlaintiffAppellant()
+            : param.getPlaintiffAppellant2();
+
+        if (!ImportHelper.isBlank(param.getCaseNumber2())) {
+            entity.setCaseNumber(param.getCaseNumber2());
+        } else {
+            entity.setCaseNumber(param.getCaseNumber());
+        }
+        entity.setAppellee(appellee);
+        entity.setPlaintiffAppellant(plaintiffAppellant);
         entity.setInvolvedAmount(param.getInvolvedAmount());
         entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
-        entity.setComments(param.getComments());
+        if (!ImportHelper.isBlank(param.getDataStatus2())) {
+            entity.setDataStatus(param.getDataStatus2());
+        } else {
+            entity.setDataStatus(param.getDataStatus());
+        }
+        entity.setDataType("股权冻结");
+        entity.setPublicDate(param.getPublicDate());
+        if (!ImportHelper.isBlank(param.getFreezeDateStart2())) {
+            entity.setFreezeDateStart(param.getFreezeDateStart2());
+        } else {
+            entity.setFreezeDateStart(param.getFreezeDateStart());
+        }
+        if (!ImportHelper.isBlank(param.getFreezeDateEnd2())) {
+            entity.setFreezeDateEnd(param.getFreezeDateEnd2());
+        } else {
+            entity.setFreezeDateEnd(param.getFreezeDateEnd());
+        }
 
         return entity;
     }

src/main/java/com/gxwebsoft/credit/controller/CreditHistoricalLegalPersonController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditHistoricalLegalPerson;
 import com.gxwebsoft.credit.param.CreditHistoricalLegalPersonImportParam;
 import com.gxwebsoft.credit.param.CreditHistoricalLegalPersonParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditHistoricalLegalPersonService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 历史法定代表人控制器
@@ -41,6 +45,12 @@ public class CreditHistoricalLegalPersonController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询历史法定代表人")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditHistoricalLegalPerson>> page(CreditHistoricalLegalPersonParam param) {
@@ -133,6 +143,45 @@ public class CreditHistoricalLegalPersonController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditHistoricalLegalPerson:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditHistoricalLegalPersonService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditHistoricalLegalPerson::getId,
+            CreditHistoricalLegalPerson::setId,
+            CreditHistoricalLegalPerson::getName,
+            CreditHistoricalLegalPerson::getCompanyId,
+            CreditHistoricalLegalPerson::setCompanyId,
+            CreditHistoricalLegalPerson::getHasData,
+            CreditHistoricalLegalPerson::setHasData,
+            CreditHistoricalLegalPerson::getTenantId,
+            CreditHistoricalLegalPerson::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入历史法定代表人
      */
@@ -143,6 +192,7 @@ public class CreditHistoricalLegalPersonController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditHistoricalLegalPersonImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -202,6 +252,10 @@ public class CreditHistoricalLegalPersonController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -381,6 +435,8 @@ public class CreditHistoricalLegalPersonController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.HISTORICAL_LEGAL_PERSON, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditJudgmentDebtorController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditJudgmentDebtor;
 import com.gxwebsoft.credit.param.CreditJudgmentDebtorImportParam;
 import com.gxwebsoft.credit.param.CreditJudgmentDebtorParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditJudgmentDebtorService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -29,8 +31,11 @@ import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.Locale;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
@@ -50,6 +55,12 @@ public class CreditJudgmentDebtorController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询被执行人")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditJudgmentDebtor>> page(CreditJudgmentDebtorParam param) {
@@ -142,6 +153,56 @@ public class CreditJudgmentDebtorController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtor:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit,
+        @RequestParam(value = "topLevelOnly", required = false, defaultValue = "true") Boolean topLevelOnly
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Match only on "name" column: debtor.name contains a (top-level) CreditCompany name/matchName.
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditJudgmentDebtorService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditJudgmentDebtor::getId,
+            CreditJudgmentDebtor::setId,
+            CreditJudgmentDebtor::getCompanyId,
+            CreditJudgmentDebtor::setCompanyId,
+            CreditJudgmentDebtor::getHasData,
+            CreditJudgmentDebtor::setHasData,
+            CreditJudgmentDebtor::getTenantId,
+            CreditJudgmentDebtor::new,
+            q -> {
+                if (!Boolean.TRUE.equals(topLevelOnly)) {
+                    return;
+                }
+                // "一级企业"：parentId=0（部分历史数据可能为 NULL，兼容处理）
+                q.and(w -> w.eq(com.gxwebsoft.credit.entity.CreditCompany::getParentId, 0)
+                    .or()
+                    .isNull(com.gxwebsoft.credit.entity.CreditCompany::getParentId));
+            },
+            CreditJudgmentDebtor::getName
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入被执行人
      */
@@ -165,6 +226,46 @@ public class CreditJudgmentDebtorController extends BaseController {
             if (!outcome.anyDataRead) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
             }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.JUDGMENT_DEBTOR, outcome.touchedCompanyIds);
+
+            if (outcome.errorMessages.isEmpty()) {
+                return success("成功导入" + outcome.successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + outcome.successCount + "条，失败" + outcome.errorMessages.size() + "条", outcome.errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
+    /**
+     * 批量导入历史被执行人（写入被执行人表 credit_judgment_debtor，仅解析“历史被执行人”选项卡）
+     * 规则：案号相同则更新；案号不存在则插入；导入文件内案号重复时取最后一条覆盖。
+     */
+    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtor:save')")
+    @Operation(summary = "批量导入历史被执行人")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        try {
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+            ImportOutcome outcome;
+            if (isZip(file)) {
+                outcome = importHistoryFromZip(file, currentUserId, currentTenantId, companyId);
+            } else {
+                outcome = importHistoryFromExcel(file, safeFileLabel(file.getOriginalFilename()), currentUserId, currentTenantId, companyId);
+            }
+
+            if (!outcome.anyDataRead) {
+                return fail("未读取到数据，请确认文件中存在“历史被执行人”选项卡且表头与示例格式一致", null);
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.JUDGMENT_DEBTOR, outcome.touchedCompanyIds);
+
             if (outcome.errorMessages.isEmpty()) {
                 return success("成功导入" + outcome.successCount + "条数据", null);
             }
@@ -188,7 +289,6 @@ public class CreditJudgmentDebtorController extends BaseController {
         example.setName("某某公司");
         example.setCode("1234567890");
         example.setOccurrenceTime("2024-01-10");
-        example.setAmount("100000");
         example.setDataStatus("已公开");
         example.setComments("备注信息");
         templateList.add(example);
@@ -209,10 +309,7 @@ public class CreditJudgmentDebtorController extends BaseController {
         if (isImportHeaderRow(param)) {
             return true;
         }
-        return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getName())
-            && ImportHelper.isBlank(param.getName1())
-            && ImportHelper.isBlank(param.getCode());
+        return ImportHelper.isBlank(param.getCaseNumber());
     }
 
     private boolean isImportHeaderRow(CreditJudgmentDebtorImportParam param) {
@@ -224,7 +321,9 @@ public class CreditJudgmentDebtorController extends BaseController {
             || isHeaderValue(param.getCode(), "证件号/组织机构代码")
             || isHeaderValue(param.getOccurrenceTime(), "立案日期")
             || isHeaderValue(param.getCourtName(), "法院")
-            || isHeaderValue(param.getAmount(), "执行标的(元)")
+            || isHeaderValue(param.getCourtNameQcc(), "执行法院")
+            || isHeaderValue(param.getInvolvedAmount(), "涉案金额")
+            || isHeaderValue(param.getInvolvedAmountQcc(), "执行标的(元)")
             || isHeaderValue(param.getDataStatus(), "数据状态");
     }
 
@@ -235,17 +334,56 @@ public class CreditJudgmentDebtorController extends BaseController {
         return headerText.equals(value.trim());
     }
 
+    private static boolean hasMeaningfulPartyValue(String value) {
+        if (ImportHelper.isBlank(value)) {
+            return false;
+        }
+        return !"-".equals(value.trim());
+    }
+
     private CreditJudgmentDebtor convertImportParamToEntity(CreditJudgmentDebtorImportParam param) {
         CreditJudgmentDebtor entity = new CreditJudgmentDebtor();
 
         entity.setCaseNumber(param.getCaseNumber());
         entity.setName1(param.getName1());
         String debtorName = ImportHelper.isBlank(param.getName()) ? param.getName1() : param.getName();
+        if (debtorName != null) {
+            debtorName = debtorName.trim();
+        }
+        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
+        entity.setAppellee(param.getAppellee());
+        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
+        // Some upstream XLS templates store party/company name in "原告/上诉人/被告/第三人" columns.
+        // When present, use them to populate the debtor "name" for compatibility.
+        if (hasMeaningfulPartyValue(param.getPlaintiffAppellant())) {
+            debtorName = param.getPlaintiffAppellant().trim();
+        } else if (hasMeaningfulPartyValue(param.getAppellee())) {
+            debtorName = param.getAppellee().trim();
+        } else if (hasMeaningfulPartyValue(param.getOtherPartiesThirdParty())) {
+            debtorName = param.getOtherPartiesThirdParty().trim();
+        }
         entity.setName(debtorName);
         entity.setCode(param.getCode());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
-        entity.setAmount(param.getAmount());
-        entity.setCourtName(param.getCourtName());
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2().trim()
+            : (param.getOccurrenceTime() != null ? param.getOccurrenceTime().trim() : null);
+        entity.setOccurrenceTime(occurrenceTime);
+        // 兼容企查查历史被执行人：执行标的(元) / 执行法院
+        String amount = !ImportHelper.isBlank(param.getInvolvedAmount())
+            ? param.getInvolvedAmount()
+            : param.getInvolvedAmountQcc();
+        if (amount != null) {
+            amount = amount.trim();
+        }
+        entity.setAmount(amount);
+
+        String courtName = !ImportHelper.isBlank(param.getCourtName())
+            ? param.getCourtName()
+            : param.getCourtNameQcc();
+        if (courtName != null) {
+            courtName = courtName.trim();
+        }
+        entity.setCourtName(courtName);
         entity.setDataStatus(param.getDataStatus());
         entity.setComments(param.getComments());
 
@@ -256,17 +394,20 @@ public class CreditJudgmentDebtorController extends BaseController {
         private final boolean anyDataRead;
         private final int successCount;
         private final List<String> errorMessages;
+        private final Set<Integer> touchedCompanyIds;
 
-        private ImportOutcome(boolean anyDataRead, int successCount, List<String> errorMessages) {
+        private ImportOutcome(boolean anyDataRead, int successCount, List<String> errorMessages, Set<Integer> touchedCompanyIds) {
             this.anyDataRead = anyDataRead;
             this.successCount = successCount;
             this.errorMessages = errorMessages;
+            this.touchedCompanyIds = touchedCompanyIds != null ? touchedCompanyIds : new HashSet<>();
         }
     }
 
     private ImportOutcome importFromExcel(MultipartFile excelFile, String fileLabel, Integer currentUserId, Integer currentTenantId, Integer companyId, boolean strictDebtorSheet) throws Exception {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         ExcelImportSupport.ImportResult<CreditJudgmentDebtorImportParam> importResult = readDebtorImport(excelFile, strictDebtorSheet);
         List<CreditJudgmentDebtorImportParam> list = importResult.getData();
@@ -275,7 +416,7 @@ public class CreditJudgmentDebtorController extends BaseController {
         int usedSheetIndex = importResult.getSheetIndex();
 
         if (CollectionUtils.isEmpty(list)) {
-            return new ImportOutcome(false, 0, errorMessages);
+            return new ImportOutcome(false, 0, errorMessages, touchedCompanyIds);
         }
 
         Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
@@ -308,6 +449,9 @@ public class CreditJudgmentDebtorController extends BaseController {
                 if (item.getCompanyId() == null && companyId != null) {
                     item.setCompanyId(companyId);
                 }
+                if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                    touchedCompanyIds.add(item.getCompanyId());
+                }
                 if (item.getUserId() == null && currentUserId != null) {
                     item.setUserId(currentUserId);
                 }
@@ -329,6 +473,10 @@ public class CreditJudgmentDebtorController extends BaseController {
                     continue;
                 }
 
+                if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                    touchedCompanyIds.add(item.getCompanyId());
+                }
+
                 chunkItems.add(item);
                 chunkRowNumbers.add(excelRowNumber);
                 if (chunkItems.size() >= chunkSize) {
@@ -345,7 +493,231 @@ public class CreditJudgmentDebtorController extends BaseController {
         if (!chunkItems.isEmpty()) {
             successCount += persistImportChunk(chunkItems, chunkRowNumbers, prefix, mpBatchSize, errorMessages);
         }
-        return new ImportOutcome(true, successCount, errorMessages);
+        return new ImportOutcome(true, successCount, errorMessages, touchedCompanyIds);
+    }
+
+    private ImportOutcome importHistoryFromExcel(MultipartFile excelFile, String fileLabel, Integer currentUserId, Integer currentTenantId, Integer companyId) throws Exception {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        int historySheetIndex = ExcelImportSupport.findSheetIndex(excelFile, "历史被执行人");
+        if (historySheetIndex < 0) {
+            return new ImportOutcome(false, 0, errorMessages, touchedCompanyIds);
+        }
+
+        ExcelImportSupport.ImportResult<CreditJudgmentDebtorImportParam> importResult = ExcelImportSupport.readBest(
+            excelFile,
+            CreditJudgmentDebtorImportParam.class,
+            this::isEmptyImportRow,
+            this::isScoreImportRow,
+            historySheetIndex
+        );
+
+        List<CreditJudgmentDebtorImportParam> list = importResult.getData();
+        int usedTitleRows = importResult.getTitleRows();
+        int usedHeadRows = importResult.getHeadRows();
+        int usedSheetIndex = importResult.getSheetIndex();
+
+        if (CollectionUtils.isEmpty(list)) {
+            return new ImportOutcome(false, 0, errorMessages, touchedCompanyIds);
+        }
+
+        Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+        Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "被执行人名称");
+        Map<String, String> urlByName1 = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "被执行人");
+
+        String prefix = ImportHelper.isBlank(fileLabel) ? "" : "【" + fileLabel + "】";
+
+        // 同案号多条：以导入文件中“最后一条”为准（视为最新），避免批处理中重复 upsert。
+        LinkedHashMap<String, CreditJudgmentDebtor> latestByCaseNumber = new LinkedHashMap<>();
+        LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+        for (int i = 0; i < list.size(); i++) {
+            CreditJudgmentDebtorImportParam param = list.get(i);
+            int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+            try {
+                CreditJudgmentDebtor item = convertImportParamToEntity(param);
+
+                if (item.getCaseNumber() != null) {
+                    item.setCaseNumber(item.getCaseNumber().trim());
+                }
+                if (ImportHelper.isBlank(item.getCaseNumber())) {
+                    errorMessages.add(prefix + "第" + excelRowNumber + "行：案号不能为空");
+                    continue;
+                }
+
+                String link = urlByCaseNumber.get(item.getCaseNumber());
+                if ((link == null || link.isEmpty()) && !ImportHelper.isBlank(item.getName())) {
+                    link = urlByName.get(item.getName().trim());
+                }
+                if ((link == null || link.isEmpty()) && !ImportHelper.isBlank(item.getName1())) {
+                    link = urlByName1.get(item.getName1().trim());
+                }
+                if (link != null && !link.isEmpty()) {
+                    item.setUrl(link);
+                }
+
+                if (item.getCompanyId() == null && companyId != null) {
+                    item.setCompanyId(companyId);
+                }
+                if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                    touchedCompanyIds.add(item.getCompanyId());
+                }
+                if (item.getUserId() == null && currentUserId != null) {
+                    item.setUserId(currentUserId);
+                }
+                if (item.getTenantId() == null && currentTenantId != null) {
+                    item.setTenantId(currentTenantId);
+                }
+                if (item.getStatus() == null) {
+                    item.setStatus(0);
+                }
+                if (item.getRecommend() == null) {
+                    item.setRecommend(0);
+                }
+                if (item.getDeleted() == null) {
+                    item.setDeleted(0);
+                }
+                // 历史导入的数据统一标记为“失效”
+                item.setDataStatus("失效");
+
+                latestByCaseNumber.put(item.getCaseNumber(), item);
+                latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+            } catch (Exception e) {
+                errorMessages.add(prefix + "第" + excelRowNumber + "行：" + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+
+        if (latestByCaseNumber.isEmpty()) {
+            return new ImportOutcome(true, 0, errorMessages, touchedCompanyIds);
+        }
+
+        final int chunkSize = 500;
+        final int mpBatchSize = 500;
+        List<CreditJudgmentDebtor> chunkItems = new ArrayList<>(chunkSize);
+        List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+        for (Map.Entry<String, CreditJudgmentDebtor> entry : latestByCaseNumber.entrySet()) {
+            String caseNumber = entry.getKey();
+            CreditJudgmentDebtor item = entry.getValue();
+            Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+            chunkItems.add(item);
+            chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+            if (chunkItems.size() >= chunkSize) {
+                successCount += persistHistoryImportChunk(chunkItems, chunkRowNumbers, prefix, mpBatchSize, errorMessages);
+                chunkItems.clear();
+                chunkRowNumbers.clear();
+            }
+        }
+        if (!chunkItems.isEmpty()) {
+            successCount += persistHistoryImportChunk(chunkItems, chunkRowNumbers, prefix, mpBatchSize, errorMessages);
+        }
+
+        return new ImportOutcome(true, successCount, errorMessages, touchedCompanyIds);
+    }
+
+    private int persistHistoryImportChunk(List<CreditJudgmentDebtor> items,
+                                          List<Integer> excelRowNumbers,
+                                          String prefix,
+                                          int mpBatchSize,
+                                          List<String> errorMessages) {
+        if (CollectionUtils.isEmpty(items)) {
+            return 0;
+        }
+
+        try {
+            return batchImportSupport.runInNewTx(() -> {
+                List<String> keys = new ArrayList<>(items.size());
+                for (CreditJudgmentDebtor item : items) {
+                    if (item == null || ImportHelper.isBlank(item.getCaseNumber())) {
+                        continue;
+                    }
+                    keys.add(item.getCaseNumber().trim());
+                }
+
+                Map<String, CreditJudgmentDebtor> existingByCaseNumber = new java.util.HashMap<>();
+                if (!keys.isEmpty()) {
+                    List<CreditJudgmentDebtor> existingList = creditJudgmentDebtorService.lambdaQuery()
+                        .in(CreditJudgmentDebtor::getCaseNumber, keys)
+                        .select(CreditJudgmentDebtor::getId, CreditJudgmentDebtor::getCaseNumber, CreditJudgmentDebtor::getRecommend)
+                        .list();
+                    for (CreditJudgmentDebtor existing : existingList) {
+                        if (existing == null || ImportHelper.isBlank(existing.getCaseNumber())) {
+                            continue;
+                        }
+                        existingByCaseNumber.putIfAbsent(existing.getCaseNumber().trim(), existing);
+                    }
+                }
+
+                List<CreditJudgmentDebtor> updates = new ArrayList<>();
+                List<CreditJudgmentDebtor> inserts = new ArrayList<>();
+                for (CreditJudgmentDebtor item : items) {
+                    if (item == null || ImportHelper.isBlank(item.getCaseNumber())) {
+                        continue;
+                    }
+                    String caseNumber = item.getCaseNumber().trim();
+                    CreditJudgmentDebtor existing = existingByCaseNumber.get(caseNumber);
+                    if (existing != null && existing.getId() != null) {
+                        // 覆盖更新：recommend 记录“被更新次数”，每次更新 +1
+                        item.setId(existing.getId());
+                        Integer old = existing.getRecommend();
+                        item.setRecommend(old == null ? 1 : old + 1);
+                        updates.add(item);
+                    } else {
+                        if (item.getRecommend() == null) {
+                            item.setRecommend(0);
+                        }
+                        inserts.add(item);
+                    }
+                }
+
+                if (!updates.isEmpty()) {
+                    creditJudgmentDebtorService.updateBatchById(updates, mpBatchSize);
+                }
+                if (!inserts.isEmpty()) {
+                    creditJudgmentDebtorService.saveBatch(inserts, mpBatchSize);
+                }
+                return updates.size() + inserts.size();
+            });
+        } catch (Exception batchException) {
+            int successCount = 0;
+            for (int i = 0; i < items.size(); i++) {
+                CreditJudgmentDebtor item = items.get(i);
+                int excelRowNumber = (excelRowNumbers != null && i < excelRowNumbers.size()) ? excelRowNumbers.get(i) : -1;
+                try {
+                    int delta = batchImportSupport.runInNewTx(() -> {
+                        if (item == null || ImportHelper.isBlank(item.getCaseNumber())) {
+                            return 0;
+                        }
+                        String caseNumber = item.getCaseNumber().trim();
+                        CreditJudgmentDebtor existing = creditJudgmentDebtorService.lambdaQuery()
+                            .eq(CreditJudgmentDebtor::getCaseNumber, caseNumber)
+                            .select(CreditJudgmentDebtor::getId, CreditJudgmentDebtor::getRecommend)
+                            .one();
+                        if (existing != null && existing.getId() != null) {
+                            item.setId(existing.getId());
+                            Integer old = existing.getRecommend();
+                            item.setRecommend(old == null ? 1 : old + 1);
+                            return creditJudgmentDebtorService.updateById(item) ? 1 : 0;
+                        }
+                        if (item.getRecommend() == null) {
+                            item.setRecommend(0);
+                        }
+                        return creditJudgmentDebtorService.save(item) ? 1 : 0;
+                    });
+                    if (delta > 0) {
+                        successCount += delta;
+                    } else {
+                        errorMessages.add(prefix + "第" + excelRowNumber + "行：保存失败");
+                    }
+                } catch (Exception e) {
+                    errorMessages.add(prefix + "第" + excelRowNumber + "行：" + e.getMessage());
+                }
+            }
+            return successCount;
+        }
     }
 
     private int persistImportChunk(List<CreditJudgmentDebtor> items,
@@ -415,6 +787,7 @@ public class CreditJudgmentDebtorController extends BaseController {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
         boolean anyDataRead = false;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try (InputStream is = zipFile.getInputStream(); ZipInputStream zis = new ZipInputStream(is, charset)) {
             ZipEntry entry;
@@ -437,13 +810,59 @@ public class CreditJudgmentDebtorController extends BaseController {
                         anyDataRead = true;
                         successCount += outcome.successCount;
                         errorMessages.addAll(outcome.errorMessages);
+                        touchedCompanyIds.addAll(outcome.touchedCompanyIds);
                     }
                 } catch (Exception e) {
                     errorMessages.add("【" + entryFileName + "】解析失败：" + e.getMessage());
                 }
             }
         }
-        return new ImportOutcome(anyDataRead, successCount, errorMessages);
+        return new ImportOutcome(anyDataRead, successCount, errorMessages, touchedCompanyIds);
+    }
+
+    private ImportOutcome importHistoryFromZip(MultipartFile zipFile, Integer currentUserId, Integer currentTenantId, Integer companyId) throws Exception {
+        try {
+            return importHistoryFromZip(zipFile, currentUserId, currentTenantId, companyId, StandardCharsets.UTF_8);
+        } catch (IllegalArgumentException e) {
+            return importHistoryFromZip(zipFile, currentUserId, currentTenantId, companyId, Charset.forName("GBK"));
+        }
+    }
+
+    private ImportOutcome importHistoryFromZip(MultipartFile zipFile, Integer currentUserId, Integer currentTenantId, Integer companyId, Charset charset) throws Exception {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        boolean anyDataRead = false;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try (InputStream is = zipFile.getInputStream(); ZipInputStream zis = new ZipInputStream(is, charset)) {
+            ZipEntry entry;
+            while ((entry = zis.getNextEntry()) != null) {
+                if (entry.isDirectory()) {
+                    continue;
+                }
+                String entryName = entry.getName();
+                if (!isExcelFileName(entryName)) {
+                    continue;
+                }
+
+                byte[] bytes = readAllBytes(zis);
+                String entryFileName = safeFileLabel(entryName);
+                MultipartFile excelFile = new InMemoryMultipartFile(entryFileName, bytes);
+
+                try {
+                    ImportOutcome outcome = importHistoryFromExcel(excelFile, entryFileName, currentUserId, currentTenantId, companyId);
+                    if (outcome.anyDataRead) {
+                        anyDataRead = true;
+                        successCount += outcome.successCount;
+                        errorMessages.addAll(outcome.errorMessages);
+                        touchedCompanyIds.addAll(outcome.touchedCompanyIds);
+                    }
+                } catch (Exception e) {
+                    errorMessages.add("【" + entryFileName + "】解析失败：" + e.getMessage());
+                }
+            }
+        }
+        return new ImportOutcome(anyDataRead, successCount, errorMessages, touchedCompanyIds);
     }
 
     private static boolean isZip(MultipartFile file) {
@@ -485,27 +904,43 @@ public class CreditJudgmentDebtorController extends BaseController {
     }
 
     private List<Integer> findDebtorSheetIndices(MultipartFile excelFile) throws Exception {
+        // Prefer an explicitly-named "被执行人" sheet when present.
+        List<Integer> preferred = new ArrayList<>();
         List<Integer> indices = new ArrayList<>();
         try (InputStream is = excelFile.getInputStream(); Workbook workbook = WorkbookFactory.create(is)) {
             int sheetCount = workbook.getNumberOfSheets();
             for (int i = 0; i < sheetCount; i++) {
                 String sheetName = workbook.getSheetName(i);
-                if (isDebtorSheetName(sheetName)) {
+                if (!isDebtorSheetName(sheetName)) {
+                    continue;
+                }
+                String normalized = normalizeSheetName(sheetName);
+                if ("被执行人".equals(normalized)) {
+                    preferred.add(i);
+                } else {
                     indices.add(i);
                 }
             }
         }
-        return indices;
+        preferred.addAll(indices);
+        return preferred;
     }
 
     private static boolean isDebtorSheetName(String sheetName) {
         if (sheetName == null) {
             return false;
         }
-        String normalized = sheetName.replace(" ", "").trim();
+        String normalized = normalizeSheetName(sheetName);
         return normalized.contains("被执行人") && !normalized.contains("失信") && !normalized.contains("历史");
     }
 
+    private static String normalizeSheetName(String sheetName) {
+        if (sheetName == null) {
+            return "";
+        }
+        return sheetName.replace(" ", "").replace("　", "").trim();
+    }
+
     private static boolean isExcelFileName(String name) {
         if (name == null) {
             return false;

src/main/java/com/gxwebsoft/credit/controller/CreditJudgmentDebtorHistoryController.java

@@ -1,604 +0,0 @@
-package com.gxwebsoft.credit.controller;
-
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.common.core.web.BatchParam;
-import com.gxwebsoft.common.core.web.PageResult;
-import com.gxwebsoft.common.system.entity.User;
-import com.gxwebsoft.credit.entity.CreditJudgmentDebtorHistory;
-import com.gxwebsoft.credit.param.CreditJudgmentDebtorHistoryImportParam;
-import com.gxwebsoft.credit.param.CreditJudgmentDebtorHistoryParam;
-import com.gxwebsoft.credit.service.CreditJudgmentDebtorHistoryService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.apache.poi.ss.usermodel.Workbook;
-import org.apache.poi.ss.usermodel.WorkbookFactory;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.util.CollectionUtils;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-import javax.annotation.Resource;
-import javax.servlet.http.HttpServletResponse;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipInputStream;
-
-/**
- * 被执行人控制器
- *
- * @author 科技小王子
- * @since 2026-01-12 08:10:44
- */
-@Tag(name = "被执行人管理")
-@RestController
-@RequestMapping("/api/credit/credit-judgment-debtor-history")
-public class CreditJudgmentDebtorHistoryController extends BaseController {
-    @Resource
-    private CreditJudgmentDebtorHistoryService creditJudgmentDebtorHistoryService;
-
-    @Resource
-    private BatchImportSupport batchImportSupport;
-
-    @Operation(summary = "分页查询被执行人")
-    @GetMapping("/page")
-    public ApiResult<PageResult<CreditJudgmentDebtorHistory>> page(CreditJudgmentDebtorHistoryParam param) {
-        // 使用关联查询
-        return success(creditJudgmentDebtorHistoryService.pageRel(param));
-    }
-
-    @Operation(summary = "查询全部被执行人")
-    @GetMapping()
-    public ApiResult<List<CreditJudgmentDebtorHistory>> list(CreditJudgmentDebtorHistoryParam param) {
-        // 使用关联查询
-        return success(creditJudgmentDebtorHistoryService.listRel(param));
-    }
-
-    @Operation(summary = "根据id查询被执行人")
-    @GetMapping("/{id}")
-    public ApiResult<CreditJudgmentDebtorHistory> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(creditJudgmentDebtorHistoryService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:save')")
-    @OperationLog
-    @Operation(summary = "添加被执行人")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody CreditJudgmentDebtorHistory creditJudgmentDebtorHistory) {
-        if (creditJudgmentDebtorHistoryService.save(creditJudgmentDebtorHistory)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:update')")
-    @OperationLog
-    @Operation(summary = "修改被执行人")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody CreditJudgmentDebtorHistory creditJudgmentDebtorHistory) {
-        if (creditJudgmentDebtorHistoryService.updateById(creditJudgmentDebtorHistory)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:remove')")
-    @OperationLog
-    @Operation(summary = "删除被执行人")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (creditJudgmentDebtorHistoryService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:save')")
-    @OperationLog
-    @Operation(summary = "批量添加被执行人")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<CreditJudgmentDebtorHistory> list) {
-        if (creditJudgmentDebtorHistoryService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:update')")
-    @OperationLog
-    @Operation(summary = "批量修改被执行人")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<CreditJudgmentDebtorHistory> batchParam) {
-        if (batchParam.update(creditJudgmentDebtorHistoryService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除被执行人")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (creditJudgmentDebtorHistoryService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    /**
-     * 批量导入被执行人历史
-     */
-    @PreAuthorize("hasAuthority('credit:creditJudgmentDebtorHistory:save')")
-    @Operation(summary = "批量导入被执行人历史")
-    @PostMapping("/import")
-    public ApiResult<List<String>> importBatch(@RequestParam("file") MultipartFile file,
-                                               @RequestParam(value = "companyId", required = false) Integer companyId) {
-        try {
-            User loginUser = getLoginUser();
-            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
-            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
-
-            ImportOutcome outcome;
-            if (isZip(file)) {
-                outcome = importFromZip(file, currentUserId, currentTenantId, companyId);
-            } else {
-                outcome = importFromExcel(file, safeFileLabel(file.getOriginalFilename()), currentUserId, currentTenantId, companyId, false);
-            }
-
-            if (!outcome.anyDataRead) {
-                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
-            }
-            if (outcome.errorMessages.isEmpty()) {
-                return success("成功导入" + outcome.successCount + "条数据", null);
-            }
-            return success("导入完成，成功" + outcome.successCount + "条，失败" + outcome.errorMessages.size() + "条", outcome.errorMessages);
-        } catch (Exception e) {
-            e.printStackTrace();
-            return fail("导入失败：" + e.getMessage(), null);
-        }
-    }
-
-    /**
-     * 下载被执行人历史导入模板
-     */
-    @Operation(summary = "下载被执行人历史导入模板")
-    @GetMapping("/import/template")
-    public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudgmentDebtorHistoryImportParam> templateList = new ArrayList<>();
-
-        CreditJudgmentDebtorHistoryImportParam example = new CreditJudgmentDebtorHistoryImportParam();
-        example.setCaseNumber("（2024）示例案号");
-        example.setName("某某公司");
-        example.setCode("1234567890");
-        example.setOccurrenceTime("2024-01-10");
-        example.setAmount("100000");
-        example.setDataStatus("已公开");
-        example.setComments("备注信息");
-        templateList.add(example);
-
-        Workbook workbook = ExcelImportSupport.buildTemplate("被执行人历史导入模板", "历史被执行人", CreditJudgmentDebtorHistoryImportParam.class, templateList);
-
-        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
-        response.setHeader("Content-Disposition", "attachment; filename=credit_judgment_debtor_history_import_template.xlsx");
-
-        workbook.write(response.getOutputStream());
-        workbook.close();
-    }
-
-    private boolean isEmptyImportRow(CreditJudgmentDebtorHistoryImportParam param) {
-        if (param == null) {
-            return true;
-        }
-        if (isImportHeaderRow(param)) {
-            return true;
-        }
-        return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getName())
-            && ImportHelper.isBlank(param.getName1())
-            && ImportHelper.isBlank(param.getCode());
-    }
-
-    private boolean isImportHeaderRow(CreditJudgmentDebtorHistoryImportParam param) {
-        return isHeaderValue(param.getName(), "序号")
-            || isHeaderValue(param.getName1(), "序号")
-            || isHeaderValue(param.getCaseNumber(), "案号")
-            || isHeaderValue(param.getName(), "被执行人名称")
-            || isHeaderValue(param.getName1(), "被执行人")
-            || isHeaderValue(param.getCode(), "证件号/组织机构代码")
-            || isHeaderValue(param.getOccurrenceTime(), "立案日期")
-            || isHeaderValue(param.getCourtName(), "法院")
-            || isHeaderValue(param.getAmount(), "执行标的(元)")
-            || isHeaderValue(param.getDataStatus(), "数据状态");
-    }
-
-    private static boolean isHeaderValue(String value, String headerText) {
-        if (value == null) {
-            return false;
-        }
-        return headerText.equals(value.trim());
-    }
-
-    private CreditJudgmentDebtorHistory convertImportParamToEntity(CreditJudgmentDebtorHistoryImportParam param) {
-        CreditJudgmentDebtorHistory entity = new CreditJudgmentDebtorHistory();
-
-        entity.setCaseNumber(param.getCaseNumber());
-        entity.setName1(param.getName1());
-        String debtorName = ImportHelper.isBlank(param.getName()) ? param.getName1() : param.getName();
-        entity.setName(debtorName);
-        entity.setCode(param.getCode());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
-        entity.setAmount(param.getAmount());
-        entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
-        entity.setComments(param.getComments());
-
-        return entity;
-    }
-
-    private static class ImportOutcome {
-        private final boolean anyDataRead;
-        private final int successCount;
-        private final List<String> errorMessages;
-
-        private ImportOutcome(boolean anyDataRead, int successCount, List<String> errorMessages) {
-            this.anyDataRead = anyDataRead;
-            this.successCount = successCount;
-            this.errorMessages = errorMessages;
-        }
-    }
-
-    private ImportOutcome importFromExcel(MultipartFile excelFile, String fileLabel, Integer currentUserId, Integer currentTenantId, Integer companyId, boolean strictHistorySheet) throws Exception {
-        List<String> errorMessages = new ArrayList<>();
-        int successCount = 0;
-
-        ExcelImportSupport.ImportResult<CreditJudgmentDebtorHistoryImportParam> importResult = readHistoryImport(excelFile, strictHistorySheet);
-        List<CreditJudgmentDebtorHistoryImportParam> list = importResult.getData();
-        int usedTitleRows = importResult.getTitleRows();
-        int usedHeadRows = importResult.getHeadRows();
-        int usedSheetIndex = importResult.getSheetIndex();
-
-        if (CollectionUtils.isEmpty(list)) {
-            return new ImportOutcome(false, 0, errorMessages);
-        }
-
-        Map<String, String> urlByCaseNumber = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
-        Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "被执行人名称");
-        Map<String, String> urlByName1 = ExcelImportSupport.readHyperlinksByHeaderKey(excelFile, usedSheetIndex, usedTitleRows, usedHeadRows, "被执行人");
-
-        String prefix = ImportHelper.isBlank(fileLabel) ? "" : "【" + fileLabel + "】";
-        final int chunkSize = 500;
-        final int mpBatchSize = 500;
-        List<CreditJudgmentDebtorHistory> chunkItems = new ArrayList<>(chunkSize);
-        List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
-        for (int i = 0; i < list.size(); i++) {
-            CreditJudgmentDebtorHistoryImportParam param = list.get(i);
-            try {
-                CreditJudgmentDebtorHistory item = convertImportParamToEntity(param);
-                String link = null;
-                if (!ImportHelper.isBlank(item.getCaseNumber())) {
-                    link = urlByCaseNumber.get(item.getCaseNumber().trim());
-                }
-                if ((link == null || link.isEmpty()) && !ImportHelper.isBlank(item.getName())) {
-                    link = urlByName.get(item.getName().trim());
-                }
-                if ((link == null || link.isEmpty()) && !ImportHelper.isBlank(item.getName1())) {
-                    link = urlByName1.get(item.getName1().trim());
-                }
-                if (link != null && !link.isEmpty()) {
-                    item.setUrl(link);
-                }
-
-                if (item.getCompanyId() == null && companyId != null) {
-                    item.setCompanyId(companyId);
-                }
-                if (item.getUserId() == null && currentUserId != null) {
-                    item.setUserId(currentUserId);
-                }
-                if (item.getTenantId() == null && currentTenantId != null) {
-                    item.setTenantId(currentTenantId);
-                }
-                if (item.getType() == null) {
-                    item.setType(0);
-                }
-                if (item.getStatus() == null) {
-                    item.setStatus(0);
-                }
-                if (item.getRecommend() == null) {
-                    item.setRecommend(0);
-                }
-                if (item.getDeleted() == null) {
-                    item.setDeleted(0);
-                }
-
-                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
-                if (ImportHelper.isBlank(item.getCaseNumber())) {
-                    errorMessages.add(prefix + "第" + excelRowNumber + "行：案号不能为空");
-                    continue;
-                }
-
-                chunkItems.add(item);
-                chunkRowNumbers.add(excelRowNumber);
-                if (chunkItems.size() >= chunkSize) {
-                    successCount += persistImportChunk(chunkItems, chunkRowNumbers, prefix, mpBatchSize, errorMessages);
-                    chunkItems.clear();
-                    chunkRowNumbers.clear();
-                }
-            } catch (Exception e) {
-                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
-                errorMessages.add(prefix + "第" + excelRowNumber + "行：" + e.getMessage());
-                e.printStackTrace();
-            }
-        }
-        if (!chunkItems.isEmpty()) {
-            successCount += persistImportChunk(chunkItems, chunkRowNumbers, prefix, mpBatchSize, errorMessages);
-        }
-        return new ImportOutcome(true, successCount, errorMessages);
-    }
-
-    private int persistImportChunk(List<CreditJudgmentDebtorHistory> items,
-                                   List<Integer> excelRowNumbers,
-                                   String prefix,
-                                   int mpBatchSize,
-                                   List<String> errorMessages) {
-        if (CollectionUtils.isEmpty(items)) {
-            return 0;
-        }
-        try {
-            return batchImportSupport.runInNewTx(() -> batchImportSupport.upsertBySingleKey(
-                creditJudgmentDebtorHistoryService,
-                items,
-                CreditJudgmentDebtorHistory::getId,
-                CreditJudgmentDebtorHistory::setId,
-                CreditJudgmentDebtorHistory::getCaseNumber,
-                CreditJudgmentDebtorHistory::getCaseNumber,
-                null,
-                mpBatchSize
-            ));
-        } catch (Exception batchException) {
-            int successCount = 0;
-            for (int i = 0; i < items.size(); i++) {
-                CreditJudgmentDebtorHistory item = items.get(i);
-                int excelRowNumber = (excelRowNumbers != null && i < excelRowNumbers.size()) ? excelRowNumbers.get(i) : -1;
-                try {
-                    int delta = batchImportSupport.runInNewTx(() -> {
-                        boolean saved = creditJudgmentDebtorHistoryService.save(item);
-                        if (!saved) {
-                            CreditJudgmentDebtorHistory existing = creditJudgmentDebtorHistoryService.lambdaQuery()
-                                .eq(CreditJudgmentDebtorHistory::getCaseNumber, item.getCaseNumber())
-                                .one();
-                            if (existing != null) {
-                                item.setId(existing.getId());
-                                if (creditJudgmentDebtorHistoryService.updateById(item)) {
-                                    return 1;
-                                }
-                            }
-                        } else {
-                            return 1;
-                        }
-                        return 0;
-                    });
-                    if (delta > 0) {
-                        successCount += delta;
-                    } else {
-                        errorMessages.add(prefix + "第" + excelRowNumber + "行：保存失败");
-                    }
-                } catch (Exception e) {
-                    errorMessages.add(prefix + "第" + excelRowNumber + "行：" + e.getMessage());
-                }
-            }
-            return successCount;
-        }
-    }
-
-    private ImportOutcome importFromZip(MultipartFile zipFile, Integer currentUserId, Integer currentTenantId, Integer companyId) throws Exception {
-        try {
-            return importFromZip(zipFile, currentUserId, currentTenantId, companyId, StandardCharsets.UTF_8);
-        } catch (IllegalArgumentException e) {
-            return importFromZip(zipFile, currentUserId, currentTenantId, companyId, Charset.forName("GBK"));
-        }
-    }
-
-    private ImportOutcome importFromZip(MultipartFile zipFile, Integer currentUserId, Integer currentTenantId, Integer companyId, Charset charset) throws Exception {
-        List<String> errorMessages = new ArrayList<>();
-        int successCount = 0;
-        boolean anyDataRead = false;
-
-        try (InputStream is = zipFile.getInputStream(); ZipInputStream zis = new ZipInputStream(is, charset)) {
-            ZipEntry entry;
-            while ((entry = zis.getNextEntry()) != null) {
-                if (entry.isDirectory()) {
-                    continue;
-                }
-                String entryName = entry.getName();
-                if (!isExcelFileName(entryName)) {
-                    continue;
-                }
-
-                byte[] bytes = readAllBytes(zis);
-                String entryFileName = safeFileLabel(entryName);
-                MultipartFile excelFile = new InMemoryMultipartFile(entryFileName, bytes);
-
-                try {
-                    ImportOutcome outcome = importFromExcel(excelFile, entryFileName, currentUserId, currentTenantId, companyId, true);
-                    if (outcome.anyDataRead) {
-                        anyDataRead = true;
-                        successCount += outcome.successCount;
-                        errorMessages.addAll(outcome.errorMessages);
-                    }
-                } catch (Exception e) {
-                    errorMessages.add("【" + entryFileName + "】解析失败：" + e.getMessage());
-                }
-            }
-        }
-        return new ImportOutcome(anyDataRead, successCount, errorMessages);
-    }
-
-    private static boolean isZip(MultipartFile file) {
-        String filename = file != null ? file.getOriginalFilename() : null;
-        if (filename == null) {
-            return false;
-        }
-        return filename.toLowerCase(Locale.ROOT).endsWith(".zip");
-    }
-
-    private ExcelImportSupport.ImportResult<CreditJudgmentDebtorHistoryImportParam> readHistoryImport(MultipartFile excelFile, boolean strictHistorySheet) throws Exception {
-        int namedSheetIndex = ExcelImportSupport.findSheetIndex(excelFile, "历史被执行人");
-        if (namedSheetIndex >= 0) {
-            ExcelImportSupport.ImportResult<CreditJudgmentDebtorHistoryImportParam> namedSheetResult = ExcelImportSupport.readBest(
-                excelFile,
-                CreditJudgmentDebtorHistoryImportParam.class,
-                this::isEmptyImportRow,
-                this::isScoreImportRow,
-                namedSheetIndex
-            );
-            if (!CollectionUtils.isEmpty(namedSheetResult.getData())) {
-                return namedSheetResult;
-            }
-        }
-
-        List<Integer> historySheetIndices = findHistorySheetIndices(excelFile);
-        for (Integer sheetIndex : historySheetIndices) {
-            if (sheetIndex != null && sheetIndex == namedSheetIndex) {
-                continue;
-            }
-            ExcelImportSupport.ImportResult<CreditJudgmentDebtorHistoryImportParam> sheetResult = ExcelImportSupport.readBest(
-                excelFile,
-                CreditJudgmentDebtorHistoryImportParam.class,
-                this::isEmptyImportRow,
-                this::isScoreImportRow,
-                sheetIndex
-            );
-            if (!CollectionUtils.isEmpty(sheetResult.getData())) {
-                return sheetResult;
-            }
-        }
-        if (strictHistorySheet) {
-            return new ExcelImportSupport.ImportResult<>(new ArrayList<>(), 0, 0);
-        }
-        return ExcelImportSupport.readAnySheetBest(excelFile, CreditJudgmentDebtorHistoryImportParam.class, this::isEmptyImportRow, this::isScoreImportRow);
-    }
-
-    private boolean isScoreImportRow(CreditJudgmentDebtorHistoryImportParam param) {
-        if (param == null) {
-            return false;
-        }
-        if (isImportHeaderRow(param)) {
-            return false;
-        }
-        return !ImportHelper.isBlank(param.getCaseNumber());
-    }
-
-    private List<Integer> findHistorySheetIndices(MultipartFile excelFile) throws Exception {
-        List<Integer> indices = new ArrayList<>();
-        try (InputStream is = excelFile.getInputStream(); Workbook workbook = WorkbookFactory.create(is)) {
-            int sheetCount = workbook.getNumberOfSheets();
-            for (int i = 0; i < sheetCount; i++) {
-                String sheetName = workbook.getSheetName(i);
-                if (isHistorySheetName(sheetName)) {
-                    indices.add(i);
-                }
-            }
-        }
-        return indices;
-    }
-
-    private static boolean isHistorySheetName(String sheetName) {
-        if (sheetName == null) {
-            return false;
-        }
-        String normalized = sheetName.replace(" ", "").trim();
-        return normalized.contains("被执行人") && normalized.contains("历史") && !normalized.contains("失信");
-    }
-
-    private static boolean isExcelFileName(String name) {
-        if (name == null) {
-            return false;
-        }
-        String lower = name.toLowerCase(Locale.ROOT);
-        return lower.endsWith(".xlsx") || lower.endsWith(".xls") || lower.endsWith(".xlsm");
-    }
-
-    private static String safeFileLabel(String name) {
-        if (ImportHelper.isBlank(name)) {
-            return "";
-        }
-        int lastSlash = name.lastIndexOf('/');
-        if (lastSlash >= 0 && lastSlash + 1 < name.length()) {
-            return name.substring(lastSlash + 1);
-        }
-        return name;
-    }
-
-    private static byte[] readAllBytes(InputStream inputStream) throws IOException {
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
-        byte[] buffer = new byte[8192];
-        int read;
-        while ((read = inputStream.read(buffer)) != -1) {
-            out.write(buffer, 0, read);
-        }
-        return out.toByteArray();
-    }
-
-    private static class InMemoryMultipartFile implements MultipartFile {
-        private final String originalFilename;
-        private final byte[] bytes;
-
-        private InMemoryMultipartFile(String originalFilename, byte[] bytes) {
-            this.originalFilename = originalFilename;
-            this.bytes = bytes != null ? bytes : new byte[0];
-        }
-
-        @Override
-        public String getName() {
-            return originalFilename;
-        }
-
-        @Override
-        public String getOriginalFilename() {
-            return originalFilename;
-        }
-
-        @Override
-        public String getContentType() {
-            return null;
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return bytes.length == 0;
-        }
-
-        @Override
-        public long getSize() {
-            return bytes.length;
-        }
-
-        @Override
-        public byte[] getBytes() {
-            return bytes;
-        }
-
-        @Override
-        public InputStream getInputStream() {
-            return new java.io.ByteArrayInputStream(bytes);
-        }
-
-        @Override
-        public void transferTo(java.io.File dest) throws IOException {
-            Files.write(dest.toPath(), bytes);
-        }
-    }
-
-}

src/main/java/com/gxwebsoft/credit/controller/CreditJudicialDocumentController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditJudicialDocument;
+import com.gxwebsoft.credit.param.CreditJudicialDocumentImportParam;
 import com.gxwebsoft.credit.param.CreditJudicialDocumentParam;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditJudicialDocumentService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 裁判文书司法大数据控制器
@@ -40,6 +46,12 @@ public class CreditJudicialDocumentController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询裁判文书司法大数据")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditJudicialDocument>> page(CreditJudicialDocumentParam param) {
@@ -132,6 +144,46 @@ public class CreditJudicialDocumentController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据“当事人/第三人”文本中包含的企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditJudicialDocument:update')")
+    @OperationLog
+    @Operation(summary = "根据当事人字段包含企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditJudicialDocumentService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditJudicialDocument::getId,
+            CreditJudicialDocument::setId,
+            CreditJudicialDocument::getCompanyId,
+            CreditJudicialDocument::setCompanyId,
+            CreditJudicialDocument::getHasData,
+            CreditJudicialDocument::setHasData,
+            CreditJudicialDocument::getTenantId,
+            CreditJudicialDocument::new,
+            // 需求：otherPartiesThirdParty 字段包含企业名称时，回填 companyId
+            CreditJudicialDocument::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入裁判文书司法大数据
      */
@@ -142,13 +194,17 @@ public class CreditJudicialDocumentController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            // 支持按选项卡名称导入：默认读取“裁判文书”sheet（不存在则回退到第 0 个sheet）
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "裁判文书", 0);
+            ExcelImportSupport.ImportResult<CreditJudicialDocumentImportParam> importResult = ExcelImportSupport.read(
+                file, CreditJudicialDocumentImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditJudicialDocumentImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +213,8 @@ public class CreditJudicialDocumentController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+            Map<String, String> urlByTitle = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "文书标题");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,13 +222,26 @@ public class CreditJudicialDocumentController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditJudicialDocumentImportParam param = list.get(i);
                 try {
                     CreditJudicialDocument item = convertImportParamToEntity(param);
+                    String link = null;
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(link) && !ImportHelper.isBlank(item.getTitle())) {
+                        link = urlByTitle.get(item.getTitle().trim());
+                    }
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -193,6 +264,10 @@ public class CreditJudicialDocumentController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +352,8 @@ public class CreditJudicialDocumentController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.JUDICIAL_DOCUMENT, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -288,29 +365,240 @@ public class CreditJudicialDocumentController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史裁判文书（仅解析“历史裁判文书”选项卡）
+     * 规则：案号相同则覆盖更新（recommend++ 记录更新次数）；案号不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditJudicialDocument:save')")
+    @Operation(summary = "批量导入历史裁判文书司法大数据")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史裁判文书");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史裁判文书”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditJudicialDocumentImportParam> importResult = ExcelImportSupport.read(
+                file, CreditJudicialDocumentImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditJudicialDocumentImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+            Map<String, String> urlByTitle = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "文书标题");
+
+            LinkedHashMap<String, CreditJudicialDocument> latestByCaseNumber = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditJudicialDocumentImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditJudicialDocument item = convertImportParamToEntity(param);
+                    if (item.getCaseNumber() != null) {
+                        item.setCaseNumber(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCaseNumber())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = null;
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        link = urlByCaseNumber.get(item.getCaseNumber());
+                    }
+                    if (ImportHelper.isBlank(link) && !ImportHelper.isBlank(item.getTitle())) {
+                        link = urlByTitle.get(item.getTitle().trim());
+                    }
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    latestByCaseNumber.put(item.getCaseNumber(), item);
+                    latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCaseNumber.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditJudicialDocument> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditJudicialDocument> entry : latestByCaseNumber.entrySet()) {
+                String caseNumber = entry.getKey();
+                CreditJudicialDocument item = entry.getValue();
+                Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditJudicialDocumentService,
+                            chunkItems,
+                            CreditJudicialDocument::getId,
+                            CreditJudicialDocument::setId,
+                            CreditJudicialDocument::getCaseNumber,
+                            CreditJudicialDocument::getCaseNumber,
+                            CreditJudicialDocument::getRecommend,
+                            CreditJudicialDocument::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditJudicialDocumentService.save(rowItem);
+                            if (!saved) {
+                                CreditJudicialDocument existing = creditJudicialDocumentService.lambdaQuery()
+                                    .eq(CreditJudicialDocument::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditJudicialDocument::getId, CreditJudicialDocument::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditJudicialDocumentService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditJudicialDocumentService,
+                        chunkItems,
+                        CreditJudicialDocument::getId,
+                        CreditJudicialDocument::setId,
+                        CreditJudicialDocument::getCaseNumber,
+                        CreditJudicialDocument::getCaseNumber,
+                        CreditJudicialDocument::getRecommend,
+                        CreditJudicialDocument::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditJudicialDocumentService.save(rowItem);
+                        if (!saved) {
+                            CreditJudicialDocument existing = creditJudicialDocumentService.lambdaQuery()
+                                .eq(CreditJudicialDocument::getCaseNumber, rowItem.getCaseNumber())
+                                .select(CreditJudicialDocument::getId, CreditJudicialDocument::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditJudicialDocumentService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.JUDICIAL_DOCUMENT, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载裁判文书导入模板
      */
     @Operation(summary = "下载裁判文书导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditJudicialDocumentImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
-        example.setDataType("裁判文书");
-        example.setPlaintiffAppellant("原告示例");
-        example.setAppellee("被告示例");
+        CreditJudicialDocumentImportParam example = new CreditJudicialDocumentImportParam();
+        example.setTitle("裁判文书");
         example.setOtherPartiesThirdParty("第三人示例");
         example.setOccurrenceTime("2024-01-01");
         example.setCaseNumber("（2024）示例案号");
         example.setCauseOfAction("案由示例");
         example.setInvolvedAmount("100000");
+        example.setDefendantAppellee("裁判结果示例");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
+        example.setReleaseDate("2024-01-02");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("裁判文书导入模板", "裁判文书", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("裁判文书导入模板", "裁判文书", CreditJudicialDocumentImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_judicial_document_import_template.xlsx");
@@ -319,31 +607,34 @@ public class CreditJudicialDocumentController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditJudicialDocumentImportParam param) {
         if (param == null) {
             return true;
         }
-        return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+        return ImportHelper.isBlank(param.getCaseNumber());
     }
 
-    private CreditJudicialDocument convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditJudicialDocument convertImportParamToEntity(CreditJudicialDocumentImportParam param) {
         CreditJudicialDocument entity = new CreditJudicialDocument();
 
-        entity.setDataType(param.getDataType());
-        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
-        entity.setAppellee(param.getAppellee());
+      String involvedAmount = !ImportHelper.isBlank(param.getInvolvedAmount2())
+        ? param.getInvolvedAmount2()
+        : param.getInvolvedAmount();
+
+        entity.setTitle(param.getTitle());
+        entity.setType(param.getType());
+        entity.setDataStatus(param.getDataStatus());
         entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
         entity.setOccurrenceTime(param.getOccurrenceTime());
         entity.setCaseNumber(param.getCaseNumber());
         entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
+        entity.setInvolvedAmount(involvedAmount);
+        // Excel导入字段映射补全：否则对应数据库字段(defendant_appellee/release_date)会一直为空
+        entity.setDefendantAppellee(param.getDefendantAppellee());
+        entity.setReleaseDate(param.getReleaseDate());
         entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
         entity.setComments(param.getComments());
-
+      System.out.println("entity = " + entity);
         return entity;
     }
 

src/main/java/com/gxwebsoft/credit/controller/CreditJudiciaryController.java

@@ -13,6 +13,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditJudiciary;
 import com.gxwebsoft.credit.param.CreditJudiciaryImportParam;
 import com.gxwebsoft.credit.param.CreditJudiciaryParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditJudiciaryService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -26,7 +28,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 司法案件控制器
@@ -44,6 +49,12 @@ public class CreditJudiciaryController extends BaseController {
   @Resource
   private BatchImportSupport batchImportSupport;
 
+  @Resource
+  private CreditCompanyService creditCompanyService;
+
+  @Resource
+  private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询司法案件")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditJudiciary>> page(CreditJudiciaryParam param) {
@@ -131,6 +142,45 @@ public class CreditJudiciaryController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditJudiciary:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditJudiciaryService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditJudiciary::getId,
+            CreditJudiciary::setId,
+            CreditJudiciary::getName,
+            CreditJudiciary::getCompanyId,
+            CreditJudiciary::setCompanyId,
+            CreditJudiciary::getHasData,
+            CreditJudiciary::setHasData,
+            CreditJudiciary::getTenantId,
+            CreditJudiciary::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
   /**
    * 批量导入司法案件
    */
@@ -141,15 +191,19 @@ public class CreditJudiciaryController extends BaseController {
                                              @RequestParam(value = "companyId", required = false) Integer companyId) {
     List<String> errorMessages = new ArrayList<>();
     int successCount = 0;
+    Set<Integer> touchedCompanyIds = new HashSet<>();
 
     try {
+      // 支持按选项卡名称导入：默认读取“司法案件”sheet（不存在则回退到第 0 个sheet）
+      int sheetIndex = ExcelImportSupport.findSheetIndex(file, "司法案件", 0);
+
       List<CreditJudiciaryImportParam> list = null;
       int usedTitleRows = 0;
       int usedHeadRows = 0;
       int[][] tryConfigs = new int[][]{{1, 1}, {0, 1}, {0, 2}, {0, 3}};
 
       for (int[] config : tryConfigs) {
-        list = filterEmptyRows(tryImport(file, config[0], config[1]));
+        list = filterEmptyRows(tryImport(file, config[0], config[1], sheetIndex));
         if (!CollectionUtils.isEmpty(list)) {
           usedTitleRows = config[0];
           usedHeadRows = config[1];
@@ -163,6 +217,20 @@ public class CreditJudiciaryController extends BaseController {
       User loginUser = getLoginUser();
       Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
       Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+      // easypoi 默认不会读取单元格超链接地址；url 可能挂在“案号/案件名称”等列的超链接中，需要额外读取回填。
+      Map<String, String> urlByCode = ExcelImportSupport.readHyperlinksByHeaderKey(file, sheetIndex, usedTitleRows, usedHeadRows, "案号");
+      Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(file, sheetIndex, usedTitleRows, usedHeadRows, "案件名称");
+      // 有些源文件会单独提供“url/网址/链接”等列（可能是纯文本也可能是超链接）
+      Map<String, String> urlByCodeFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(file, sheetIndex, usedTitleRows, usedHeadRows, "案号", "url");
+      if (urlByCodeFromUrlCol.isEmpty()) {
+        urlByCodeFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(file, sheetIndex, usedTitleRows, usedHeadRows, "案号", "URL");
+      }
+      if (urlByCodeFromUrlCol.isEmpty()) {
+        urlByCodeFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(file, sheetIndex, usedTitleRows, usedHeadRows, "案号", "网址");
+      }
+      if (urlByCodeFromUrlCol.isEmpty()) {
+        urlByCodeFromUrlCol = ExcelImportSupport.readKeyValueByHeaders(file, sheetIndex, usedTitleRows, usedHeadRows, "案号", "链接");
+      }
 
       final int chunkSize = 500;
       final int mpBatchSize = 500;
@@ -173,6 +241,21 @@ public class CreditJudiciaryController extends BaseController {
         CreditJudiciaryImportParam param = list.get(i);
         try {
           CreditJudiciary item = convertImportParamToEntity(param);
+          if (!isBlank(item.getCode())) {
+            String key = item.getCode().trim();
+            String link = urlByCode.get(key);
+            if (isBlank(link)) {
+              link = urlByCodeFromUrlCol.get(key);
+            }
+            if (!isBlank(link)) {
+              item.setUrl(link.trim());
+            }
+          } else if (!isBlank(item.getName())) {
+            String link = urlByName.get(item.getName().trim());
+            if (!isBlank(link)) {
+              item.setUrl(link.trim());
+            }
+          }
           if (item.getCompanyId() == null && companyId != null) {
             item.setCompanyId(companyId);
           }
@@ -198,15 +281,19 @@ public class CreditJudiciaryController extends BaseController {
           }
           int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
           // 验证必填字段
-          if (item.getName() == null || item.getName().trim().isEmpty()) {
-            errorMessages.add("第" + excelRowNumber + "行：项目名称不能为空");
-            continue;
-          }
+//          if (item.getName() == null || item.getName().trim().isEmpty()) {
+//            errorMessages.add("第" + excelRowNumber + "行：项目名称不能为空");
+//            continue;
+//          }
           if (item.getCode() == null || item.getCode().trim().isEmpty()) {
             errorMessages.add("第" + excelRowNumber + "行：唯一标识不能为空");
             continue;
           }
 
+          if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+            touchedCompanyIds.add(item.getCompanyId());
+          }
+
           chunkItems.add(item);
           chunkRowNumbers.add(excelRowNumber);
           if (chunkItems.size() >= chunkSize) {
@@ -285,6 +372,8 @@ public class CreditJudiciaryController extends BaseController {
         );
       }
 
+      creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.JUDICIARY, touchedCompanyIds);
+
       if (errorMessages.isEmpty()) {
         return success("成功导入" + successCount + "条数据", null);
       } else {
@@ -329,11 +418,11 @@ public class CreditJudiciaryController extends BaseController {
       workbook.close();
     }
 
-    private List<CreditJudiciaryImportParam> tryImport(MultipartFile file, int titleRows, int headRows) throws Exception {
+    private List<CreditJudiciaryImportParam> tryImport(MultipartFile file, int titleRows, int headRows, int sheetIndex) throws Exception {
       ImportParams importParams = new ImportParams();
       importParams.setTitleRows(titleRows);
       importParams.setHeadRows(headRows);
-      importParams.setStartSheetIndex(0);
+      importParams.setStartSheetIndex(sheetIndex);
       importParams.setSheetNum(1);
       return ExcelImportUtil.importExcel(file.getInputStream(), CreditJudiciaryImportParam.class, importParams);
     }

src/main/java/com/gxwebsoft/credit/controller/CreditMediationController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditMediation;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.param.CreditMediationImportParam;
 import com.gxwebsoft.credit.param.CreditMediationParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditMediationService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 诉前调解司法大数据控制器
@@ -40,6 +45,12 @@ public class CreditMediationController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询诉前调解司法大数据")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditMediation>> page(CreditMediationParam param) {
@@ -132,6 +143,49 @@ public class CreditMediationController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditMediation:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditMediationService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditMediation::getId,
+            CreditMediation::setId,
+            CreditMediation::getCompanyId,
+            CreditMediation::setCompanyId,
+            CreditMediation::getHasData,
+            CreditMediation::setHasData,
+            CreditMediation::getTenantId,
+            CreditMediation::new,
+            CreditMediation::getPlaintiffAppellant,
+            CreditMediation::getAppellee,
+            CreditMediation::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入诉前调解司法大数据
      */
@@ -142,13 +196,16 @@ public class CreditMediationController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "诉前调解", 0);
+            ExcelImportSupport.ImportResult<CreditMediationImportParam> importResult = ExcelImportSupport.read(
+                file, CreditMediationImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditMediationImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +214,7 @@ public class CreditMediationController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,9 +222,15 @@ public class CreditMediationController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditMediationImportParam param = list.get(i);
                 try {
                     CreditMediation item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -193,6 +257,10 @@ public class CreditMediationController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +345,8 @@ public class CreditMediationController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.MEDIATION, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -294,23 +364,18 @@ public class CreditMediationController extends BaseController {
     @Operation(summary = "下载诉前调解导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditMediationImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
-        example.setDataType("诉前调解");
-        example.setPlaintiffAppellant("原告示例");
-        example.setAppellee("被告示例");
-        example.setOtherPartiesThirdParty("第三人示例");
-        example.setOccurrenceTime("2024-01-01");
+        CreditMediationImportParam example = new CreditMediationImportParam();
+        example.setOtherPartiesThirdParty("当事人");
         example.setCaseNumber("（2024）示例案号");
         example.setCauseOfAction("案由示例");
-        example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
+        example.setOccurrenceTime("2024-01-01");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("诉前调解导入模板", "诉前调解", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("诉前调解导入模板", "诉前调解", CreditMediationImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_mediation_import_template.xlsx");
@@ -319,30 +384,35 @@ public class CreditMediationController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditMediationImportParam param) {
         if (param == null) {
             return true;
         }
         return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
             && ImportHelper.isBlank(param.getCauseOfAction());
     }
 
-    private CreditMediation convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditMediation convertImportParamToEntity(CreditMediationImportParam param) {
         CreditMediation entity = new CreditMediation();
 
-        entity.setDataType(param.getDataType());
-        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
-        entity.setAppellee(param.getAppellee());
-        entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
+        // Template compatibility: prefer new columns ("发生时间"/"其他当事人/第三人"), fallback to legacy ones ("立案日期"/"当事人").
+        String occurrenceTime = !ImportHelper.isBlank(param.getOccurrenceTime2())
+            ? param.getOccurrenceTime2()
+            : param.getOccurrenceTime();
+        String otherPartiesThirdParty = !ImportHelper.isBlank(param.getOtherPartiesThirdParty2())
+            ? param.getOtherPartiesThirdParty2()
+            : param.getOtherPartiesThirdParty();
+
+        entity.setOccurrenceTime(occurrenceTime);
+        entity.setOtherPartiesThirdParty(otherPartiesThirdParty);
         entity.setCaseNumber(param.getCaseNumber());
         entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
         entity.setCourtName(param.getCourtName());
-        entity.setDataStatus(param.getDataStatus());
         entity.setComments(param.getComments());
+        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
+        entity.setAppellee(param.getAppellee());
+        entity.setInvolvedAmount(param.getInvolvedAmount());
+        entity.setDataStatus(param.getDataStatus());
 
         return entity;
     }

src/main/java/com/gxwebsoft/credit/controller/CreditNearbyCompanyController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditNearbyCompany;
 import com.gxwebsoft.credit.param.CreditNearbyCompanyImportParam;
 import com.gxwebsoft.credit.param.CreditNearbyCompanyParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditNearbyCompanyService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 附近企业控制器
@@ -41,6 +45,12 @@ public class CreditNearbyCompanyController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询附近企业")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditNearbyCompany>> page(CreditNearbyCompanyParam param) {
@@ -133,6 +143,45 @@ public class CreditNearbyCompanyController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditNearbyCompany:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditNearbyCompanyService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditNearbyCompany::getId,
+            CreditNearbyCompany::setId,
+            CreditNearbyCompany::getName,
+            CreditNearbyCompany::getCompanyId,
+            CreditNearbyCompany::setCompanyId,
+            CreditNearbyCompany::getHasData,
+            CreditNearbyCompany::setHasData,
+            CreditNearbyCompany::getTenantId,
+            CreditNearbyCompany::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入附近企业
      */
@@ -145,6 +194,7 @@ public class CreditNearbyCompanyController extends BaseController {
                                                @RequestParam(value = "type", required = false) Integer type) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditNearbyCompanyImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -194,6 +244,9 @@ public class CreditNearbyCompanyController extends BaseController {
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -234,6 +287,8 @@ public class CreditNearbyCompanyController extends BaseController {
                 successCount += persistImportChunk(chunkItems, chunkRowNumbers, companyId, parentId, type, currentTenantId, mpBatchSize, errorMessages);
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.NEARBY_COMPANY, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditPatentController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditPatent;
 import com.gxwebsoft.credit.param.CreditPatentImportParam;
 import com.gxwebsoft.credit.param.CreditPatentParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditPatentService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 专利控制器
@@ -41,6 +45,12 @@ public class CreditPatentController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询专利")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditPatent>> page(CreditPatentParam param) {
@@ -133,6 +143,45 @@ public class CreditPatentController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditPatent:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditPatentService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditPatent::getId,
+            CreditPatent::setId,
+            CreditPatent::getPatentApplicant,
+            CreditPatent::getCompanyId,
+            CreditPatent::setCompanyId,
+            CreditPatent::getHasData,
+            CreditPatent::setHasData,
+            CreditPatent::getTenantId,
+            CreditPatent::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入专利
      */
@@ -143,6 +192,7 @@ public class CreditPatentController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditPatentImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -207,6 +257,10 @@ public class CreditPatentController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -291,6 +345,8 @@ public class CreditPatentController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.PATENT, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -339,9 +395,7 @@ public class CreditPatentController extends BaseController {
         if (isImportHeaderRow(param)) {
             return true;
         }
-        return ImportHelper.isBlank(param.getRegisterNo())
-            && ImportHelper.isBlank(param.getName())
-            && ImportHelper.isBlank(param.getPatentApplicant());
+        return ImportHelper.isBlank(param.getPublicNo());
     }
 
     private boolean isImportHeaderRow(CreditPatentImportParam param) {

src/main/java/com/gxwebsoft/credit/controller/CreditRiskRelationController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditRiskRelation;
 import com.gxwebsoft.credit.param.CreditRiskRelationImportParam;
 import com.gxwebsoft.credit.param.CreditRiskRelationParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditRiskRelationService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 风险关系表控制器
@@ -40,6 +45,12 @@ public class CreditRiskRelationController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询风险关系表")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditRiskRelation>> page(CreditRiskRelationParam param) {
@@ -132,6 +143,45 @@ public class CreditRiskRelationController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditRiskRelation:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditRiskRelationService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditRiskRelation::getId,
+            CreditRiskRelation::setId,
+            CreditRiskRelation::getMainBodyName,
+            CreditRiskRelation::getCompanyId,
+            CreditRiskRelation::setCompanyId,
+            CreditRiskRelation::getHasData,
+            CreditRiskRelation::setHasData,
+            CreditRiskRelation::getTenantId,
+            CreditRiskRelation::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入风险关系表
      */
@@ -142,6 +192,7 @@ public class CreditRiskRelationController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             int sheetIndex = ExcelImportSupport.findSheetIndex(file, "风险关系", 1);
@@ -194,6 +245,10 @@ public class CreditRiskRelationController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -278,6 +333,8 @@ public class CreditRiskRelationController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.RISK_RELATION, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditSupplierController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditSupplier;
 import com.gxwebsoft.credit.param.CreditSupplierImportParam;
 import com.gxwebsoft.credit.param.CreditSupplierParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditSupplierService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 供应商控制器
@@ -40,6 +45,12 @@ public class CreditSupplierController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询供应商")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditSupplier>> page(CreditSupplierParam param) {
@@ -132,6 +143,45 @@ public class CreditSupplierController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditSupplier:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditSupplierService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditSupplier::getId,
+            CreditSupplier::setId,
+            CreditSupplier::getSupplier,
+            CreditSupplier::getCompanyId,
+            CreditSupplier::setCompanyId,
+            CreditSupplier::getHasData,
+            CreditSupplier::setHasData,
+            CreditSupplier::getTenantId,
+            CreditSupplier::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入供应商
      */
@@ -142,6 +192,7 @@ public class CreditSupplierController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             int sheetIndex = ExcelImportSupport.findSheetIndex(file, "供应商", 3);
@@ -150,6 +201,7 @@ public class CreditSupplierController extends BaseController {
             List<CreditSupplierImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -158,6 +210,7 @@ public class CreditSupplierController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlBySupplier = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "供应商");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -168,6 +221,12 @@ public class CreditSupplierController extends BaseController {
                 CreditSupplierImportParam param = list.get(i);
                 try {
                     CreditSupplier item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getSupplier())) {
+                        String link = urlBySupplier.get(item.getSupplier().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
@@ -194,6 +253,10 @@ public class CreditSupplierController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -278,6 +341,8 @@ public class CreditSupplierController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.SUPPLIER, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditSuspectedRelationshipController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditSuspectedRelationship;
 import com.gxwebsoft.credit.param.CreditSuspectedRelationshipImportParam;
 import com.gxwebsoft.credit.param.CreditSuspectedRelationshipParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditSuspectedRelationshipService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 疑似关系控制器
@@ -41,6 +45,12 @@ public class CreditSuspectedRelationshipController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询疑似关系")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditSuspectedRelationship>> page(CreditSuspectedRelationshipParam param) {
@@ -133,6 +143,45 @@ public class CreditSuspectedRelationshipController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditSuspectedRelationship:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditSuspectedRelationshipService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditSuspectedRelationship::getId,
+            CreditSuspectedRelationship::setId,
+            CreditSuspectedRelationship::getName,
+            CreditSuspectedRelationship::getCompanyId,
+            CreditSuspectedRelationship::setCompanyId,
+            CreditSuspectedRelationship::getHasData,
+            CreditSuspectedRelationship::setHasData,
+            CreditSuspectedRelationship::getTenantId,
+            CreditSuspectedRelationship::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入疑似关系
      */
@@ -143,6 +192,7 @@ public class CreditSuspectedRelationshipController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditSuspectedRelationshipImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -206,6 +256,10 @@ public class CreditSuspectedRelationshipController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -412,6 +466,8 @@ public class CreditSuspectedRelationshipController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.SUSPECTED_RELATIONSHIP, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditUserController.java

@@ -14,6 +14,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditUser;
 import com.gxwebsoft.credit.param.CreditUserImportParam;
 import com.gxwebsoft.credit.param.CreditUserParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditUserService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -36,8 +38,10 @@ import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 招投标信息表控制器
@@ -57,6 +61,12 @@ public class CreditUserController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询招投标信息表")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditUser>> page(CreditUserParam param) {
@@ -144,6 +154,45 @@ public class CreditUserController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditUser:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditUserService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditUser::getId,
+            CreditUser::setId,
+            CreditUser::getWinningName,
+            CreditUser::getCompanyId,
+            CreditUser::setCompanyId,
+            CreditUser::getHasData,
+            CreditUser::setHasData,
+            CreditUser::getTenantId,
+            CreditUser::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入招投标信息
      * Excel表头格式：客户名称、唯一标识、类型、企业角色、上级ID、信息类型、所在国家、所在省份、所在城市、所在辖区、街道地址、招采单位名称、中标单位名称、中标金额、备注、是否推荐、到期时间、排序、状态、用户ID、租户ID
@@ -155,6 +204,7 @@ public class CreditUserController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             int sheetIndex = ExcelImportSupport.findSheetIndex(file, "招投标", 0);
@@ -197,6 +247,9 @@ public class CreditUserController extends BaseController {
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
 
                     // 设置默认值
                     if (item.getUserId() == null && currentUserId != null) {
@@ -302,6 +355,8 @@ public class CreditUserController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.USER, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {

src/main/java/com/gxwebsoft/credit/controller/CreditXgxfController.java

@@ -7,8 +7,10 @@ import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditXgxf;
-import com.gxwebsoft.credit.param.CreditJudicialImportParam;
+import com.gxwebsoft.credit.param.CreditXgxfImportParam;
 import com.gxwebsoft.credit.param.CreditXgxfParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditXgxfService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,7 +24,11 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 限制高消费控制器
@@ -40,6 +46,12 @@ public class CreditXgxfController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询限制高消费")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditXgxf>> page(CreditXgxfParam param) {
@@ -132,6 +144,49 @@ public class CreditXgxfController extends BaseController {
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditXgxf:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        // Party columns may contain multiple roles/names; match if any company name is contained in the text.
+        // Priority: 原告/上诉人 > 被告/被上诉人 > 其他当事人/第三人
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyNameContainedInText(
+            creditXgxfService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditXgxf::getId,
+            CreditXgxf::setId,
+            CreditXgxf::getCompanyId,
+            CreditXgxf::setCompanyId,
+            CreditXgxf::getHasData,
+            CreditXgxf::setHasData,
+            CreditXgxf::getTenantId,
+            CreditXgxf::new,
+            CreditXgxf::getPlaintiffAppellant,
+            CreditXgxf::getAppellee,
+            CreditXgxf::getOtherPartiesThirdParty
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入限制高消费司法大数据
      */
@@ -142,13 +197,16 @@ public class CreditXgxfController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
-            ExcelImportSupport.ImportResult<CreditJudicialImportParam> importResult = ExcelImportSupport.read(
-                file, CreditJudicialImportParam.class, this::isEmptyImportRow);
-            List<CreditJudicialImportParam> list = importResult.getData();
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "限制高消费", 0);
+            ExcelImportSupport.ImportResult<CreditXgxfImportParam> importResult = ExcelImportSupport.read(
+                file, CreditXgxfImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditXgxfImportParam> list = importResult.getData();
             int usedTitleRows = importResult.getTitleRows();
             int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
 
             if (CollectionUtils.isEmpty(list)) {
                 return fail("未读取到数据，请确认模板表头与示例格式一致", null);
@@ -157,6 +215,8 @@ public class CreditXgxfController extends BaseController {
             User loginUser = getLoginUser();
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            // easypoi 默认不会读取单元格超链接地址；url 可能挂在“案号”等列的超链接中，或单独提供 url/网址/链接 列。
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -164,13 +224,22 @@ public class CreditXgxfController extends BaseController {
             List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
 
             for (int i = 0; i < list.size(); i++) {
-                CreditJudicialImportParam param = list.get(i);
+                CreditXgxfImportParam param = list.get(i);
                 try {
                     CreditXgxf item = convertImportParamToEntity(param);
+                    if (!ImportHelper.isBlank(item.getCaseNumber())) {
+                        String link = urlByCaseNumber.get(item.getCaseNumber().trim());
+                        if (!ImportHelper.isBlank(link)) {
+                            item.setUrl(link.trim());
+                        }
+                    }
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -193,6 +262,10 @@ public class CreditXgxfController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
@@ -277,6 +350,8 @@ public class CreditXgxfController extends BaseController {
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.XGXF, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -288,29 +363,231 @@ public class CreditXgxfController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史限制高消费（仅解析“历史限制高消费”选项卡）
+     * 规则：案号相同则覆盖更新（recommend++ 记录更新次数）；案号不存在则插入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditXgxf:save')")
+    @Operation(summary = "批量导入历史限制高消费司法大数据")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史限制高消费");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史限制高消费”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditXgxfImportParam> importResult = ExcelImportSupport.read(
+                file, CreditXgxfImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditXgxfImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCaseNumber = ExcelImportSupport.readUrlByKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+
+            LinkedHashMap<String, CreditXgxf> latestByCaseNumber = new LinkedHashMap<>();
+            LinkedHashMap<String, Integer> latestRowByCaseNumber = new LinkedHashMap<>();
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditXgxfImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditXgxf item = convertImportParamToEntity(param);
+                    if (item.getCaseNumber() != null) {
+                        item.setCaseNumber(item.getCaseNumber().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCaseNumber())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = urlByCaseNumber.get(item.getCaseNumber());
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    latestByCaseNumber.put(item.getCaseNumber(), item);
+                    latestRowByCaseNumber.put(item.getCaseNumber(), excelRowNumber);
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (latestByCaseNumber.isEmpty()) {
+                if (errorMessages.isEmpty()) {
+                    return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+                }
+                return success("导入完成，成功0条，失败" + errorMessages.size() + "条", errorMessages);
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditXgxf> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (Map.Entry<String, CreditXgxf> entry : latestByCaseNumber.entrySet()) {
+                String caseNumber = entry.getKey();
+                CreditXgxf item = entry.getValue();
+                Integer rowNo = latestRowByCaseNumber.get(caseNumber);
+                chunkItems.add(item);
+                chunkRowNumbers.add(rowNo != null ? rowNo : -1);
+                if (chunkItems.size() >= chunkSize) {
+                    successCount += batchImportSupport.persistChunkWithFallback(
+                        chunkItems,
+                        chunkRowNumbers,
+                        () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                            creditXgxfService,
+                            chunkItems,
+                            CreditXgxf::getId,
+                            CreditXgxf::setId,
+                            CreditXgxf::getCaseNumber,
+                            CreditXgxf::getCaseNumber,
+                            CreditXgxf::getRecommend,
+                            CreditXgxf::setRecommend,
+                            null,
+                            mpBatchSize
+                        ),
+                        (rowItem, rowNumber) -> {
+                            if (rowItem.getRecommend() == null) {
+                                rowItem.setRecommend(0);
+                            }
+                            boolean saved = creditXgxfService.save(rowItem);
+                            if (!saved) {
+                                CreditXgxf existing = creditXgxfService.lambdaQuery()
+                                    .eq(CreditXgxf::getCaseNumber, rowItem.getCaseNumber())
+                                    .select(CreditXgxf::getId, CreditXgxf::getRecommend)
+                                    .one();
+                                if (existing != null) {
+                                    rowItem.setId(existing.getId());
+                                    Integer old = existing.getRecommend();
+                                    rowItem.setRecommend(old == null ? 1 : old + 1);
+                                    if (creditXgxfService.updateById(rowItem)) {
+                                        return true;
+                                    }
+                                }
+                            } else {
+                                return true;
+                            }
+                            String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                            errorMessages.add(prefix + "保存失败");
+                            return false;
+                        },
+                        errorMessages
+                    );
+                    chunkItems.clear();
+                    chunkRowNumbers.clear();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistChunkWithFallback(
+                    chunkItems,
+                    chunkRowNumbers,
+                    () -> batchImportSupport.upsertBySingleKeyAndIncrementCounterOnUpdate(
+                        creditXgxfService,
+                        chunkItems,
+                        CreditXgxf::getId,
+                        CreditXgxf::setId,
+                        CreditXgxf::getCaseNumber,
+                        CreditXgxf::getCaseNumber,
+                        CreditXgxf::getRecommend,
+                        CreditXgxf::setRecommend,
+                        null,
+                        mpBatchSize
+                    ),
+                    (rowItem, rowNumber) -> {
+                        if (rowItem.getRecommend() == null) {
+                            rowItem.setRecommend(0);
+                        }
+                        boolean saved = creditXgxfService.save(rowItem);
+                        if (!saved) {
+                            CreditXgxf existing = creditXgxfService.lambdaQuery()
+                                .eq(CreditXgxf::getCaseNumber, rowItem.getCaseNumber())
+                                .select(CreditXgxf::getId, CreditXgxf::getRecommend)
+                                .one();
+                            if (existing != null) {
+                                rowItem.setId(existing.getId());
+                                Integer old = existing.getRecommend();
+                                rowItem.setRecommend(old == null ? 1 : old + 1);
+                                if (creditXgxfService.updateById(rowItem)) {
+                                    return true;
+                                }
+                            }
+                        } else {
+                            return true;
+                        }
+                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
+                        errorMessages.add(prefix + "保存失败");
+                        return false;
+                    },
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.XGXF, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载限制高消费导入模板
      */
     @Operation(summary = "下载限制高消费导入模板")
     @GetMapping("/import/template")
     public void downloadTemplate(HttpServletResponse response) throws IOException {
-        List<CreditJudicialImportParam> templateList = new ArrayList<>();
+        List<CreditXgxfImportParam> templateList = new ArrayList<>();
 
-        CreditJudicialImportParam example = new CreditJudicialImportParam();
+        CreditXgxfImportParam example = new CreditXgxfImportParam();
         example.setDataType("限制高消费");
         example.setPlaintiffAppellant("原告示例");
         example.setAppellee("被告示例");
-        example.setOtherPartiesThirdParty("第三人示例");
         example.setOccurrenceTime("2024-01-01");
         example.setCaseNumber("（2024）示例案号");
-        example.setCauseOfAction("案由示例");
         example.setInvolvedAmount("100000");
         example.setCourtName("示例法院");
-        example.setDataStatus("已公开");
         example.setComments("备注信息");
         templateList.add(example);
 
-        Workbook workbook = ExcelImportSupport.buildTemplate("限制高消费导入模板", "限制高消费", CreditJudicialImportParam.class, templateList);
+        Workbook workbook = ExcelImportSupport.buildTemplate("限制高消费导入模板", "限制高消费", CreditXgxfImportParam.class, templateList);
 
         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
         response.setHeader("Content-Disposition", "attachment; filename=credit_xgxf_import_template.xlsx");
@@ -319,29 +596,31 @@ public class CreditXgxfController extends BaseController {
         workbook.close();
     }
 
-    private boolean isEmptyImportRow(CreditJudicialImportParam param) {
+    private boolean isEmptyImportRow(CreditXgxfImportParam param) {
         if (param == null) {
             return true;
         }
-        return ImportHelper.isBlank(param.getCaseNumber())
-            && ImportHelper.isBlank(param.getPlaintiffAppellant())
-            && ImportHelper.isBlank(param.getAppellee())
-            && ImportHelper.isBlank(param.getCauseOfAction());
+        return ImportHelper.isBlank(param.getCaseNumber());
     }
 
-    private CreditXgxf convertImportParamToEntity(CreditJudicialImportParam param) {
+    private CreditXgxf convertImportParamToEntity(CreditXgxfImportParam param) {
         CreditXgxf entity = new CreditXgxf();
 
+        entity.setCaseNumber(param.getCaseNumber());
+        entity.setType(param.getType());
         entity.setDataType(param.getDataType());
         entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
         entity.setAppellee(param.getAppellee());
         entity.setOtherPartiesThirdParty(param.getOtherPartiesThirdParty());
-        entity.setOccurrenceTime(param.getOccurrenceTime());
-        entity.setCaseNumber(param.getCaseNumber());
-        entity.setCauseOfAction(param.getCauseOfAction());
-        entity.setInvolvedAmount(param.getInvolvedAmount());
-        entity.setCourtName(param.getCourtName());
+        entity.setPlaintiffAppellant(param.getPlaintiffAppellant());
         entity.setDataStatus(param.getDataStatus());
+        entity.setAppellee(param.getAppellee());
+
+        // 兼容不同模板字段：如果 *2 有值则以 *2 为准写入主字段
+        entity.setInvolvedAmount(param.getInvolvedAmount());
+        entity.setOccurrenceTime(param.getOccurrenceTime());
+        entity.setCourtName(param.getCourtName());
+        entity.setReleaseDate(param.getReleaseDate());
         entity.setComments(param.getComments());
 
         return entity;

src/main/java/com/gxwebsoft/credit/controller/ExcelImportSupport.java

@@ -15,6 +15,8 @@ import org.apache.poi.ss.usermodel.WorkbookFactory;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.multipart.MultipartFile;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.util.Collections;
 import java.util.HashMap;
@@ -114,15 +116,55 @@ public class ExcelImportSupport {
         int usedTitleRows = 0;
         int usedHeadRows = 0;
         int[][] tryConfigs = new int[][]{{1, 1}, {0, 1}, {2, 1}, {3, 1}, {0, 2}, {0, 3}, {0, 4}};
+        Exception lastFailure = null;
+        boolean anyImported = false;
 
         for (int[] config : tryConfigs) {
-            list = filterEmptyRows(importSheet(file, clazz, config[0], config[1], sheetIndex), emptyRowPredicate);
+            try {
+                list = filterEmptyRows(importSheet(file, clazz, config[0], config[1], sheetIndex), emptyRowPredicate);
+                anyImported = true;
+            } catch (Exception e) {
+                // Some source files can trigger easypoi/POI runtime exceptions for certain title/head row combinations.
+                // Keep trying other configurations instead of failing the whole import.
+                lastFailure = e;
+                continue;
+            }
             if (!CollectionUtils.isEmpty(list)) {
                 usedTitleRows = config[0];
                 usedHeadRows = config[1];
                 break;
             }
         }
+
+        // Fallback for upstream files with extra banner/title rows or wider multi-row headers.
+        // Keep the default fast path above for common templates.
+        if (CollectionUtils.isEmpty(list)) {
+            final int maxTitleRows = 10;
+            final int maxHeadRows = 6;
+            outer:
+            for (int titleRows = 0; titleRows <= maxTitleRows; titleRows++) {
+                for (int headRows = 1; headRows <= maxHeadRows; headRows++) {
+                    try {
+                        list = filterEmptyRows(importSheet(file, clazz, titleRows, headRows, sheetIndex), emptyRowPredicate);
+                        anyImported = true;
+                    } catch (Exception e) {
+                        lastFailure = e;
+                        continue;
+                    }
+                    if (!CollectionUtils.isEmpty(list)) {
+                        usedTitleRows = titleRows;
+                        usedHeadRows = headRows;
+                        break outer;
+                    }
+                }
+            }
+        }
+        if (list == null) {
+            if (!anyImported && lastFailure != null) {
+                throw lastFailure;
+            }
+            list = Collections.emptyList();
+        }
         return new ImportResult<>(list, usedTitleRows, usedHeadRows, sheetIndex);
     }
 
@@ -135,11 +177,20 @@ public class ExcelImportSupport {
         int bestHeadRows = 0;
         int bestScore = -1;
         int bestSize = -1;
+        Exception lastFailure = null;
+        boolean anyImported = false;
 
         int[][] tryConfigs = new int[][]{{1, 1}, {0, 1}, {2, 1}, {3, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 2}, {1, 3}, {1, 4}, {2, 2}, {2, 3}, {2, 4}, {3, 2}, {3, 3}, {3, 4}};
 
         for (int[] config : tryConfigs) {
-            List<T> list = filterEmptyRows(importSheet(file, clazz, config[0], config[1], sheetIndex), emptyRowPredicate);
+            List<T> list;
+            try {
+                list = filterEmptyRows(importSheet(file, clazz, config[0], config[1], sheetIndex), emptyRowPredicate);
+                anyImported = true;
+            } catch (Exception e) {
+                lastFailure = e;
+                continue;
+            }
             if (CollectionUtils.isEmpty(list)) {
                 continue;
             }
@@ -163,10 +214,52 @@ public class ExcelImportSupport {
             }
         }
 
+        // Fallback scan: broaden the search space for messy source files (extra title rows, multi-row headers).
+        if (bestList == null) {
+            final int maxTitleRows = 10;
+            final int maxHeadRows = 6;
+            for (int titleRows = 0; titleRows <= maxTitleRows; titleRows++) {
+                for (int headRows = 1; headRows <= maxHeadRows; headRows++) {
+                    List<T> list;
+                    try {
+                        list = filterEmptyRows(importSheet(file, clazz, titleRows, headRows, sheetIndex), emptyRowPredicate);
+                        anyImported = true;
+                    } catch (Exception e) {
+                        lastFailure = e;
+                        continue;
+                    }
+                    if (CollectionUtils.isEmpty(list)) {
+                        continue;
+                    }
+
+                    int score = 0;
+                    if (scoreRowPredicate != null) {
+                        for (T row : list) {
+                            if (scoreRowPredicate.test(row)) {
+                                score++;
+                            }
+                        }
+                    }
+
+                    int size = list.size();
+                    if (score > bestScore || (score == bestScore && size > bestSize)) {
+                        bestList = list;
+                        bestTitleRows = titleRows;
+                        bestHeadRows = headRows;
+                        bestScore = score;
+                        bestSize = size;
+                    }
+                }
+            }
+        }
+
         if (bestList != null) {
             return new ImportResult<>(bestList, bestTitleRows, bestHeadRows, sheetIndex);
         }
 
+        if (!anyImported && lastFailure != null) {
+            throw lastFailure;
+        }
         return read(file, clazz, emptyRowPredicate, sheetIndex);
     }
 
@@ -176,7 +269,76 @@ public class ExcelImportSupport {
         importParams.setHeadRows(headRows);
         importParams.setStartSheetIndex(sheetIndex);
         importParams.setSheetNum(1);
-        return ExcelImportUtil.importExcel(file.getInputStream(), clazz, importParams);
+
+        // Easypoi matches headers by exact string. Some upstream files contain extra spaces/tabs/newlines in header cells
+        // (e.g. "原告 / 上诉人" or "原告/上诉人\t"), which makes specific columns silently not mapped.
+        // Normalize header cells first to make imports robust.
+        try (InputStream is = file.getInputStream(); Workbook workbook = WorkbookFactory.create(is)) {
+            if (workbook.getNumberOfSheets() > sheetIndex) {
+                Sheet sheet = workbook.getSheetAt(sheetIndex);
+                if (sheet != null) {
+                    normalizeHeaderCells(sheet, titleRows, headRows);
+                }
+            }
+            try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
+                workbook.write(bos);
+                try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray())) {
+                    return ExcelImportUtil.importExcel(bis, clazz, importParams);
+                }
+            }
+        }
+    }
+
+    private static void normalizeHeaderCells(Sheet sheet, int titleRows, int headRows) {
+        if (sheet == null || headRows <= 0) {
+            return;
+        }
+        int headerStart = Math.max(titleRows, 0);
+        int headerEnd = headerStart + headRows - 1;
+        for (int r = headerStart; r <= headerEnd; r++) {
+            Row row = sheet.getRow(r);
+            if (row == null) {
+                continue;
+            }
+            short last = row.getLastCellNum();
+            for (int c = 0; c < last; c++) {
+                Cell cell = row.getCell(c);
+                if (cell == null) {
+                    continue;
+                }
+
+                String text = null;
+                CellType type = cell.getCellType();
+                if (type == CellType.STRING) {
+                    text = cell.getStringCellValue();
+                } else if (type == CellType.FORMULA && cell.getCachedFormulaResultType() == CellType.STRING) {
+                    text = cell.getStringCellValue();
+                } else {
+                    continue;
+                }
+
+                String normalized = normalizeHeaderText(text);
+                if (normalized != null && !normalized.equals(text)) {
+                    cell.setCellValue(normalized);
+                }
+            }
+        }
+    }
+
+    private static String normalizeHeaderText(String text) {
+        if (text == null) {
+            return null;
+        }
+        // Remove common invisible whitespace characters, including full-width space.
+        return text
+            .replace("／", "/")
+            .replace(" ", "")
+            .replace("\t", "")
+            .replace("\r", "")
+            .replace("\n", "")
+            .replace("\u00A0", "")
+            .replace("　", "")
+            .trim();
     }
 
     private static <T> List<T> filterEmptyRows(List<T> rawList, Predicate<T> emptyRowPredicate) {
@@ -287,6 +449,109 @@ public class ExcelImportSupport {
         }
     }
 
+    /**
+     * 读取两列（由表头名定位）的文本/超链接，返回：key列显示值 -> value列（优先超链接地址，其次单元格文本）。
+     *
+     * <p>适用于：Excel 把 url 放在单独一列（可能是纯文本，也可能是超链接）。</p>
+     */
+    public static Map<String, String> readKeyValueByHeaders(MultipartFile file,
+                                                            int sheetIndex,
+                                                            int titleRows,
+                                                            int headRows,
+                                                            String keyHeaderName,
+                                                            String valueHeaderName) throws Exception {
+        if (file == null
+            || keyHeaderName == null || keyHeaderName.trim().isEmpty()
+            || valueHeaderName == null || valueHeaderName.trim().isEmpty()) {
+            return Collections.emptyMap();
+        }
+
+        try (InputStream is = file.getInputStream(); Workbook workbook = WorkbookFactory.create(is)) {
+            if (workbook.getNumberOfSheets() <= sheetIndex) {
+                return Collections.emptyMap();
+            }
+            Sheet sheet = workbook.getSheetAt(sheetIndex);
+            if (sheet == null) {
+                return Collections.emptyMap();
+            }
+
+            int keyCol = findColumnIndexByHeader(sheet, titleRows, headRows, keyHeaderName);
+            int valCol = findColumnIndexByHeader(sheet, titleRows, headRows, valueHeaderName);
+            if (keyCol < 0 || valCol < 0) {
+                return Collections.emptyMap();
+            }
+
+            Map<String, String> result = new HashMap<>();
+            DataFormatter formatter = new DataFormatter();
+            int dataStartRow = titleRows + headRows;
+            for (int r = dataStartRow; r <= sheet.getLastRowNum(); r++) {
+                Row row = sheet.getRow(r);
+                if (row == null) {
+                    continue;
+                }
+                Cell keyCell = row.getCell(keyCol);
+                if (keyCell == null) {
+                    continue;
+                }
+                String key = formatter.formatCellValue(keyCell);
+                if (key == null || key.trim().isEmpty()) {
+                    continue;
+                }
+
+                Cell valCell = row.getCell(valCol);
+                if (valCell == null) {
+                    continue;
+                }
+                String value = extractHyperlinkAddress(valCell);
+                if (value == null || value.trim().isEmpty()) {
+                    value = formatter.formatCellValue(valCell);
+                }
+                if (value == null || value.trim().isEmpty()) {
+                    continue;
+                }
+                result.put(key.trim(), value.trim());
+            }
+            return result;
+        }
+    }
+
+    /**
+     * 读取“key列 -> url”的映射：
+     * - 优先读取 key 列自身的超链接（url 常挂在名称/案号等列的超链接里）
+     * - 如果源文件提供独立的 url/URL/网址/链接/链接地址 等列，则读取该列（支持文本或超链接）
+     */
+    public static Map<String, String> readUrlByKey(MultipartFile file,
+                                                   int sheetIndex,
+                                                   int titleRows,
+                                                   int headRows,
+                                                   String keyHeaderName) throws Exception {
+        if (file == null || keyHeaderName == null || keyHeaderName.trim().isEmpty()) {
+            return Collections.emptyMap();
+        }
+
+        Map<String, String> result = new HashMap<>();
+
+        // 1) url 挂在 key 列超链接里（最常见）
+        Map<String, String> fromKeyHyperlinks = readHyperlinksByHeaderKey(file, sheetIndex, titleRows, headRows, keyHeaderName);
+        if (!fromKeyHyperlinks.isEmpty()) {
+            result.putAll(fromKeyHyperlinks);
+        }
+
+        // 2) url 作为单独一列（多种表头命名）
+        String[] urlHeaders = new String[]{"url", "URL", "网址", "链接", "链接地址"};
+        for (String urlHeader : urlHeaders) {
+            Map<String, String> fromUrlCol = readKeyValueByHeaders(file, sheetIndex, titleRows, headRows, keyHeaderName, urlHeader);
+            if (fromUrlCol.isEmpty()) {
+                continue;
+            }
+            for (Map.Entry<String, String> entry : fromUrlCol.entrySet()) {
+                // 不覆盖已从 key 超链接读取到的地址
+                result.putIfAbsent(entry.getKey(), entry.getValue());
+            }
+        }
+        return result;
+    }
+
     private static int findColumnIndexByHeader(Sheet sheet, int titleRows, int headRows, String headerName) {
         int firstHeaderRow = Math.max(0, titleRows);
         int lastHeaderRow = Math.max(0, titleRows + headRows - 1);

src/main/java/com/gxwebsoft/credit/entity/CreditAdministrativeLicense.java

@@ -37,7 +37,7 @@ public class CreditAdministrativeLicense implements Serializable {
     @Schema(description = "许可状态")
     private String statusText;
 
-    @Schema(description = "许可类型")
+    @Schema(description = "许可类别")
     private String type;
 
     @Schema(description = "链接")
@@ -59,12 +59,22 @@ public class CreditAdministrativeLicense implements Serializable {
     @Schema(description = "数据来源单位")
     private String dataSourceUnit;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
+    @Schema(description = "数据状态")
+    private String dataStatus;
+
     @Schema(description = "备注")
     private String comments;
 
     @Schema(description = "企业ID")
     private Integer companyId;
 
+    @Schema(description = "主体企业")
+    @TableField(exist = false)
+    private String companyName;
+
     @Schema(description = "是否推荐")
     private Integer recommend;
 
@@ -81,6 +91,10 @@ public class CreditAdministrativeLicense implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditBankruptcy.java

@@ -1,6 +1,7 @@
 package com.gxwebsoft.credit.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -45,12 +46,19 @@ public class CreditBankruptcy implements Serializable {
     @Schema(description = "公开日期")
     private String publicDate;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
     @Schema(description = "企业ID")
     private Integer companyId;
 
+    @Schema(description = "主体企业")
+    @TableField(exist = false)
+    private String companyName;
+
     @Schema(description = "是否推荐")
     private Integer recommend;
 
@@ -67,6 +75,10 @@ public class CreditBankruptcy implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditBranch.java

@@ -1,6 +1,7 @@
 package com.gxwebsoft.credit.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -45,12 +46,19 @@ public class CreditBranch implements Serializable {
     @Schema(description = "状态")
     private String statusText;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
     @Schema(description = "企业ID")
     private Integer companyId;
 
+    @Schema(description = "主题企业")
+    @TableField(exist = false)
+    private String companyName;
+
     @Schema(description = "是否推荐")
     private Integer recommend;
 
@@ -67,6 +75,10 @@ public class CreditBranch implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditBreachOfTrust.java

@@ -30,34 +30,39 @@ public class CreditBreachOfTrust implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
+    @Schema(description = "案号")
+    private String caseNumber;
+
+    @Schema(description = "失信被执行人")
+    private String plaintiffAppellant;
+
+    @Schema(description = "疑似申请执行人")
+    private String appellee;
+
+    @Schema(description = "涉案金额(元)")
+    private String involvedAmount;
+
+    @Schema(description = "执行法院")
+    private String courtName;
+
+    @Schema(description = "立案日期")
+    private String occurrenceTime;
+
+    @Schema(description = "发布日期")
+    private String releaseDate;
+
     @Schema(description = "数据类型")
     private String dataType;
 
-    @Schema(description = "原告/上诉人")
-    private String plaintiffAppellant;
-
-    @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
-    private String appellee;
+    @Schema(description = "链接地址")
+    private String url;
 
     @Schema(description = "其他当事人/第三人")
     private String otherPartiesThirdParty;
 
-    @Schema(description = "发生时间")
-    private String occurrenceTime;
-
-    @Schema(description = "案号")
-    private String caseNumber;
-
     @Schema(description = "案由")
     private String causeOfAction;
 
-    @Schema(description = "涉案金额")
-    private String involvedAmount;
-
-    @Schema(description = "法院")
-    private String courtName;
-
     @Schema(description = "数据状态")
     private String dataStatus;
 
@@ -68,6 +73,9 @@ public class CreditBreachOfTrust implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +95,10 @@ public class CreditBreachOfTrust implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditCaseFiling.java

@@ -37,18 +37,20 @@ public class CreditCaseFiling implements Serializable {
     private String plaintiffAppellant;
 
     @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
     private String appellee;
 
     @Schema(description = "其他当事人/第三人")
     private String otherPartiesThirdParty;
 
-    @Schema(description = "发生时间")
+    @Schema(description = "立案日期")
     private String occurrenceTime;
 
     @Schema(description = "案号")
     private String caseNumber;
 
+    @Schema(description = "项目网址")
+    private String url;
+
     @Schema(description = "案由")
     private String causeOfAction;
 
@@ -68,6 +70,9 @@ public class CreditCaseFiling implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditCaseFiling implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditCompany.java

@@ -1,6 +1,7 @@
 package com.gxwebsoft.credit.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -33,18 +34,6 @@ public class CreditCompany implements Serializable {
     @Schema(description = "系统匹配企业名称")
     private String matchName;
 
-    @Schema(description = "统一社会信用代码")
-    private String code;
-
-    @Schema(description = "项目网址")
-    private String url;
-
-    @Schema(description = "类型")
-    private Integer type;
-
-    @Schema(description = "上级id, 0是顶级")
-    private Integer parentId;
-
     @Schema(description = "登记状态")
     private String registrationStatus;
 
@@ -60,9 +49,21 @@ public class CreditCompany implements Serializable {
     @Schema(description = "成立日期")
     private String establishDate;
 
+    @Schema(description = "统一社会信用代码")
+    private String code;
+
     @Schema(description = "企业地址")
     private String address;
 
+    @Schema(description = "所属省份")
+    private String province;
+
+    @Schema(description = "所属城市")
+    private String city;
+
+    @Schema(description = "所属区县")
+    private String region;
+
     @Schema(description = "电话")
     private String tel;
 
@@ -75,18 +76,6 @@ public class CreditCompany implements Serializable {
     @Schema(description = "更多邮箱")
     private String moreEmail;
 
-    @Schema(description = "所在国家")
-    private String country;
-
-    @Schema(description = "所属省份")
-    private String province;
-
-    @Schema(description = "所属城市")
-    private String city;
-
-    @Schema(description = "所属区县")
-    private String region;
-
     @Schema(description = "企业（机构）类型")
     private String institutionType;
 
@@ -180,6 +169,94 @@ public class CreditCompany implements Serializable {
     @Schema(description = "是否小微企业")
     private String smallEnterprise;
 
+
+    @Schema(description = "项目网址")
+    private String url;
+
+    @Schema(description = "类型")
+    private Integer type;
+
+    @Schema(description = "上级id, 0是顶级")
+    private Integer parentId;
+
+    @Schema(description = "所在国家")
+    private String country;
+
+    @Schema(description = "记录数")
+    private Integer creditAdministrativeLicense;
+
+    @Schema(description = "记录数")
+    private Integer creditBankruptcy;
+
+    @Schema(description = "记录数")
+    private Integer creditBranch;
+
+    @Schema(description = "记录数")
+    private Integer creditBreachOfTrust;
+
+    @Schema(description = "记录数")
+    private Integer creditCaseFiling;
+
+    @Schema(description = "记录数")
+    private Integer creditCompetitor;
+
+    @Schema(description = "记录数")
+    private Integer creditCourtAnnouncement;
+
+    @Schema(description = "记录数")
+    private Integer creditCourtSession;
+
+    @Schema(description = "记录数")
+    private Integer creditCustomer;
+
+    @Schema(description = "记录数")
+    private Integer creditDeliveryNotice;
+
+    @Schema(description = "记录数")
+    private Integer creditExternal;
+
+    @Schema(description = "记录数")
+    private Integer creditFinalVersion;
+
+    @Schema(description = "记录数")
+    private Integer creditGqdj;
+
+    @Schema(description = "记录数")
+    private Integer creditHistoricalLegalPerson;
+
+    @Schema(description = "记录数")
+    private Integer creditJudgmentDebtor;
+
+    @Schema(description = "记录数")
+    private Integer creditJudicialDocument;
+
+    @Schema(description = "记录数")
+    private Integer creditJudiciary;
+
+    @Schema(description = "记录数")
+    private Integer creditMediation;
+
+    @Schema(description = "记录数")
+    private Integer creditNearbyCompany;
+
+    @Schema(description = "记录数")
+    private Integer creditPatent;
+
+    @Schema(description = "记录数")
+    private Integer creditRiskRelation;
+
+    @Schema(description = "记录数")
+    private Integer creditSupplier;
+
+    @Schema(description = "记录数")
+    private Integer creditSuspectedRelationship;
+
+    @Schema(description = "记录数")
+    private Integer creditUser;
+
+    @Schema(description = "记录数")
+    private Integer creditXgxf;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -199,6 +276,10 @@ public class CreditCompany implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditCompetitor.java

@@ -31,7 +31,10 @@ public class CreditCompetitor implements Serializable {
     private Integer id;
 
     @Schema(description = "企业名称")
-    private String companyName;
+    private String name;
+
+    @Schema(description = "链接地址")
+    private String url;
 
     @Schema(description = "法定代表人")
     private String legalRepresentative;
@@ -52,12 +55,19 @@ public class CreditCompetitor implements Serializable {
     private String province;
 
     @Schema(description = "企业ID")
-  private Integer companyId;
+    private Integer companyId;
+
+    @Schema(description = "企业名称")
+    @TableField(exist = false)
+    private String companyName;
 
     @Schema(description = "所属企业名称")
     @TableField(exist = false)
     private String mainCompanyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -77,6 +87,10 @@ public class CreditCompetitor implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditCourtAnnouncement.java

@@ -30,28 +30,30 @@ public class CreditCourtAnnouncement implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
-    @Schema(description = "数据类型")
-    private String dataType;
-
-    @Schema(description = "原告/上诉人")
-    private String plaintiffAppellant;
-
-    @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
-    private String appellee;
-
-    @Schema(description = "其他当事人/第三人")
-    private String otherPartiesThirdParty;
-
-    @Schema(description = "发生时间")
-    private String occurrenceTime;
-
     @Schema(description = "案号")
     private String caseNumber;
 
     @Schema(description = "案由")
     private String causeOfAction;
 
+    @Schema(description = "当事人")
+    private String otherPartiesThirdParty;
+
+    @Schema(description = "公告类型")
+    private String dataType;
+
+    @Schema(description = "公告人")
+    private String plaintiffAppellant;
+
+    @Schema(description = "刊登日期")
+    private String occurrenceTime;
+
+    @Schema(description = "被告/被上诉人")
+    private String appellee;
+
+    @Schema(description = "链接地址")
+    private String url;
+
     @Schema(description = "涉案金额")
     private String involvedAmount;
 
@@ -68,6 +70,9 @@ public class CreditCourtAnnouncement implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditCourtAnnouncement implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditCourtSession.java

@@ -37,7 +37,6 @@ public class CreditCourtSession implements Serializable {
     private String plaintiffAppellant;
 
     @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
     private String appellee;
 
     @Schema(description = "其他当事人/第三人")
@@ -49,6 +48,9 @@ public class CreditCourtSession implements Serializable {
     @Schema(description = "案号")
     private String caseNumber;
 
+    @Schema(description = "链接地址")
+    private String url;
+
     @Schema(description = "案由")
     private String causeOfAction;
 
@@ -68,6 +70,9 @@ public class CreditCourtSession implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditCourtSession implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditCustomer.java

@@ -33,6 +33,9 @@ public class CreditCustomer implements Serializable {
     @Schema(description = "客户")
     private String name;
 
+    @Schema(description = "链接地址")
+    private String url;
+
     @Schema(description = "状态")
     private String statusTxt;
 
@@ -52,6 +55,9 @@ public class CreditCustomer implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -71,6 +77,10 @@ public class CreditCustomer implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditDeliveryNotice.java

@@ -30,6 +30,24 @@ public class CreditDeliveryNotice implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
+    @Schema(description = "案号")
+    private String caseNumber;
+
+    @Schema(description = "链接地址")
+    private String url;
+
+    @Schema(description = "案由")
+    private String causeOfAction;
+
+    @Schema(description = "当事人")
+    private String otherPartiesThirdParty;
+
+    @Schema(description = "法院")
+    private String courtName;
+
+    @Schema(description = "发布日期")
+    private String occurrenceTime;
+
     @Schema(description = "数据类型")
     private String dataType;
 
@@ -37,27 +55,11 @@ public class CreditDeliveryNotice implements Serializable {
     private String plaintiffAppellant;
 
     @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
     private String appellee;
 
-    @Schema(description = "其他当事人/第三人")
-    private String otherPartiesThirdParty;
-
-    @Schema(description = "发生时间")
-    private String occurrenceTime;
-
-    @Schema(description = "案号")
-    private String caseNumber;
-
-    @Schema(description = "案由")
-    private String causeOfAction;
-
     @Schema(description = "涉案金额")
     private String involvedAmount;
 
-    @Schema(description = "法院")
-    private String courtName;
-
     @Schema(description = "数据状态")
     private String dataStatus;
 
@@ -68,6 +70,9 @@ public class CreditDeliveryNotice implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditDeliveryNotice implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditExternal.java

@@ -33,10 +33,13 @@ public class CreditExternal implements Serializable {
     @Schema(description = "被投资企业名称")
     private String name;
 
-    @Schema(description = "企业状态（如存续、注销等）")
+    @Schema(description = "状态")
     private String statusTxt;
 
-    @Schema(description = "法定代表人姓名")
+    @Schema(description = "链接地址")
+    private String url;
+
+    @Schema(description = "法定代表人")
     private String legalRepresentative;
 
     @Schema(description = "注册资本（金额）")
@@ -79,6 +82,9 @@ public class CreditExternal implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -98,6 +104,10 @@ public class CreditExternal implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditFinalVersion.java

@@ -30,33 +30,35 @@ public class CreditFinalVersion implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
-    @Schema(description = "数据类型")
-    private String dataType;
+    @Schema(description = "案号")
+    private String caseNumber;
 
-    @Schema(description = "原告/上诉人")
+    @Schema(description = "链接地址")
+    private String url;
+
+    @Schema(description = "被执行人")
+    private String appellee;
+
+    @Schema(description = "疑似申请执行人")
     private String plaintiffAppellant;
 
-    @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
-    private String appellee;
+    @Schema(description = "未履行金额（元）")
+    private String unfulfilledAmount;
+
+    @Schema(description = "执行标的（元）")
+    private String involvedAmount;
 
     @Schema(description = "其他当事人/第三人")
     private String otherPartiesThirdParty;
 
-    @Schema(description = "发生时间")
+    @Schema(description = "执行法院")
+    private String courtName;
+
+    @Schema(description = "立案日期")
     private String occurrenceTime;
 
-    @Schema(description = "案号")
-    private String caseNumber;
-
-    @Schema(description = "案由")
-    private String causeOfAction;
-
-    @Schema(description = "涉案金额")
-    private String involvedAmount;
-
-    @Schema(description = "法院")
-    private String courtName;
+    @Schema(description = "终本日期")
+    private String finalDate;
 
     @Schema(description = "数据状态")
     private String dataStatus;
@@ -68,6 +70,9 @@ public class CreditFinalVersion implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditFinalVersion implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditGqdj.java

@@ -30,37 +30,39 @@ public class CreditGqdj implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
-    @Schema(description = "数据类型")
-    private String dataType;
+    @Schema(description = "执行通知文书号")
+    private String caseNumber;;
 
-    @Schema(description = "原告/上诉人")
-    private String plaintiffAppellant;
-
-    @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
+    @Schema(description = "被执行人")
     private String appellee;
 
-    @Schema(description = "其他当事人/第三人")
-    private String otherPartiesThirdParty;
+    @Schema(description = "冻结股权标的企业")
+    private String plaintiffAppellant;
 
-    @Schema(description = "发生时间")
-    private String occurrenceTime;
-
-    @Schema(description = "案号")
-    private String caseNumber;
-
-    @Schema(description = "案由")
-    private String causeOfAction;
-
-    @Schema(description = "涉案金额")
+    @Schema(description = "被执行人持有股权、其他投资权益数额")
     private String involvedAmount;
 
-    @Schema(description = "法院")
+    @Schema(description = "执行法院")
     private String courtName;
 
-    @Schema(description = "数据状态")
+    @Schema(description = "类型")
+    private String dataType;
+
+    @Schema(description = "状态")
     private String dataStatus;
 
+    @Schema(description = "详情链接")
+    private String url;
+
+    @Schema(description = "冻结日期自")
+    private String freezeDateStart;
+
+    @Schema(description = "冻结日期至")
+    private String freezeDateEnd;
+
+    @Schema(description = "公示日期")
+    private String publicDate;
+
     @Schema(description = "企业ID")
     private Integer companyId;
 
@@ -68,6 +70,9 @@ public class CreditGqdj implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditGqdj implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditHistoricalLegalPerson.java

@@ -1,6 +1,7 @@
 package com.gxwebsoft.credit.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -39,12 +40,19 @@ public class CreditHistoricalLegalPerson implements Serializable {
     @Schema(description = "链接")
     private String url;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
     @Schema(description = "企业ID")
     private Integer companyId;
 
+    @Schema(description = "主体企业")
+    @TableField(exist = false)
+    private String companyName;
+
     @Schema(description = "是否推荐")
     private Integer recommend;
 
@@ -61,6 +69,10 @@ public class CreditHistoricalLegalPerson implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditJudgmentDebtor.java

@@ -40,6 +40,15 @@ public class CreditJudgmentDebtor implements Serializable {
     @Schema(description = "被执行人")
     private String name1;
 
+    @Schema(description = "原告/上诉人")
+    private String plaintiffAppellant;
+
+    @Schema(description = "被告/被上诉人")
+    private String appellee;
+
+    @Schema(description = "其他当事人/第三人")
+    private String otherPartiesThirdParty;
+
     @Schema(description = "证件号/组织机构代码")
     private String code;
 
@@ -49,7 +58,7 @@ public class CreditJudgmentDebtor implements Serializable {
     @Schema(description = "发生时间")
     private String occurrenceTime;
 
-    @Schema(description = "执行标的(元)")
+    @Schema(description = "涉案金额")
     private String amount;
 
     @Schema(description = "法院")
@@ -65,6 +74,9 @@ public class CreditJudgmentDebtor implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -84,6 +96,10 @@ public class CreditJudgmentDebtor implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditJudicialDocument.java

@@ -30,31 +30,39 @@ public class CreditJudicialDocument implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
-    @Schema(description = "数据类型")
-    private String dataType;
+    @Schema(description = "文书标题")
+    private String title;
 
-    @Schema(description = "原告/上诉人")
-    private String plaintiffAppellant;
-
-    @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
-    private String appellee;
-
-    @Schema(description = "其他当事人/第三人")
-    private String otherPartiesThirdParty;
-
-    @Schema(description = "发生时间")
-    private String occurrenceTime;
+    @Schema(description = "文书类型")
+    private String type;
 
     @Schema(description = "案号")
     private String caseNumber;
 
+    @Schema(description = "链接地址")
+    private String url;
+
     @Schema(description = "案由")
     private String causeOfAction;
 
-    @Schema(description = "涉案金额")
+    @Schema(description = "当事人")
+    private String otherPartiesThirdParty;
+
+    @Schema(description = "案件金额（元）")
     private String involvedAmount;
 
+    @Schema(description = "裁判结果")
+    private String defendantAppellee;
+
+    @Schema(description = "裁判日期")
+    private String occurrenceTime;
+
+    @Schema(description = "发布日期")
+    private String releaseDate;
+
+    @Schema(description = "被告/被上诉人")
+    private String appellee;
+
     @Schema(description = "法院")
     private String courtName;
 
@@ -68,6 +76,9 @@ public class CreditJudicialDocument implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +98,10 @@ public class CreditJudicialDocument implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditJudiciary.java

@@ -34,6 +34,9 @@ public class CreditJudiciary implements Serializable {
     @Schema(description = "案号")
     private String code;
 
+    @Schema(description = "详情链接")
+    private String url;
+
     @Schema(description = "类型, 0普通用户, 1招投标")
     private Integer type;
 
@@ -83,6 +86,9 @@ public class CreditJudiciary implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -106,6 +112,10 @@ public class CreditJudiciary implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditMediation.java

@@ -37,7 +37,6 @@ public class CreditMediation implements Serializable {
     private String plaintiffAppellant;
 
     @Schema(description = "被告/被上诉人")
-    @TableField("Appellee")
     private String appellee;
 
     @Schema(description = "其他当事人/第三人")
@@ -49,6 +48,9 @@ public class CreditMediation implements Serializable {
     @Schema(description = "案号")
     private String caseNumber;
 
+    @Schema(description = "链接地址")
+    private String url;
+
     @Schema(description = "案由")
     private String causeOfAction;
 
@@ -68,6 +70,9 @@ public class CreditMediation implements Serializable {
     @TableField(exist = false)
     private String companyName;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -87,6 +92,10 @@ public class CreditMediation implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 
@@ -98,4 +107,8 @@ public class CreditMediation implements Serializable {
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime updateTime;
 
+    @Schema(description = "发生时间")
+    @TableField(exist = false)
+    private String occurrenceTime2;
+
 }

src/main/java/com/gxwebsoft/credit/entity/CreditNearbyCompany.java

@@ -1,6 +1,7 @@
 package com.gxwebsoft.credit.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -78,6 +79,10 @@ public class CreditNearbyCompany implements Serializable {
     @Schema(description = "企业ID")
     private Integer companyId;
 
+    @Schema(description = "主体企业")
+    @TableField(exist = false)
+    private String companyName;
+
     @Schema(description = "纳税人识别号")
     private String taxpayerCode;
 
@@ -189,6 +194,9 @@ public class CreditNearbyCompany implements Serializable {
     @Schema(description = "是否小微企业")
     private String smallEnterprise;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
@@ -208,6 +216,10 @@ public class CreditNearbyCompany implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;
 

src/main/java/com/gxwebsoft/credit/entity/CreditPatent.java

@@ -1,6 +1,7 @@
 package com.gxwebsoft.credit.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.fasterxml.jackson.annotation.JsonFormat;
@@ -57,12 +58,19 @@ public class CreditPatent implements Serializable {
     @Schema(description = "链接")
     private String url;
 
+    @Schema(description = "是否有数据")
+    private Boolean hasData;
+
     @Schema(description = "备注")
     private String comments;
 
     @Schema(description = "企业ID")
     private Integer companyId;
 
+    @Schema(description = "主体企业")
+    @TableField(exist = false)
+    private String companyName;
+
     @Schema(description = "是否推荐")
     private Integer recommend;
 
@@ -79,6 +87,10 @@ public class CreditPatent implements Serializable {
     @Schema(description = "用户ID")
     private Integer userId;
 
+    @Schema(description = "真实姓名")
+    @TableField(exist = false)
+    private String realName;
+
     @Schema(description = "租户id")
     private Integer tenantId;